@ctrl-spc/cli 1.3.2 → 1.3.4

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,9 +1,41 @@
 import { spawn } from 'node:child_process';
+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("'", "'\\''")}'`;
 }
@@ -132,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;
@@ -144,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');
             }

package/dist/git.js

@@ -1,4 +1,73 @@
 import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+export const LOCAL_REPOSITORY_KEY_PREFIX = 'local:v1:';
+const LOCAL_REPOSITORY_CONFIG_KEY = 'ctrl-spc.repository-id';
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function gitOutput(cwd, args) {
+    try {
+        const value = execFileSync('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return value || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function localRepositoryKey(id) {
+    if (!UUID_PATTERN.test(id))
+        throw new Error('Invalid local repository identity.');
+    return `${LOCAL_REPOSITORY_KEY_PREFIX}${id.toLowerCase()}`;
+}
+export function isLocalRepositoryKey(value) {
+    return value.toLowerCase().startsWith(LOCAL_REPOSITORY_KEY_PREFIX);
+}
+export function readLocalRepositoryIdentity(cwd) {
+    const id = gitOutput(cwd, ['config', '--local', '--get', LOCAL_REPOSITORY_CONFIG_KEY]);
+    return id && UUID_PATTERN.test(id) ? localRepositoryKey(id) : null;
+}
+export function readRootCommitSha(cwd) {
+    const roots = gitOutput(cwd, ['rev-list', '--max-parents=0', 'HEAD']);
+    return roots?.split(/\s+/).filter(Boolean).sort()[0] ?? null;
+}
+/** Writes untracked Git metadata so identity survives moves and copied folders. */
+export function ensureLocalRepositoryIdentity(cwd, createId = randomUUID) {
+    const existing = readLocalRepositoryIdentity(cwd);
+    if (existing)
+        return existing;
+    if (!gitOutput(cwd, ['rev-parse', '--show-toplevel'])) {
+        throw new Error(`Not a Git repository: ${cwd}`);
+    }
+    const id = createId();
+    const key = localRepositoryKey(id);
+    execFileSync('git', ['config', '--local', LOCAL_REPOSITORY_CONFIG_KEY, id.toLowerCase()], {
+        cwd,
+        stdio: 'ignore',
+    });
+    return key;
+}
+export function writeLocalRepositoryIdentity(cwd, key, allowedPriorKey) {
+    if (!isLocalRepositoryKey(key))
+        throw new Error('Expected a local repository identity.');
+    const id = key.slice(LOCAL_REPOSITORY_KEY_PREFIX.length);
+    localRepositoryKey(id);
+    const existing = readLocalRepositoryIdentity(cwd);
+    if (existing && existing !== key && existing !== allowedPriorKey) {
+        throw new Error('This folder is already linked to a different CTRL+SPC repository.');
+    }
+    if (!gitOutput(cwd, ['rev-parse', '--show-toplevel']))
+        throw new Error(`Not a Git repository: ${cwd}`);
+    execFileSync('git', ['config', '--local', LOCAL_REPOSITORY_CONFIG_KEY, id], { cwd, stdio: 'ignore' });
+    return key;
+}
+export function currentRepoIdentity(cwd) {
+    const remote = currentRepoRemote(cwd);
+    if (remote)
+        return normalizeRemoteUrl(remote);
+    return readLocalRepositoryIdentity(cwd);
+}
 /**
  * Normalizes a git remote URL to a canonical `host/path` key (no scheme,
  * lowercase throughout — hosts are case-insensitive and GitHub/GitLab paths
@@ -52,13 +121,12 @@ export function currentRepoRemote(cwd) {
  * (`init`/`link`) must not treat it as such.
  */
 export async function resolveProject(client, cwd) {
-    const remote = currentRepoRemote(cwd);
-    if (!remote)
+    const key = currentRepoIdentity(cwd);
+    if (!key)
         return null;
-    const key = normalizeRemoteUrl(remote);
     const { data, error } = await client
         .from('projects')
-        .select('id, org_id, name, organizations(name)')
+        .select('id, org_id, name, archived_at, organizations(name)')
         .eq('git_remote_url', key)
         .maybeSingle();
     if (error)
@@ -66,5 +134,7 @@ export async function resolveProject(client, cwd) {
     if (!data)
         return null;
     const row = data;
+    if (row.archived_at)
+        return null;
     return { id: row.id, orgId: row.org_id, name: row.name, orgName: row.organizations?.name ?? '' };
 }

package/dist/index.js

@@ -5,16 +5,19 @@ import { init } from './commands/init.js';
 import { link } from './commands/link.js';
 import { fetchRepository } from './commands/fetch.js';
 import { run } from './commands/run.js';
+import { openCompanion, serveCompanion } from './companion.js';
 export const HELP_TEXT = `ctrl-spc — CTRL+SPC CLI
 
 Usage:
   ctrl-spc login    Sign in via the browser and store a session
   ctrl-spc logout   Remove the stored session from this machine
   ctrl-spc init     Discover repositories and explicitly group them into projects
+                    [--project <empty-project-id>] [--repo <path> ...] [--combine] [--yes]
   ctrl-spc link     Reconcile a project's full topology after grouping changes
                     [--project <project-id>]
   ctrl-spc fetch    Clone and link one unavailable project repository
                     [repository-id] [--project <project-id>] [--destination <path>] [--yes]
+  ctrl-spc open     Open the local connection manager
   ctrl-spc          Run the local agent process (presence + MCP server)
   ctrl-spc --help   Show this help text
 `;
@@ -36,6 +39,15 @@ export async function main(argv = process.argv.slice(2)) {
         case 'fetch':
             await fetchRepository(argv.slice(1));
             return;
+        case 'open':
+            await openCompanion();
+            return;
+        case '__broker':
+            await run();
+            return;
+        case '__companion':
+            await serveCompanion();
+            return;
         case '--help':
         case '-h':
             console.log(HELP_TEXT);