jpmschweitzer/clide
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

T-128: delete IsolateClient / Backend / backend_entry.dart
test / unit + widget + golden + a11y (push) Failing after 37s
test / integration_test (xvfb) (push) Has been skipped
test / bundle smoke (xvfb 5s) (push) Has been skipped
test / daemon subprocess + web WASM smoke (push) Has been skipped
test / dart doc (lib API) (push) Failing after 29s

Browse Source 
Fifth slice of T-99. After T-127 the socket-loopback DaemonClient
is the only IPC path; the isolate-backed third implementation
(IsolateClient + Backend + backend_entry.dart) was never wired
through and has no remaining references. Removed wholesale; the
single service-registration site lives in main.dart's
buildDispatcher.

flutter analyze + the kernel and ipc suites stay green.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
jpmschweitzer
2026-05-19 12:06:54 +02:00
co-authored by Claude
parent 70c293b163
commit f987cd3bb1
6 changed files with 18 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/kernel/src/backend.dart
-138
View File
@@ -1,138 +0,0 @@
/// Manages the backend isolate lifecycle.
///
/// Two-phase boot:
/// 1. [Backend.spawn] — starts the isolate, resolves toolchain (binary checks only).
/// 2. [Backend.openProject] — initializes services for a specific project root.
library;
import 'dart:async';
import 'dart:isolate';
import 'package:clide/kernel/src/backend_entry.dart';
import 'package:clide/kernel/src/ipc/isolate_client.dart';
import 'package:clide/kernel/src/toolchain.dart';
class Backend {
Backend._({
required this.client,
required this.toolchain,
required SendPort backendRequestPort,
required Isolate isolate,
required ReceivePort receivePort,
}) : _backendRequestPort = backendRequestPort,
_isolate = isolate,
_receivePort = receivePort;
final IsolateClient client;
final Toolchain toolchain;
final SendPort _backendRequestPort;
final Isolate _isolate;
final ReceivePort _receivePort;
Completer<void>? _projectCompleter;
final Map<String, Completer<String?>> _validateCompleters = {};
int _validateId = 0;
/// Spawn the backend isolate. Returns when the toolchain is resolved.
/// No services are active yet — call [openProject] to activate.
static Future<Backend> spawn({
required IsolateClient Function(SendPort backendPort) clientFactory,
String? hintRoot,
}) async {
final receivePort = ReceivePort();
final completer = Completer<Backend>();
late final IsolateClient client;
late final Isolate isolate;
late final SendPort backendRequestPort;
late final Backend backend;
receivePort.listen((message) {
if (message is Map<String, Object?>) {
final type = message['type'] as String?;
if (type == 'ready') {
backendRequestPort = message['requestPort'] as SendPort;
client = clientFactory(backendRequestPort);
final tcData = message['toolchain'] as Map<String, Object?>;
final toolchain = Toolchain();
toolchain.applyResolved(ResolvedPaths(
git: tcData['git'] as String?,
pql: tcData['pql'] as String?,
tmux: tcData['tmux'] as String?,
shell: tcData['shell'] as String?,
gitEnv: (tcData['gitEnv'] as Map?)?.cast<String, String>(),
));
backend = Backend._(
client: client,
toolchain: toolchain,
backendRequestPort: backendRequestPort,
isolate: isolate,
receivePort: receivePort,
);
if (!completer.isCompleted) completer.complete(backend);
} else if (type == 'project.validated') {
final id = message['id'] as String;
final root = message['root'] as String?;
final c = backend._validateCompleters.remove(id);
if (c != null && !c.isCompleted) c.complete(root);
} else if (type == 'project.ready') {
// Update toolchain with project-specific paths.
final tcData = message['toolchain'] as Map<String, Object?>;
backend.toolchain.applyResolved(ResolvedPaths(
git: tcData['git'] as String?,
pql: tcData['pql'] as String?,
tmux: tcData['tmux'] as String?,
shell: tcData['shell'] as String?,
gitEnv: (tcData['gitEnv'] as Map?)?.cast<String, String>(),
));
backend._projectCompleter?.complete();
backend._projectCompleter = null;
} else {
// Response or event — forward to the client.
client.handleMessage(message);
}
}
});
isolate = await Isolate.spawn(
backendEntry,
BackendBootMessage(frontendPort: receivePort.sendPort, hintRoot: hintRoot),
);
return completer.future;
}
/// Validate a path as a git repo. Returns the repo root or null.
/// Runs git rev-parse in the backend isolate (no main-thread I/O).
Future<String?> validateProject(String path) {
final id = '${_validateId++}';
final c = Completer<String?>();
_validateCompleters[id] = c;
_backendRequestPort.send({
'type': 'project.validate',
'path': path,
'id': id,
});
return c.future;
}
/// Activate a project. The backend (re)initializes all services
/// for the given root directory. Returns when services are ready.
Future<void> openProject(String path) {
_projectCompleter = Completer<void>();
_backendRequestPort.send({
'type': 'project.open',
'path': path,
});
return _projectCompleter!.future;
}
/// Shut down the backend isolate.
void dispose() {
_isolate.kill(priority: Isolate.beforeNextEvent);
_receivePort.close();
}
}
lib/kernel/src/backend_entry.dart
-154
View File
@@ -1,154 +0,0 @@
/// Backend isolate entry point.
///
/// Two-phase boot:
/// 1. Resolve toolchain (find binaries) → report ready.
/// 2. On `project.open` message → initialize services for the project.
///
/// The dispatcher only registers command handlers after a project is
/// activated. IPC requests arriving before that get an error response.
library;
import 'dart:io';
import 'dart:isolate';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/src/daemon/dispatcher.dart';
import 'package:clide/src/daemon/editor_commands.dart';
import 'package:clide/src/daemon/files_commands.dart';
import 'package:clide/src/daemon/git_commands.dart';
import 'package:clide/src/daemon/pane_commands.dart';
import 'package:clide/src/daemon/pql_commands.dart';
import 'package:clide/src/editor/registry.dart' show EditorRegistry;
import 'package:clide/src/git/client.dart';
import 'package:clide/src/ipc/envelope.dart';
import 'package:clide/src/ipc/schema_v1.dart';
import 'package:clide/src/panes/event_sink.dart';
import 'package:clide/src/panes/registry.dart';
import 'package:clide/src/pql/client.dart';
/// Message sent from main isolate to bootstrap the backend.
class BackendBootMessage {
const BackendBootMessage({required this.frontendPort, this.hintRoot});
final SendPort frontendPort;
/// Optional path hint for initial toolchain resolution (e.g. CLIDE_PROJECT).
/// Used to find project-local binaries like dugite before a project opens.
final String? hintRoot;
}
/// Top-level entry point for the backend isolate.
void backendEntry(BackendBootMessage boot) {
final frontendPort = boot.frontendPort;
final requestPort = ReceivePort();
final eventSink = _IsolateEventSink(frontendPort);
final dispatcher = DaemonDispatcher();
late Toolchain toolchain;
// Phase 1: resolve toolchain — just find binaries, don't init services.
// Dugite is resolved against the install dir; per T-98 the project
// root is never inspected during toolchain resolution.
toolchain = Toolchain();
toolchain.applyResolved(resolveToolchainPaths());
// Listen for messages from the frontend.
requestPort.listen((message) async {
if (message is! Map<String, Object?>) return;
final type = message['type'] as String?;
if (type == 'project.validate') {
// Validate a path as a git repo. Runs git rev-parse in the backend
// isolate (safe from the merged thread). Returns the repo root or null.
final path = message['path'] as String;
final id = message['id'] as String;
try {
final r = await Process.run(toolchain.git, ['rev-parse', '--show-toplevel'], workingDirectory: path, environment: toolchain.gitEnv);
if (r.exitCode == 0) {
final root = (r.stdout as String).trim();
frontendPort.send({'type': 'project.validated', 'id': id, 'root': root});
} else {
frontendPort.send({'type': 'project.validated', 'id': id, 'root': null});
}
} catch (_) {
frontendPort.send({'type': 'project.validated', 'id': id, 'root': null});
}
} else if (type == 'project.open') {
// Phase 2: (re)initialize services for the given project.
final projectPath = message['path'] as String;
final workDir = Directory(projectPath);
// Re-resolve toolchain. Project path is not inspected (T-98);
// dugite still comes from the install dir + env override.
toolchain = Toolchain();
toolchain.applyResolved(resolveToolchainPaths());
// Clear existing handlers and re-register with new project.
dispatcher.clear();
final filesService = FilesService(root: workDir, events: eventSink);
registerFilesCommands(dispatcher, filesService);
final editorRegistry = EditorRegistry(events: eventSink, workspaceRoot: workDir);
registerEditorCommands(dispatcher, editorRegistry);
final gitClient = GitClient(toolchain: toolchain, workDir: workDir);
registerGitCommands(dispatcher, gitClient, eventSink);
final pql = PqlClient(workDir: workDir, toolchain: toolchain);
registerPqlCommands(dispatcher, pql);
final paneRegistry = PaneRegistry(events: eventSink);
registerPaneCommands(dispatcher, paneRegistry);
// Tell the frontend the project is active.
frontendPort.send({
'type': 'project.ready',
'path': projectPath,
'toolchain': _serializeToolchain(toolchain),
});
} else {
// IPC request — dispatch if we have handlers.
final req = IpcRequest.fromJson(message);
if (dispatcher.isEmpty) {
frontendPort.send(IpcResponse.err(
id: req.id,
error: IpcError(
code: IpcExitCode.toolError,
kind: IpcErrorKind.toolError,
message: 'No project active',
hint: 'Open a project first',
),
).toJson());
} else {
final resp = await dispatcher.dispatch(req);
frontendPort.send(resp.toJson());
}
}
});
// Send ready with toolchain state and request port.
frontendPort.send({
'type': 'ready',
'requestPort': requestPort.sendPort,
'toolchain': _serializeToolchain(toolchain),
});
}
Map<String, Object?> _serializeToolchain(Toolchain tc) => {
'git': tc.git,
'pql': tc.pql,
'tmux': tc.tmux,
'shell': tc.shell,
'gitEnv': tc.gitEnv,
'missing': tc.missing,
};
/// Sends IPC events to the frontend via SendPort.
class _IsolateEventSink implements DaemonEventSink {
_IsolateEventSink(this._port);
final SendPort _port;
@override
void emit(IpcEvent event) {
_port.send(event.toJson());
}
}
lib/kernel/src/ipc/isolate_client.dart
-71
View File
@@ -1,71 +0,0 @@
/// IPC client that sends requests to a backend isolate via SendPort.
///
/// Replaces [InProcessClient] for production use. The backend isolate
/// owns the [DaemonDispatcher] and all subprocess/file-I/O services.
/// Requests and responses travel as serialized Maps over SendPort,
/// reusing the existing IPC protocol (IpcRequest/IpcResponse/IpcEvent).
library;
import 'dart:async';
import 'dart:isolate';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/events/bus.dart';
import 'package:clide/kernel/src/events/types.dart';
import 'package:clide/kernel/src/ipc/client.dart';
class IsolateClient extends DaemonClient {
IsolateClient({
required super.log,
required super.events,
required SendPort backendPort,
}) : _backendPort = backendPort,
_events = events,
super(socketPath: '');
final SendPort _backendPort;
final DaemonBus _events;
/// The event bus that receives events from the backend.
DaemonBus get events => _events;
final Map<String, Completer<IpcResponse>> _pending = {};
int _nextId = 0;
/// Called by [Backend] to feed incoming messages from the backend isolate.
void handleMessage(Map<String, Object?> msg) {
final type = msg['type'] as String?;
switch (type) {
case 'response':
final resp = IpcResponse.fromJson(msg);
final c = _pending.remove(resp.id);
if (c != null && !c.isCompleted) c.complete(resp);
case 'event':
final evt = IpcEvent.fromJson(msg);
_events.emit(DaemonEvent(
subsystem: evt.subsystem,
kind: evt.kind,
data: evt.data,
ts: evt.timestamp,
));
}
}
@override
bool get isConnected => true;
@override
Future<void> start() async {}
@override
Future<void> stop() async {}
@override
Future<IpcResponse> request(String cmd, {Map<String, Object?> args = const {}}) {
final id = '${_nextId++}';
final req = IpcRequest(id: id, cmd: cmd, args: args);
final c = Completer<IpcResponse>();
_pending[id] = c;
_backendPort.send(req.toJson());
return c.future;
}
}