jpmschweitzerandClaude
235cbcc046
First real content for the `clide` Dart package at the repo root.
One AOT-compiled binary (ADR 0005) with two modes:
* `clide --daemon` long-running unix-socket server; listens on
`$XDG_RUNTIME_DIR/clide-$USER.sock` with stale-socket
reclaim, accepts JSON-lines request/response traffic, clean
SIGTERM shutdown unlinks the socket file.
* `clide <subcommand>` one-shot; opens the socket, sends a
request, writes the response JSON to stdout, exits with the
dispatcher's error code per ADR 0006 (0/1/2/3/4). Unknown
subcommands forward to the daemon so extensions can register
their own without CLI changes.
Tier 0 handlers: `ping` (returns pong + version + UTC ts) and
`version`. Both are covered by `test/ipc/` + `test/daemon/`; the
subprocess test builds `bin/clide`, starts it, pings it, SIGTERMs
it, and asserts the socket file disappears.
Co-Authored-By: Claude <noreply@anthropic.com>
92 lines
3.0 KiB
Dart
92 lines
3.0 KiB
Dart
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
|
|
import 'package:clide/clide.dart';
|
|
import 'package:test/test.dart';
|
|
|
|
/// Subprocess-level daemon smoke. Only runs if `bin/clide` has been
|
|
/// built (the test skips itself otherwise). This is the release-gate
|
|
/// suite — catches signal-handling, socket-unlink, and version-stamp
|
|
/// regressions that the in-process test masks.
|
|
void main() {
|
|
final binary = File('bin/clide');
|
|
|
|
group('bin/clide --daemon (subprocess)', () {
|
|
setUpAll(() {
|
|
if (!binary.existsSync()) {
|
|
markTestSkipped(
|
|
'bin/clide not built; run `make build` first to enable this suite');
|
|
}
|
|
});
|
|
|
|
test('starts, responds to ping, exits cleanly on SIGTERM', () async {
|
|
if (!binary.existsSync()) return;
|
|
|
|
// Use a fresh socket under a unique temp path so parallel test
|
|
// runs don't collide. The daemon resolves its socket path from
|
|
// XDG_RUNTIME_DIR + USER (see defaultSocketPath()).
|
|
final tmp = await Directory.systemTemp.createTemp('clide_sub_');
|
|
final env = Map<String, String>.from(Platform.environment)
|
|
..['XDG_RUNTIME_DIR'] = tmp.path
|
|
..['USER'] = 'daemon';
|
|
final socketPath = '${tmp.path}/clide-daemon.sock';
|
|
|
|
final process = await Process.start(
|
|
binary.absolute.path,
|
|
['--daemon'],
|
|
environment: env,
|
|
);
|
|
|
|
// Wait for "listening on ..." on stderr before connecting.
|
|
final ready = Completer<void>();
|
|
final stderrLines = <String>[];
|
|
final sub = process.stderr
|
|
.transform(utf8.decoder)
|
|
.transform(const LineSplitter())
|
|
.listen((line) {
|
|
stderrLines.add(line);
|
|
if (line.contains('listening')) ready.complete();
|
|
});
|
|
|
|
try {
|
|
await ready.future.timeout(const Duration(seconds: 3));
|
|
|
|
// Connect and ping
|
|
final sock = await Socket.connect(
|
|
InternetAddress(socketPath, type: InternetAddressType.unix),
|
|
0,
|
|
).timeout(const Duration(seconds: 3));
|
|
sock.writeln(IpcRequest(id: '1', cmd: 'ping').encode());
|
|
final line = await sock
|
|
.cast<List<int>>()
|
|
.transform(utf8.decoder)
|
|
.transform(const LineSplitter())
|
|
.first
|
|
.timeout(const Duration(seconds: 3));
|
|
await sock.close();
|
|
final resp = IpcMessage.decode(line) as IpcResponse;
|
|
expect(resp.ok, true);
|
|
expect(resp.data['pong'], true);
|
|
|
|
// Clean shutdown
|
|
process.kill(ProcessSignal.sigterm);
|
|
final exitCode =
|
|
await process.exitCode.timeout(const Duration(seconds: 3));
|
|
expect(exitCode, 0);
|
|
|
|
// Socket file should be unlinked
|
|
expect(await File(socketPath).exists(), false);
|
|
} finally {
|
|
await sub.cancel();
|
|
try {
|
|
process.kill(ProcessSignal.sigkill);
|
|
} catch (_) {}
|
|
try {
|
|
await tmp.delete(recursive: true);
|
|
} catch (_) {}
|
|
}
|
|
}, timeout: const Timeout(Duration(seconds: 15)));
|
|
});
|
|
}
|