@ctrl-spc/cli 1.1.3 → 1.1.5

package/dist/daemon.js

@@ -1,5 +1,6 @@
 import { createSessionClient, heartbeat, setDeviceStatus } from './devices.js';
 import { loadMachineState } from './session.js';
+import { makeSpawner, nodeSpawnAgent } from './spawner.js';
 export const HEARTBEAT_INTERVAL_MS = 30_000;
 const SESSION_RETRY_INTERVAL_MS = 5_000;
 export async function heartbeatOnce(session, deps) {
@@ -18,6 +19,14 @@ export async function heartbeatOnce(session, deps) {
         }
     }
 }
+export async function runSpawnScan(spawner, log) {
+    try {
+        await spawner.processPending();
+    }
+    catch (err) {
+        log(err instanceof Error ? err.message : 'Spawn scan failed');
+    }
+}
 export async function runDaemon() {
     const deps = {
         createSession: createSessionClient,
@@ -41,9 +50,12 @@ export async function runDaemon() {
     process.once('SIGINT', () => void shutdown());
     process.once('SIGTERM', () => void shutdown());
     session = await heartbeatOnce(session, deps);
+    // ponytail: per-tick rebuild; hoist the back-off map only if the heartbeat interval drops below the back-off.
     while (true) {
         await sleep(HEARTBEAT_INTERVAL_MS);
         session = await heartbeatOnce(session, deps);
+        const spawner = makeSpawner({ session, spawnAgent: nodeSpawnAgent, now: () => Date.now(), log: deps.log });
+        await runSpawnScan(spawner, deps.log);
     }
 }
 async function acquireSession(deps) {

package/dist/flagAssembler.js

@@ -0,0 +1,27 @@
+export const READINESS_REPLY = 'Ready to get to work';
+export const READINESS_PROMPT = `Respond with exactly this phrase and nothing else: ${READINESS_REPLY}`;
+// Translates the launch-config columns into the agent's headless CLI argv.
+// Null columns are omitted so the CLI falls back to its own default.
+export function assembleCommand(req) {
+    if (req.agent_type === 'codex') {
+        const args = ['exec', READINESS_PROMPT];
+        if (req.model)
+            args.push('--model', req.model);
+        args.push('--sandbox', req.permission_mode ?? 'read-only');
+        args.push('--ask-for-approval', 'on-request');
+        if (req.effort)
+            args.push('-c', `model_reasoning_effort=${req.effort}`);
+        return { cmd: 'codex', args };
+    }
+    // Default: Claude Code.
+    const args = ['-p', READINESS_PROMPT];
+    if (req.model)
+        args.push('--model', req.model);
+    if (req.effort)
+        args.push('--effort', req.effort);
+    args.push('--permission-mode', req.permission_mode ?? 'plan');
+    if (req.allowed_tools && req.allowed_tools.length > 0) {
+        args.push('--allowedTools', req.allowed_tools.join(','));
+    }
+    return { cmd: 'claude', args };
+}

package/dist/launchd.js

@@ -77,6 +77,9 @@ export function bootoutArgs(uid, plistPath) {
 export function kickstartArgs(uid) {
     return ['kickstart', '-k', `gui/${uid}/${PLIST_LABEL}`];
 }
+export function bootstrapArgs(uid, plistPath) {
+    return ['bootstrap', `gui/${uid}`, plistPath];
+}
 export async function stopDaemon(home = homedir(), exec = defaultExec) {
     const uid = process.getuid?.();
     if (uid === undefined)
@@ -92,11 +95,18 @@ export async function restartDaemon(home = homedir(), exec = defaultExec) {
     const uid = process.getuid?.();
     if (uid === undefined)
         throw new Error(RESTART_FAILED_MESSAGE);
+    const plistPath = getPlistPath(home);
     try {
         exec('launchctl', kickstartArgs(uid));
     }
     catch {
-        throw new Error(RESTART_FAILED_MESSAGE);
+        try {
+            exec('launchctl', bootstrapArgs(uid, plistPath));
+            exec('launchctl', kickstartArgs(uid));
+        }
+        catch {
+            throw new Error(RESTART_FAILED_MESSAGE);
+        }
     }
 }
 function escapeXml(value) {

package/dist/spawner.js

@@ -0,0 +1,101 @@
+import { spawn } from 'node:child_process';
+import { assembleCommand, READINESS_REPLY } from './flagAssembler.js';
+// agent_type -> spawn mode is derived, never stored (spec decision 8).
+function isRemote(agentType) {
+    return agentType === 'claude-code' || agentType === 'codex';
+}
+export function makeSpawner(deps) {
+    const timeoutMs = deps.readinessTimeoutMs ?? 10_000;
+    const backoffMs = deps.retryBackoffMs ?? 30_000;
+    const lastAttempt = new Map(); // requestId -> timestamp; in-memory back-off
+    async function awaitReadiness(handle) {
+        return new Promise((resolve) => {
+            let buf = '';
+            let done = false;
+            const finish = (ok) => { if (!done) {
+                done = true;
+                clearTimeout(timer);
+                resolve(ok);
+            } };
+            const timer = setTimeout(() => finish(false), timeoutMs);
+            handle.stdout.on('data', (chunk) => {
+                buf += chunk.toString();
+                if (buf.includes(READINESS_REPLY))
+                    finish(true);
+            });
+            handle.stdout.on('end', () => finish(buf.includes(READINESS_REPLY)));
+            handle.stdout.on('error', () => finish(false));
+        });
+    }
+    async function resolveLocalPath(projectId) {
+        const { data } = await deps.session.client
+            .from('project_links')
+            .select('value')
+            .eq('project_id', projectId)
+            .eq('kind', 'path')
+            .limit(1);
+        return data?.[0]?.value ?? null;
+    }
+    async function fulfil(row, pid) {
+        await deps.session.client.from('sessions').insert({
+            project_id: row.project_id,
+            device_id: deps.session.machineId,
+            connection_state: 'connected',
+            awaiting_input: false,
+            agent_type: row.agent_type,
+            model: row.model,
+            effort: row.effort,
+            permission_mode: row.permission_mode,
+            allowed_tools: row.allowed_tools,
+            pid,
+        });
+        await deps.session.client.from('spawn_requests').update({ status: 'fulfilled' }).eq('id', row.id);
+    }
+    async function processOne(row) {
+        if (!isRemote(row.agent_type))
+            return; // manual types are never auto-fulfilled
+        const last = lastAttempt.get(row.id);
+        if (last !== undefined && deps.now() - last < backoffMs)
+            return;
+        lastAttempt.set(row.id, deps.now());
+        const cwd = await resolveLocalPath(row.project_id);
+        if (!cwd) {
+            deps.log(`No local path for project ${row.project_id}; skipping`);
+            return;
+        }
+        const { cmd, args } = assembleCommand(row);
+        const handle = deps.spawnAgent(cmd, args, cwd);
+        const ready = await awaitReadiness(handle);
+        if (!ready) {
+            handle.kill();
+            deps.log(`Readiness gate failed for ${row.id}; will retry`);
+            return;
+        }
+        await fulfil(row, handle.pid);
+        deps.log(`Spawned agent for project ${row.project_id} (request ${row.id})`);
+    }
+    async function processPending() {
+        const { data, error } = await deps.session.client
+            .from('spawn_requests')
+            .select('id, project_id, agent_type, model, effort, permission_mode, allowed_tools')
+            .eq('status', 'pending');
+        if (error) {
+            deps.log(`spawn_requests scan failed: ${error.message}`);
+            return;
+        }
+        for (const row of (data ?? [])) {
+            try {
+                await processOne(row);
+            }
+            catch (err) {
+                deps.log(err instanceof Error ? err.message : `spawn failed for ${row.id}`);
+            }
+        }
+    }
+    return { processPending };
+}
+// Real spawn handle backed by node:child_process, used by the daemon (not in unit tests).
+export function nodeSpawnAgent(cmd, args, cwd) {
+    const child = spawn(cmd, args, { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+    return { pid: child.pid ?? -1, stdout: child.stdout, kill: () => child.kill() };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctrl-spc/cli",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Control Space CLI - machine setup and background daemon",
   "type": "module",
   "files": [