@ctrl-spc/cli 1.1.10 → 1.1.12

package/dist/controlRequests.js

@@ -0,0 +1,154 @@
+import { assembleCommand, PING_PROMPT } from './flagAssembler.js';
+const STOP_NOT_OWNED_MESSAGE = 'This machine can only stop agent processes it started and still owns.';
+export function makeControlRequestProcessor(deps) {
+    const timeoutMs = deps.pingTimeoutMs ?? 60_000;
+    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 mark(row, patch) {
+        await deps.session.client.from('agent_control_requests').update(patch).eq('id', row.id);
+    }
+    function completedPatch(status, errorMessage) {
+        return {
+            status,
+            ...(errorMessage ? { error_message: errorMessage } : {}),
+            completed_at: new Date(deps.now()).toISOString(),
+        };
+    }
+    async function collectStdout(handle) {
+        return new Promise((resolve, reject) => {
+            let stdout = '';
+            let settled = false;
+            const timer = setTimeout(() => {
+                handle.kill();
+                finish(() => reject(new Error('Provider timed out before replying.')));
+            }, timeoutMs);
+            const finish = (settle) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                settle();
+            };
+            handle.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            handle.stdout.on('end', () => finish(() => resolve(stdout)));
+            handle.stdout.on('error', (err) => finish(() => reject(err)));
+        });
+    }
+    async function findSession(row) {
+        let query = deps.session.client
+            .from('sessions')
+            .select('id, project_id, agent_type, model, effort, permission_mode, allowed_tools')
+            .eq('project_id', row.project_id)
+            .is('ended_at', null);
+        if (row.session_id)
+            query = query.eq('id', row.session_id);
+        const { data, error } = await query.order('created_at', { ascending: false }).limit(1);
+        if (error)
+            throw new Error(`Session lookup failed: ${error.message}`);
+        return ((data ?? [])[0] ?? null);
+    }
+    async function insertMessage(row, sessionId, role, kind, content) {
+        const { data, error } = await deps.session.client.from('agent_messages').insert({
+            project_id: row.project_id,
+            session_id: sessionId,
+            role,
+            kind,
+            content,
+        }).select('id').single();
+        if (error)
+            throw new Error(`Message insert failed: ${error.message}`);
+        return data?.id ?? null;
+    }
+    async function processPing(row) {
+        const session = await findSession(row);
+        if (!session) {
+            await mark(row, completedPatch('failed', 'No active agent session was found.'));
+            return;
+        }
+        const cwd = await resolveLocalPath(row.project_id);
+        if (!cwd) {
+            await mark(row, completedPatch('failed', 'This project is not linked to a local folder on this machine.'));
+            return;
+        }
+        const { cmd, args } = assembleCommand(session, PING_PROMPT);
+        const handle = deps.spawnAgent(cmd, args, cwd);
+        const stdout = await collectStdout(handle);
+        const responseId = await insertMessage(row, session.id, 'agent', 'ping', cleanAgentText(stdout));
+        await mark(row, { ...completedPatch('succeeded'), response_message_id: responseId });
+    }
+    async function processStop(row) {
+        const owned = row.session_id
+            ? deps.ownedSessions.get(row.session_id)
+            : [...deps.ownedSessions.values()].find((entry) => entry.projectId === row.project_id);
+        if (!owned) {
+            const session = await findSession(row);
+            if (session) {
+                const endedAt = new Date(deps.now()).toISOString();
+                await deps.session.client.from('sessions').update({
+                    connection_state: 'disconnected',
+                    ended_at: endedAt,
+                    exit_code: null,
+                    stop_reason: 'daemon_restarted',
+                }).eq('id', session.id);
+                await insertMessage(row, session.id, 'system', 'system', 'This agent was no longer owned by the current machine helper, so Control Space marked it disconnected. Start a fresh agent to continue.');
+                await mark(row, { status: 'succeeded', completed_at: endedAt });
+                return;
+            }
+            await mark(row, completedPatch('failed', STOP_NOT_OWNED_MESSAGE));
+            return;
+        }
+        owned.handle.kill();
+        deps.ownedSessions.delete(owned.sessionId);
+        const endedAt = new Date(deps.now()).toISOString();
+        await deps.session.client.from('sessions').update({
+            connection_state: 'disconnected',
+            ended_at: endedAt,
+            exit_code: null,
+            stop_reason: 'stopped_by_request',
+        }).eq('id', owned.sessionId);
+        await insertMessage(row, owned.sessionId, 'system', 'system', 'Agent stopped.');
+        await mark(row, { status: 'succeeded', completed_at: endedAt });
+    }
+    async function processOne(row) {
+        await mark(row, { status: 'processing' });
+        if (row.action === 'ping') {
+            await processPing(row);
+            return;
+        }
+        if (row.action === 'stop') {
+            await processStop(row);
+            return;
+        }
+        await mark(row, completedPatch('failed', 'This control request is not supported by this version of the daemon.'));
+    }
+    async function processPending() {
+        const { data, error } = await deps.session.client
+            .from('agent_control_requests')
+            .select('id, project_id, session_id, action')
+            .eq('status', 'pending');
+        if (error) {
+            deps.log(`agent_control_requests scan failed: ${error.message}`);
+            return;
+        }
+        for (const row of (data ?? [])) {
+            try {
+                await processOne(row);
+            }
+            catch (err) {
+                deps.log(err instanceof Error ? err.message : `control request failed for ${row.id}`);
+                await mark(row, completedPatch('failed', err instanceof Error ? err.message : 'Control request failed.'));
+            }
+        }
+    }
+    return { processPending };
+}
+function cleanAgentText(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 4000);
+}

package/dist/daemon.js

@@ -1,6 +1,7 @@
 import { createSessionClient, heartbeat, setDeviceStatus } from './devices.js';
 import { loadMachineState } from './session.js';
 import { makeSpawner, nodeSpawnAgent } from './spawner.js';
+import { makeControlRequestProcessor } from './controlRequests.js';
 export const HEARTBEAT_INTERVAL_MS = 30_000;
 const SESSION_RETRY_INTERVAL_MS = 5_000;
 export async function heartbeatOnce(session, deps) {
@@ -27,6 +28,14 @@ export async function runSpawnScan(spawner, log) {
         log(err instanceof Error ? err.message : 'Spawn scan failed');
     }
 }
+export async function runControlScan(processor, log) {
+    try {
+        await processor.processPending();
+    }
+    catch (err) {
+        log(err instanceof Error ? err.message : 'Control request scan failed');
+    }
+}
 export async function runDaemon() {
     const deps = {
         createSession: createSessionClient,
@@ -35,6 +44,7 @@ export async function runDaemon() {
     };
     let session = await acquireSession(deps);
     let shuttingDown = false;
+    const ownedSessions = new Map();
     const shutdown = async () => {
         if (shuttingDown)
             return;
@@ -50,12 +60,17 @@ 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.
+    let spawner = makeSpawner({ session, spawnAgent: nodeSpawnAgent, ownedSessions, now: () => Date.now(), log: deps.log });
+    let controls = makeControlRequestProcessor({ session, spawnAgent: nodeSpawnAgent, ownedSessions, now: () => Date.now(), log: deps.log });
+    await runSpawnScan(spawner, deps.log);
+    await runControlScan(controls, deps.log);
     while (true) {
         await sleep(HEARTBEAT_INTERVAL_MS);
         session = await heartbeatOnce(session, deps);
-        const spawner = makeSpawner({ session, spawnAgent: nodeSpawnAgent, now: () => Date.now(), log: deps.log });
+        spawner = makeSpawner({ session, spawnAgent: nodeSpawnAgent, ownedSessions, now: () => Date.now(), log: deps.log });
+        controls = makeControlRequestProcessor({ session, spawnAgent: nodeSpawnAgent, ownedSessions, now: () => Date.now(), log: deps.log });
         await runSpawnScan(spawner, deps.log);
+        await runControlScan(controls, deps.log);
     }
 }
 async function acquireSession(deps) {

package/dist/flagAssembler.js

@@ -1,20 +1,22 @@
 export const READINESS_REPLY = 'Ready to get to work';
 export const READINESS_PROMPT = `Respond with exactly this phrase and nothing else: ${READINESS_REPLY}`;
+export const PING_PROMPT = 'Reply with one short sentence confirming you are still responsive to Control Space.';
 // 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) {
+export function assembleCommand(req, prompt = READINESS_PROMPT) {
     if (req.agent_type === 'codex') {
-        const args = ['exec', READINESS_PROMPT];
+        const args = ['--ask-for-approval', 'on-request', 'exec'];
         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}`);
+        args.push('--color', 'never');
+        args.push(prompt);
         return { cmd: 'codex', args };
     }
     // Default: Claude Code.
-    const args = ['-p', READINESS_PROMPT];
+    const args = ['-p', prompt];
     if (req.model)
         args.push('--model', req.model);
     if (req.effort)

package/dist/spawner.js

@@ -42,8 +42,11 @@ export function makeSpawner(deps) {
             .limit(1);
         return data?.[0]?.value ?? null;
     }
-    async function fulfil(row, pid) {
-        await deps.session.client.from('sessions').insert({
+    async function markRequest(row, status) {
+        await deps.session.client.from('spawn_requests').update({ status }).eq('id', row.id);
+    }
+    async function fulfil(row, pid, stdout, handle) {
+        const { data, error } = await deps.session.client.from('sessions').insert({
             project_id: row.project_id,
             device_id: deps.session.machineId,
             connection_state: 'connected',
@@ -54,8 +57,21 @@ export function makeSpawner(deps) {
             permission_mode: row.permission_mode,
             allowed_tools: row.allowed_tools,
             pid,
+        }).select('id').single();
+        if (error)
+            throw new Error(`Session insert failed: ${error.message}`);
+        const sessionId = data.id;
+        const { error: messageError } = await deps.session.client.from('agent_messages').insert({
+            project_id: row.project_id,
+            session_id: sessionId,
+            role: 'agent',
+            kind: 'ready',
+            content: stdout,
         });
-        await deps.session.client.from('spawn_requests').update({ status: 'fulfilled' }).eq('id', row.id);
+        if (messageError)
+            throw new Error(`Ready message insert failed: ${messageError.message}`);
+        deps.ownedSessions?.set(sessionId, { projectId: row.project_id, sessionId, handle });
+        await markRequest(row, 'fulfilled');
     }
     async function processOne(row) {
         if (!isRemote(row.agent_type))
@@ -69,15 +85,17 @@ export function makeSpawner(deps) {
             deps.log(`No local path for project ${row.project_id}; skipping`);
             return;
         }
+        await markRequest(row, 'processing');
         const { cmd, args } = assembleCommand(row);
         const handle = deps.spawnAgent(cmd, args, cwd);
         const result = await awaitReadiness(handle);
         if (!result.ready) {
             handle.kill();
             deps.log(`Readiness gate failed for ${row.id}; will retry. stdout=${quoteSnippet(result.stdout)} stderr=${quoteSnippet(result.stderr)}`);
+            await markRequest(row, 'failed');
             return;
         }
-        await fulfil(row, handle.pid);
+        await fulfil(row, handle.pid, result.stdout, handle);
         deps.log(`Spawned agent for project ${row.project_id} (request ${row.id})`);
     }
     async function processPending() {

package/package.json

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