@craftspace/cli 0.1.0 → 0.2.1

package/dist/machine.d.ts

@@ -6,10 +6,15 @@ export declare const machine: {
         url: string;
         install: boolean;
     }): Promise<Machine>;
+    signIn({ url, why, install }: {
+        url?: string;
+        why: string;
+        install?: boolean;
+    }): Promise<SignedIn>;
     status(): Promise<{
         machine: Machine;
         url: string;
-    } | null>;
+    }>;
     beatOnce(): Promise<boolean>;
     beatForever(): Promise<void>;
     run({ argv, on }: {
@@ -18,4 +23,13 @@ export declare const machine: {
     }): Promise<number>;
     logout(): Promise<void>;
 };
+export declare function tokenIn(line: string): string | undefined;
 export declare function nextDelayMs(failures: number, busy?: boolean): number;
+interface Auth {
+    url: string;
+    token: string;
+}
+interface SignedIn extends Auth {
+    machine: Machine;
+}
+export {};

package/dist/machine.js

@@ -4,6 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, MachineRunSchema, MachineRunsResponseSchema, MachineSchema, MachineSessionSchema, MachinesResponseSchema, } from '@craftspace/shared';
+import { confirm, input, select } from '@inquirer/prompts';
 import { z } from 'zod';
 import { runner } from './run.js';
 import { setup } from './setup.js';
@@ -40,15 +41,32 @@ export const machine = {
         };
         return answer.machine;
     },
+    async signIn({ url, why, install = false }) {
+        const where = url ?? (await readConfig())?.url ?? DEFAULT_URL;
+        if (!process.stdin.isTTY)
+            throw new Error(`${why} Run: craftspace login --token <token>`);
+        const page = `${where}/workstations`;
+        process.stdout.write(`\n${why}\n\n`);
+        if (await confirm({ message: `Open ${page} for a key?`, default: true })) {
+            await openInBrowser(page);
+            process.stdout.write('  Click "Add a workstation" there, then copy the line it gives you.\n');
+        }
+        else {
+            process.stdout.write(`  Get one at ${page} under "Add a workstation".\n`);
+        }
+        const token = tokenIn(await input({
+            message: 'Paste it here',
+            validate: (line) => tokenIn(line) !== undefined || 'No cst_… token in that. Paste the whole line if it is easier.',
+        }));
+        if (token === undefined)
+            throw new Error('That line carries no key.');
+        const signed = await machine.login({ token, url: where, install });
+        process.stdout.write(`\nSigned in as ${signed.ownerName}. This machine is ${signed.name}.\n`);
+        return { url: where, token, machine: signed };
+    },
     async status() {
-        const config = await readConfig();
-        if (!config)
-            return null;
-        const token = await readToken();
-        if (!token)
-            return null;
-        const found = await call({ url: config.url, token, method: 'GET', path: '/api/machines/me', schema: MachineSchema });
-        return { machine: found, url: config.url };
+        const found = await withAuth(await signedInOrAsk(), (auth) => call({ ...auth, method: 'GET', path: '/api/machines/me', schema: MachineSchema }));
+        return { machine: found.value, url: found.auth.url };
     },
     async beatOnce() {
         const { url, token } = await requireSignedIn();
@@ -129,8 +147,9 @@ async function runHere(argv) {
     }
 }
 async function runThere({ argv, on }) {
-    const { url, token } = await requireSignedIn();
-    const target = await machineNamed({ url, token, name: on });
+    const first = await signedInOrAsk();
+    const { auth, value: target } = await withAuth(first, (live) => machineNamed({ ...live, name: on }));
+    const { url, token } = auth;
     let run = await call({
         url,
         token,
@@ -186,10 +205,21 @@ async function readRun({ url, token, machineId, runId, }) {
 async function machineNamed({ url, token, name, }) {
     const answer = await call({ url, token, method: 'GET', path: '/api/machines', schema: MachinesResponseSchema });
     const found = answer.machines.find((candidate) => candidate.name === name || candidate.id === name);
-    if (found === undefined) {
+    if (found !== undefined)
+        return found;
+    if (answer.machines.length === 0)
+        throw new Error('This team has no workstations yet. Add one at /workstations.');
+    if (!process.stdin.isTTY) {
         throw new Error(`No workstation called ${name}. This team has: ${answer.machines.map((m) => m.name).join(', ')}`);
     }
-    return found;
+    process.stdout.write(`\nNo workstation called ${name}.\n\n`);
+    return select({
+        message: 'Run it on',
+        choices: answer.machines.map((candidate) => ({
+            name: `${candidate.name.padEnd(20)} ${candidate.state}`,
+            value: candidate,
+        })),
+    });
 }
 function readStdinLine() {
     return new Promise((resolve) => {
@@ -244,10 +274,46 @@ async function call({ url, token, method, path: route, body, schema, }) {
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
     });
+    if (response.status === 401)
+        throw new Unauthorized();
     if (!response.ok)
         throw new Error(`${route} answered ${response.status}`);
     return schema.parse(await response.json());
 }
+class Unauthorized extends Error {
+    constructor() {
+        super('This machine no longer has a key Craftspace accepts.');
+    }
+}
+async function signedInOrAsk() {
+    const config = await readConfig();
+    const token = await readToken();
+    if (config && token)
+        return { url: config.url, token };
+    return machine.signIn({ why: 'This machine is not signed in to Craftspace yet.' });
+}
+async function withAuth(auth, work) {
+    try {
+        return { auth, value: await work(auth) };
+    }
+    catch (error) {
+        if (!(error instanceof Unauthorized))
+            throw error;
+        const next = await machine.signIn({
+            url: auth.url,
+            why: 'Craftspace does not know this machine any more. Its key was revoked, which is what forgetting the workstation, or signing the same box in somewhere else, does.',
+        });
+        process.stdout.write('\nPicking up where you left off.\n\n');
+        return { auth: next, value: await work(next) };
+    }
+}
+async function openInBrowser(url) {
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    await run(opener, [url]).catch(() => undefined);
+}
+export function tokenIn(line) {
+    return /cst_[A-Za-z0-9_-]+/.exec(line)?.[0];
+}
 async function ensureKey() {
     const priv = path.join(machine.home(), 'id_ed25519');
     const pub = `${priv}.pub`;
@@ -282,8 +348,6 @@ async function readSessions() {
     }
     return sessions.slice(0, MAX_REPORTED_SESSIONS);
 }
-// Only the block between our markers is ours. Everything a person put in this file by hand is left exactly
-// where it was, because the fastest way to lock a team out of its own box is to rewrite this file wholesale.
 async function writeAuthorizedKeys(keys) {
     const target = path.join(os.homedir(), '.ssh', 'authorized_keys');
     const current = await readFile(target, 'utf8').catch(() => '');
@@ -321,6 +385,30 @@ async function writeAgentConfigs({ url, token, writes, }) {
         owned.push(target);
     }
     await writeFile(ownedPath(), JSON.stringify({ paths: owned }, null, 2));
+    await acceptClaudeGates(serversIn(planned));
+}
+function serversIn(writes) {
+    return writes.flatMap((write) => isPlainObject(write.contents.mcpServers) ? Object.keys(write.contents.mcpServers) : []);
+}
+async function acceptClaudeGates(servers) {
+    const target = path.join(os.homedir(), '.claude.json');
+    const raw = await readFile(target, 'utf8').catch(() => null);
+    if (raw === null)
+        return;
+    const parsed = JSON.parse(raw);
+    const projects = isPlainObject(parsed.projects) ? parsed.projects : {};
+    const found = projects[os.homedir()];
+    const here = isPlainObject(found) ? { ...found } : {};
+    const enabled = new Set([...(Array.isArray(here.enabledMcpjsonServers) ? here.enabledMcpjsonServers : []), ...servers]);
+    if (here.hasTrustDialogAccepted === true && enabled.size === asArray(here.enabledMcpjsonServers).length)
+        return;
+    here.hasTrustDialogAccepted = true;
+    here.enabledMcpjsonServers = [...enabled];
+    const next = { ...parsed, projects: { ...projects, [os.homedir()]: here } };
+    await writeFile(target, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
 }
 function mergeInto(current, incoming) {
     const merged = { ...current };
@@ -466,6 +554,7 @@ const MAX_BACKOFF_MS = 120_000;
 const KEYS_BEGIN = '# craftspace begin';
 const KEYS_END = '# craftspace end';
 const POLL_INTERVAL_MS = 1_000;
+const DEFAULT_URL = process.env.CRAFTSPACE_URL ?? 'https://craftspace.app';
 const PROBE_EVERY_MS = 300_000;
 let probed = null;
 const reports = new Map();

package/dist/probe.js

@@ -33,24 +33,24 @@ async function brainWired(mcpPath) {
 }
 async function version({ id, command }) {
     const found = await firstLine(command, ['--version']);
-    if (typeof found === 'string')
-        return { id, ok: true, detail: found };
-    return { id, ok: false, detail: found === 'absent' ? 'not installed' : 'installed, but it will not report a version' };
+    if (found.ran)
+        return { id, ok: true, detail: found.line };
+    return { id, ok: false, detail: found.why === 'absent' ? 'not installed' : 'installed, but it will not report a version' };
 }
 async function gitAndGithub() {
     const git = await firstLine('git', ['--version']);
-    if (typeof git !== 'string')
+    if (!git.ran)
         return { id: 'git', ok: false, detail: 'git is not installed' };
     const gh = await firstLine('gh', ['--version']);
-    if (typeof gh !== 'string')
-        return { id: 'git', ok: false, detail: `${git} · the GitHub CLI is not installed yet` };
+    if (!gh.ran)
+        return { id: 'git', ok: false, detail: `${git.line} · the GitHub CLI is not installed yet` };
     const account = await githubAccount();
     return {
         id: 'git',
         ok: account !== null,
         detail: account === null
-            ? `${git} · ${gh}, run gh auth login on this machine`
-            : `${git} · ${gh}, signed in as ${account}`,
+            ? `${git.line} · ${gh.line}, run gh auth login on this machine`
+            : `${git.line} · ${gh.line}, signed in as ${account}`,
     };
 }
 async function githubAccount() {
@@ -63,8 +63,8 @@ export function githubUser(hostsYml) {
 async function chromeInstalled() {
     for (const command of [...MAC_CHROME, ...LINUX_CHROME]) {
         const found = await firstLine(command, ['--version']);
-        if (typeof found === 'string')
-            return { id: 'chrome', ok: true, detail: found };
+        if (found.ran)
+            return { id: 'chrome', ok: true, detail: found.line };
     }
     return { id: 'chrome', ok: false, detail: 'not installed yet, so browser runs will fail' };
 }
@@ -85,13 +85,13 @@ async function firstLine(command, args) {
     if (command.includes('/')) {
         const reachable = await access(command).then(() => true, () => false);
         if (!reachable)
-            return 'absent';
+            return { ran: false, why: 'absent' };
     }
     const answer = await run(command, args, { timeout: PROBE_TIMEOUT_MS }).catch((thrown) => thrown);
     if (answer instanceof Error)
-        return answer.code === 'ENOENT' ? 'absent' : 'broken';
+        return { ran: false, why: answer.code === 'ENOENT' ? 'absent' : 'broken' };
     const line = answer.stdout.split('\n')[0]?.trim() ?? '';
-    return line === '' ? 'broken' : line.slice(0, 200);
+    return line === '' ? { ran: false, why: 'broken' } : { ran: true, line: line.slice(0, 200) };
 }
 function short(target) {
     return target.startsWith(os.homedir()) ? `~${target.slice(os.homedir().length)}` : target;

package/dist/run.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import os from 'node:os';
 import { MACHINE_RUN_OUTPUT_MAX, spreadIfDefined } from '@craftspace/shared';
 export const runner = {
     attended(argv) {
@@ -10,6 +11,7 @@ export const runner = {
     },
     async unattended({ work, onProgress, }) {
         const argv = headlessArgv(work);
+        const raw = argv[0] === 'script';
         let output = '';
         let agentSessionId = work.agentSessionId ?? undefined;
         let lastText = '';
@@ -33,10 +35,24 @@ export const runner = {
             }
         };
         const code = await new Promise((resolve) => {
-            const child = spawn(argv[0], argv.slice(1), { stdio: ['ignore', 'pipe', 'pipe'] });
+            const child = spawn(argv[0], argv.slice(1), {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: os.homedir(),
+                env: {
+                    ...process.env,
+                    TERM: process.env.TERM ?? 'xterm-256color',
+                    COLUMNS: process.env.COLUMNS ?? '120',
+                    LINES: process.env.LINES ?? '40',
+                },
+            });
+            append('');
             child.stdout.setEncoding('utf8');
             child.stderr.setEncoding('utf8');
             child.stdout.on('data', (chunk) => {
+                if (raw) {
+                    append(chunk);
+                    return;
+                }
                 pending += chunk;
                 const lines = pending.split('\n');
                 pending = lines.pop() ?? '';
@@ -74,10 +90,8 @@ export function headlessArgv(work) {
     const argv = work.argv;
     if (!isAgent(argv[0]))
         return argv;
-    // A Remote Control session is interactive and long-lived, and its whole point is that a phone drives it.
-    // Wrapping it in -p would turn it into a one-shot print run with nothing to attach to.
     if (argv.includes('--remote-control'))
-        return argv;
+        return underTty(argv);
     const streaming = ['--output-format', 'stream-json', '--verbose'];
     if (work.answer !== null && work.agentSessionId !== null) {
         return [argv[0], '--resume', work.agentSessionId, '-p', work.answer, ...streaming];
@@ -86,6 +100,14 @@ export function headlessArgv(work) {
         return [...argv, ...streaming];
     return [argv[0], '-p', argv.slice(1).join(' '), ...streaming];
 }
+function underTty(argv) {
+    const line = `stty rows ${PTY_ROWS} cols ${PTY_COLS} 2>/dev/null; exec ${argv.join(' ')}`;
+    return process.platform === 'linux'
+        ? ['script', '-qec', line, '/dev/null']
+        : ['script', '-q', '/dev/null', 'sh', '-c', line];
+}
+const PTY_ROWS = 40;
+const PTY_COLS = 120;
 function isAgent(command) {
     return AGENTS.has((command ?? '').split('/').pop() ?? '');
 }

package/dist/setup.d.ts

@@ -1,5 +1,6 @@
 import type { MachineTool } from '@craftspace/shared';
 export declare const setup: {
+    widenPath(): void;
     run({ install, rewire, say, }: {
         install: boolean;
         rewire?: () => Promise<void>;

package/dist/setup.js

@@ -1,31 +1,72 @@
 import { execFile } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
 import { promisify } from 'node:util';
 import { probe } from './probe.js';
 const run = promisify(execFile);
 export const setup = {
+    widenPath() {
+        const current = (process.env.PATH ?? '').split(path.delimiter).filter((entry) => entry !== '');
+        const missing = toolDirs().filter((entry) => !current.includes(entry));
+        if (missing.length > 0)
+            process.env.PATH = [...current, ...missing].join(path.delimiter);
+    },
     async run({ install, rewire, say, }) {
         const found = await probe.tools();
         if (!install)
-            return found;
+            return withReasons(found);
         const repairs = { ...REPAIRS, ...(rewire === undefined ? {} : { brain: { name: 'the brain', fix: rewire } }) };
-        const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== undefined);
+        const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== undefined && isDue(tool.id));
         if (broken.length === 0)
-            return found;
+            return withReasons(found);
         for (const tool of broken) {
             const repair = repairs[tool.id];
             if (repair === undefined)
                 continue;
             say?.(`Setting up ${repair.name}`);
+            tried.set(tool.id, Date.now());
             const failed = await repair.fix().then(() => null, (error) => firstLine(error.message));
+            if (failed === null)
+                reasons.delete(tool.id);
+            else
+                reasons.set(tool.id, failed);
             say?.(failed === null ? `  ${repair.name} is ready` : `  could not set up ${repair.name}: ${failed}`);
         }
-        return probe.tools();
+        return withReasons(await probe.tools());
     },
 };
+function isDue(id) {
+    const last = tried.get(id);
+    return last === undefined || Date.now() - last > RETRY_AFTER_MS;
+}
+function withReasons(tools) {
+    return tools.map((tool) => {
+        const reason = tool.ok ? undefined : reasons.get(tool.id);
+        return reason === undefined ? tool : { ...tool, detail: `${tool.detail} · ${reason}`.slice(0, 200) };
+    });
+}
+function toolDirs() {
+    const prefix = process.env.npm_config_prefix;
+    return [
+        path.dirname(process.execPath),
+        ...(prefix === undefined ? [] : [path.join(prefix, 'bin')]),
+        path.join(os.homedir(), '.local', 'bin'),
+        path.join(os.homedir(), '.npm-global', 'bin'),
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+    ];
+}
 const REPAIRS = {
     claude: { name: 'Claude Code', fix: () => npmGlobal('@anthropic-ai/claude-code') },
     codex: { name: 'Codex', fix: () => npmGlobal('@openai/codex') },
-    git: { name: 'the GitHub CLI', fix: () => installPackage({ brew: ['gh'], apt: ['gh'], dnf: ['gh'] }) },
+    git: {
+        name: 'the GitHub CLI',
+        fix: async () => {
+            if ((await firstAvailable(['gh'])) !== null)
+                return;
+            await installPackage({ brew: ['gh'], apt: ['gh'], dnf: ['gh'] });
+        },
+    },
     chrome: {
         name: 'Google Chrome',
         fix: () => installPackage({ brew: ['--cask', 'google-chrome'], apt: ['chromium'], dnf: ['chromium'] }),
@@ -56,4 +97,7 @@ async function firstAvailable(commands) {
 function firstLine(message) {
     return message.split('\n')[0] ?? 'it failed';
 }
+const tried = new Map();
+const reasons = new Map();
 const INSTALL_TIMEOUT_MS = 180_000;
+const RETRY_AFTER_MS = 21_600_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftspace/cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "description": "Sign a Mac or Linux machine into Craftspace and keep its agent setup in step.",
   "license": "MIT",
@@ -30,6 +30,7 @@
   },
   "devDependencies": {
     "@craftspace/shared": "*",
+    "@inquirer/prompts": "^8.7.2",
     "@types/node": "^22.0.0",
     "commander": "^14.0.0",
     "esbuild": "^0.28.0",