@ctrl-spc/cli 1.3.1 → 1.3.3

package/dist/companion.js

@@ -0,0 +1,422 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { configDir, clearSession, getMachineIdentity, readSession } from './config.js';
+import { login } from './commands/login.js';
+import { getClient } from './supabase.js';
+import { renderCompanionUi } from './companion-ui.js';
+import { chooseCompanionFolder, createCompanionProject, discoverCompanionProject, fetchMissingCompanionFolders, linkCompanionFolder, linkCompanionProject, loadCompanionProjects, } from './companion-projects.js';
+import { currentCompanionKind, LOCAL_RUNTIME_PORT, NPM_RUNTIME_PORT, runtimeStatuses, startRuntime, stopRuntime, } from './runtime-control.js';
+export const LOCAL_COMPANION_PORT = 4570;
+export const NPM_COMPANION_PORT = 4573;
+const CLI_ENTRY_PATH = fileURLToPath(new URL('./index.js', import.meta.url));
+const PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function attachRedirectLocation(projectId, token) {
+    if (!PROJECT_ID_RE.test(projectId))
+        return null;
+    return `/?token=${encodeURIComponent(token)}&attachProject=${encodeURIComponent(projectId)}`;
+}
+export function linkRedirectLocation(projectId, token) {
+    if (!PROJECT_ID_RE.test(projectId))
+        return null;
+    return `/?token=${encodeURIComponent(token)}&linkProject=${encodeURIComponent(projectId)}`;
+}
+function companionPort(kind) {
+    return Number(process.env.CTRL_SPC_COMPANION_PORT) || (kind === 'local' ? LOCAL_COMPANION_PORT : NPM_COMPANION_PORT);
+}
+function statePath(kind) {
+    return join(configDir(), 'runtime', `companion-${kind}.json`);
+}
+function readState(kind) {
+    try {
+        return JSON.parse(readFileSync(statePath(kind), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(kind, state) {
+    const path = statePath(kind);
+    mkdirSync(join(configDir(), 'runtime'), { recursive: true });
+    writeFileSync(path, JSON.stringify(state), { mode: 0o600 });
+    chmodSync(path, 0o600);
+}
+function openBrowser(url) {
+    const [command, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '""', url]]
+            : ['xdg-open', [url]];
+    try {
+        const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // The URL is also printed so a missing opener is non-fatal.
+    }
+}
+function json(res, status, body, headers = {}) {
+    res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', ...headers });
+    res.end(JSON.stringify(body));
+}
+export function companionProbeCorsHeaders(origin) {
+    if (!origin)
+        return {};
+    const allowed = origin === 'https://ctrl-spc.com'
+        || origin === 'https://www.ctrl-spc.com'
+        || /^http:\/\/(localhost|127\.0\.0\.1):\d+$/.test(origin);
+    return allowed ? {
+        'Access-Control-Allow-Origin': origin,
+        'Access-Control-Allow-Methods': 'GET, OPTIONS',
+        'Vary': 'Origin',
+    } : {};
+}
+export function companionHealthPayload(machineId = getMachineIdentity().id) {
+    return { status: 'ok', machineId };
+}
+function authorized(req, token) {
+    return req.headers['x-ctrl-spc-token'] === token;
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = chunk;
+        size += buffer.length;
+        if (size > 32 * 1024)
+            throw new Error('Request is too large.');
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new Error('Request contains invalid JSON.');
+    }
+}
+async function statusPayload(kind) {
+    const profiles = await runtimeStatuses();
+    const signedIn = Boolean(readSession());
+    let supabaseReachable = false;
+    if (signedIn) {
+        try {
+            const { error } = await (await getClient()).auth.getUser();
+            supabaseReachable = !error;
+        }
+        catch {
+            supabaseReachable = false;
+        }
+    }
+    const other = profiles.find((profile) => profile.kind !== kind);
+    const otherActive = other?.state === 'ready' || other?.state === 'conflict';
+    return {
+        signedIn,
+        supabaseReachable,
+        machineId: getMachineIdentity().id,
+        managerKind: kind,
+        profiles: profiles.filter((profile) => profile.kind === kind),
+        otherConnection: {
+            active: otherActive,
+            switchable: other?.state === 'ready',
+            label: kind === 'local' ? 'The installed package' : 'Another CTRL+SPC version',
+        },
+    };
+}
+function runtimeKind(value) {
+    return value === 'local' || value === 'npm' ? value : null;
+}
+async function handleApi(req, res, token, managerKind, path) {
+    if ((req.method === 'GET' || req.method === 'OPTIONS') && path === '/api/companion-health') {
+        const headers = companionProbeCorsHeaders(req.headers.origin);
+        if (req.method === 'OPTIONS') {
+            res.writeHead(Object.keys(headers).length ? 204 : 403, headers);
+            res.end();
+            return;
+        }
+        json(res, 200, companionHealthPayload(), headers);
+        return;
+    }
+    if (!authorized(req, token)) {
+        json(res, 403, { error: 'This connection manager session is no longer valid.' });
+        return;
+    }
+    if (req.method === 'GET' && path === '/api/status') {
+        json(res, 200, await statusPayload(managerKind));
+        return;
+    }
+    if (req.method === 'GET' && path === '/api/projects') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in to view projects on this machine.' });
+            return;
+        }
+        json(res, 200, await loadCompanionProjects());
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/login') {
+        await login();
+        if (!readSession()) {
+            json(res, 400, { error: 'Sign in did not complete.' });
+            return;
+        }
+        process.exitCode = 0;
+        json(res, 200, await statusPayload(managerKind));
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/logout') {
+        await Promise.allSettled([stopRuntime('local'), stopRuntime('npm')]);
+        clearSession();
+        json(res, 200, await statusPayload(managerKind));
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/folders/choose') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before adding a project.' });
+            return;
+        }
+        const folder = await chooseCompanionFolder();
+        json(res, 200, folder ? { cancelled: false, discovery: discoverCompanionProject(folder) } : { cancelled: true });
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/folders/choose-path') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before choosing a folder.' });
+            return;
+        }
+        const folder = await chooseCompanionFolder();
+        json(res, 200, folder ? { cancelled: false, path: folder } : { cancelled: true });
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/projects/discover') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before adding a project.' });
+            return;
+        }
+        const body = await readJsonBody(req);
+        const paths = Array.isArray(body.paths) ? body.paths.filter((value) => typeof value === 'string') : [];
+        const pathValue = typeof body.path === 'string' ? body.path : '';
+        json(res, 200, { discovery: discoverCompanionProject(paths.length ? paths : pathValue) });
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/projects/create') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before adding a project.' });
+            return;
+        }
+        const body = await readJsonBody(req);
+        const request = {
+            path: typeof body.path === 'string' ? body.path : '',
+            paths: Array.isArray(body.paths) ? body.paths.filter((value) => typeof value === 'string') : undefined,
+            orgId: typeof body.orgId === 'string' ? body.orgId : '',
+            name: typeof body.name === 'string' ? body.name : '',
+            existingProjectId: typeof body.existingProjectId === 'string' && body.existingProjectId
+                ? body.existingProjectId
+                : undefined,
+            existingProjectMode: body.existingProjectMode === 'attach' || body.existingProjectMode === 'link'
+                ? body.existingProjectMode
+                : undefined,
+            includedTargetIds: Array.isArray(body.includedTargetIds)
+                ? body.includedTargetIds.filter((value) => typeof value === 'string')
+                : undefined,
+            roles: body.roles && typeof body.roles === 'object' && !Array.isArray(body.roles)
+                ? body.roles
+                : undefined,
+            promotionChoice: body.promotionChoice === 'use_online' ? 'use_online' : undefined,
+        };
+        json(res, 200, await createCompanionProject(request));
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/projects/fetch-missing') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before getting missing folders.' });
+            return;
+        }
+        const body = await readJsonBody(req);
+        const projectId = typeof body.projectId === 'string' ? body.projectId : '';
+        const destination = typeof body.destination === 'string' ? body.destination.trim() : '';
+        if (!PROJECT_ID_RE.test(projectId) || !destination) {
+            json(res, 400, { error: 'Choose a project and destination folder.' });
+            return;
+        }
+        json(res, 200, await fetchMissingCompanionFolders(projectId, destination));
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/projects/link-auto') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before connecting folders.' });
+            return;
+        }
+        const body = await readJsonBody(req);
+        const projectId = typeof body.projectId === 'string' ? body.projectId : '';
+        if (!PROJECT_ID_RE.test(projectId)) {
+            json(res, 400, { error: 'Choose a project.' });
+            return;
+        }
+        json(res, 200, await linkCompanionProject(projectId));
+        return;
+    }
+    if (req.method === 'POST' && path === '/api/projects/link-folder') {
+        if (!readSession()) {
+            json(res, 401, { error: 'Sign in before connecting a folder.' });
+            return;
+        }
+        const body = await readJsonBody(req);
+        const projectId = typeof body.projectId === 'string' ? body.projectId : '';
+        const repositoryId = typeof body.repositoryId === 'string' ? body.repositoryId : '';
+        const folder = typeof body.path === 'string' ? body.path.trim() : '';
+        if (!PROJECT_ID_RE.test(projectId) || !PROJECT_ID_RE.test(repositoryId) || !folder) {
+            json(res, 400, { error: 'Choose a project folder.' });
+            return;
+        }
+        json(res, 200, await linkCompanionFolder(projectId, repositoryId, folder));
+        return;
+    }
+    const match = path.match(/^\/api\/runtime\/(local|npm)\/(start|stop)$/);
+    if (req.method === 'POST' && match) {
+        const kind = runtimeKind(match[1]);
+        if (!kind) {
+            json(res, 400, { error: 'Unknown connection.' });
+            return;
+        }
+        if (kind !== managerKind) {
+            json(res, 403, { error: 'This window cannot control the other CTRL+SPC installation.' });
+            return;
+        }
+        if (match[2] === 'start') {
+            if (!readSession()) {
+                json(res, 400, { error: 'Sign in before starting a connection.' });
+                return;
+            }
+            await startRuntime(kind);
+        }
+        else {
+            await stopRuntime(kind);
+        }
+        json(res, 200, await statusPayload(managerKind));
+        return;
+    }
+    json(res, 404, { error: 'Not found.' });
+}
+async function existingCompanion(kind) {
+    const state = readState(kind);
+    if (!state)
+        return null;
+    try {
+        const response = await fetch(`http://127.0.0.1:${state.port}/api/companion-health`, {
+            headers: { 'x-ctrl-spc-token': state.token },
+            signal: AbortSignal.timeout(600),
+        });
+        return response.ok ? state : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function openCompanion() {
+    const managerKind = currentCompanionKind();
+    let existing = await existingCompanion(managerKind);
+    if (existing) {
+        const url = `http://127.0.0.1:${existing.port}/?token=${existing.token}`;
+        console.log(`Opening CTRL+SPC connection manager — ${url}`);
+        openBrowser(url);
+        return;
+    }
+    if (existsSync(statePath(managerKind)))
+        rmSync(statePath(managerKind), { force: true });
+    const child = spawn(process.execPath, [CLI_ENTRY_PATH, '__companion'], {
+        detached: true,
+        env: { ...process.env, CTRL_SPC_COMPANION_KIND: managerKind },
+        stdio: 'ignore',
+    });
+    child.on('error', () => { });
+    child.unref();
+    const deadline = Date.now() + 5_000;
+    while (!existing && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        existing = await existingCompanion(managerKind);
+    }
+    if (!existing) {
+        throw new Error('The CTRL+SPC connection manager did not start. Run `ctrl-spc open` again.');
+    }
+    const url = `http://127.0.0.1:${existing.port}/?token=${existing.token}`;
+    console.log(`Opening CTRL+SPC connection manager — ${url}`);
+    openBrowser(url);
+}
+/** Hidden detached process started by `ctrl-spc open`. */
+export async function serveCompanion() {
+    const managerKind = currentCompanionKind();
+    const port = companionPort(managerKind);
+    if (await existingCompanion(managerKind))
+        return;
+    if (existsSync(statePath(managerKind)))
+        rmSync(statePath(managerKind), { force: true });
+    const token = randomBytes(24).toString('hex');
+    const server = createServer((req, res) => {
+        void (async () => {
+            try {
+                const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+                if (req.method === 'GET' && (url.pathname === '/attach' || url.pathname === '/link')) {
+                    const location = url.pathname === '/attach'
+                        ? attachRedirectLocation(url.searchParams.get('project') ?? '', token)
+                        : linkRedirectLocation(url.searchParams.get('project') ?? '', token);
+                    if (!location) {
+                        res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8', 'Cache-Control': 'no-store' })
+                            .end('A valid project id is required.');
+                        return;
+                    }
+                    res.writeHead(302, {
+                        Location: location,
+                        'Cache-Control': 'no-store',
+                        'Referrer-Policy': 'no-referrer',
+                    }).end();
+                    return;
+                }
+                if (req.method === 'GET' && url.pathname === '/') {
+                    if (url.searchParams.get('token') !== token) {
+                        res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' }).end('Invalid connection manager session.');
+                        return;
+                    }
+                    res.writeHead(200, {
+                        'Content-Type': 'text/html; charset=utf-8',
+                        'Cache-Control': 'no-store',
+                        'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data:; base-uri 'none'; frame-ancestors 'none'",
+                    });
+                    res.end(renderCompanionUi(token, managerKind, managerKind === 'local' ? LOCAL_RUNTIME_PORT : NPM_RUNTIME_PORT));
+                    return;
+                }
+                if (req.method === 'GET' && url.pathname === '/favicon.ico') {
+                    res.writeHead(204).end();
+                    return;
+                }
+                await handleApi(req, res, token, managerKind, url.pathname);
+            }
+            catch (err) {
+                json(res, 500, { error: err instanceof Error ? err.message : String(err) });
+            }
+        })();
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', resolve);
+    });
+    writeState(managerKind, { pid: process.pid, port, token });
+    await new Promise((resolve) => {
+        let closing = false;
+        const close = () => {
+            if (closing)
+                return;
+            closing = true;
+            server.close(() => {
+                rmSync(statePath(managerKind), { force: true });
+                resolve();
+            });
+        };
+        process.once('SIGINT', close);
+        process.once('SIGTERM', close);
+    });
+}

package/dist/dispatch.js

@@ -1,19 +1,62 @@
 import { spawn } from 'node:child_process';
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { statSync } from 'node:fs';
+import { access, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
 import { resolveAgentCommand } from './agents.js';
+import { resolveProjectRootRows } from './resolver.js';
+export const ROLE_ROUTING_ERROR = 'No connected machine has every folder this task needs.';
+export async function dispatchRolesReady(client, machineId, request, inspectPath = statSync) {
+    const slugs = request.role_slugs ?? [];
+    if (slugs.length === 0)
+        return true;
+    try {
+        let projectId = request.project_id;
+        if (!projectId) {
+            const { data, error } = await client.from('tasks').select('project_id').eq('id', request.task_id).single();
+            if (error || !data)
+                return false;
+            projectId = data.project_id;
+        }
+        const rows = await resolveProjectRootRows(client, projectId, machineId);
+        return slugs.every(slug => rows.some(row => {
+            if (row.role_slug !== slug || row.status !== 'ready' || !row.local_path)
+                return false;
+            try {
+                inspectPath(join(row.local_path, row.scope_path));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }));
+    }
+    catch {
+        return false;
+    }
+}
 function shellQuote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
-export function agentTerminalScript(request, executable) {
-    const command = agentTerminalCommand(request, executable);
+function agentInvocationCommand(request, executable) {
+    const prompt = shellQuote(request.prompt);
+    const binary = shellQuote(executable);
+    const fresh = `exec ${binary} ${prompt}`;
+    if (request.mode === 'start')
+        return fresh;
+    const resume = request.agent_kind === 'claude'
+        ? `${binary} --continue ${prompt}`
+        : `${binary} resume --last ${prompt}`;
+    return `${resume} || ${fresh}`;
+}
+export function agentTerminalScript(request, executable, markerPath) {
     return [
-        '#!/bin/zsh',
-        'script_path="$0"',
-        '/bin/rm -f -- "$script_path"',
-        '/bin/rmdir -- "${script_path%/*}" 2>/dev/null || true',
-        `exec /bin/zsh -lc ${shellQuote(command)}`,
+        '#!/bin/sh',
+        `cd ${shellQuote(request.workspace_root)} || exit 72`,
+        `: > ${shellQuote(markerPath)} || exit 73`,
+        '/bin/rm -f -- "$0"',
+        agentInvocationCommand(request, executable),
         '',
     ].join('\n');
 }
@@ -29,46 +72,77 @@ export function agentTerminalCommand(request, executable) {
 }
 /** Opens a visible agent conversation. Resume is best-effort and falls back
  * to a fresh task conversation in the same project checkout. */
-export async function launchAgentDispatch(request) {
-    if (process.platform !== 'darwin') {
+export async function launchAgentDispatch(request, deps = {}) {
+    if ((deps.platform ?? process.platform) !== 'darwin') {
         throw new Error('Automatic agent launch currently requires macOS Terminal.');
     }
-    const executable = resolveAgentCommand(request.agent_kind);
+    const executable = (deps.resolveExecutable ?? resolveAgentCommand)(request.agent_kind);
     if (!executable)
         throw new Error(`${request.agent_kind} is not installed on this machine.`);
+    const timeoutMs = deps.timeoutMs ?? 10_000;
     const directory = await mkdtemp(join(tmpdir(), 'ctrl-spc-dispatch-'));
-    const scriptPath = join(directory, `ctrl-spc-${request.id}.command`);
+    const scriptPath = join(directory, 'launch.command');
+    const markerPath = join(directory, 'launched');
     try {
-        await writeFile(scriptPath, agentTerminalScript(request, executable), {
+        await writeFile(scriptPath, agentTerminalScript(request, executable, markerPath), {
             encoding: 'utf8',
             flag: 'wx',
             mode: 0o700,
         });
-        await new Promise((resolve, reject) => {
-            const child = spawn('/usr/bin/open', ['-a', 'Terminal', scriptPath], {
-                stdio: ['ignore', 'ignore', 'pipe'],
-            });
-            let stderr = '';
-            child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-            child.once('error', reject);
-            child.once('exit', (code) => {
-                if (code === 0)
-                    resolve();
-                else
-                    reject(new Error(stderr.trim() || `Terminal launch exited with code ${code ?? 'unknown'}.`));
-            });
-        });
+        await (deps.openTerminal ?? openTerminalCommandFile)(scriptPath, timeoutMs);
+        await (deps.waitForAcknowledgement ?? waitForLaunchAcknowledgement)(markerPath, timeoutMs);
     }
-    catch (error) {
+    finally {
         await rm(directory, { recursive: true, force: true }).catch(() => { });
-        throw error;
     }
-    // The script removes itself after Terminal opens it. This fallback handles
-    // cases where Terminal accepts the file but never executes it.
-    const cleanup = setTimeout(() => {
-        void rm(directory, { recursive: true, force: true });
-    }, 60_000);
-    cleanup.unref();
+}
+export function terminalOpenArguments(scriptPath) {
+    return ['-b', 'com.apple.Terminal', scriptPath];
+}
+async function openTerminalCommandFile(scriptPath, timeoutMs) {
+    await new Promise((resolve, reject) => {
+        const child = spawn('/usr/bin/open', terminalOpenArguments(scriptPath), {
+            stdio: ['ignore', 'ignore', 'pipe'],
+        });
+        let stderr = '';
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish(new Error(`Terminal launch timed out after ${timeoutMs}ms.`));
+        }, timeoutMs);
+        timer.unref();
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.once('error', (error) => finish(error));
+        child.once('exit', (code) => {
+            if (code === 0)
+                finish();
+            else
+                finish(new Error(stderr.trim() || `Terminal launch exited with code ${code ?? 'unknown'}.`));
+        });
+    });
+}
+async function waitForLaunchAcknowledgement(markerPath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            await access(markerPath);
+            return;
+        }
+        catch {
+            await delay(50);
+        }
+    }
+    throw new Error(`Terminal accepted the launch but did not start the agent within ${timeoutMs}ms.`);
 }
 export function createAgentDispatchController(client, machineId, agents, deps = {}) {
     const claim = deps.claim ?? (async () => {
@@ -90,6 +164,7 @@ export function createAgentDispatchController(client, machineId, agents, deps =
             throw error;
     });
     const launch = deps.launch ?? launchAgentDispatch;
+    const verifyRoles = deps.verifyRoles ?? ((request) => dispatchRolesReady(client, machineId, request));
     let stopped = false;
     let polling = false;
     let timer;
@@ -102,6 +177,10 @@ export function createAgentDispatchController(client, machineId, agents, deps =
             if (!request)
                 return;
             try {
+                if (!(await verifyRoles(request))) {
+                    await complete(request.id, 'failed', ROLE_ROUTING_ERROR);
+                    return;
+                }
                 await launch(request);
                 await complete(request.id, 'launched');
             }