@craftspace/cli 0.4.2 → 0.5.0

package/dist/machine.d.ts

@@ -16,7 +16,7 @@ export declare const machine: {
         machine: Machine;
         url: string;
     }>;
-    beatOnce(): Promise<boolean>;
+    beatOnce(say?: (line: string) => void): Promise<boolean>;
     beatForever(): Promise<void>;
     run(): Promise<number>;
     daemon(): Promise<{
@@ -25,6 +25,7 @@ export declare const machine: {
     }>;
     logout(): Promise<void>;
 };
+export declare function portableTerm(local: string | undefined): string;
 export declare function tokenIn(line: string): string | undefined;
 export declare function nextDelayMs(failures: number, busy?: boolean): number;
 interface Auth {

package/dist/machine.js

@@ -3,9 +3,10 @@ import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 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, MachineSchema, MachineSessionSchema, MachinesResponseSchema, } from '@craftspace/shared';
+import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, MachineSchema, MachineSessionSchema, MachinesResponseSchema, WorkstationStepResultSchema, } from '@craftspace/shared';
 import { confirm, input, select } from '@inquirer/prompts';
 import { z } from 'zod';
+import { probe } from './probe.js';
 import { runner } from './run.js';
 import { setup } from './setup.js';
 import { ui } from './ui.js';
@@ -37,10 +38,8 @@ export const machine = {
         await writeFile(tokenPath(), token, { mode: 0o600 });
         await writeAgentConfigs({ url, token, writes: answer.write });
         await installService();
-        probed = {
-            at: Date.now(),
-            tools: await setup.run({ install, rewire, say: ui.say }),
-        };
+        if (install)
+            await machine.beatOnce(ui.say);
         return answer.machine;
     },
     async controlPlane(override) {
@@ -74,8 +73,9 @@ export const machine = {
         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() {
+    async beatOnce(say) {
         const { url, token } = await requireSignedIn();
+        const built = await readEnvironment();
         const answer = await call({
             url,
             token,
@@ -86,12 +86,19 @@ export const machine = {
                 ...load(),
                 sessions: await readSessions(),
                 runs: drainReports(),
-                tools: await tools(),
+                tools: await checks(),
+                environment: built?.results ?? [],
+                templateId: built?.templateId ?? null,
                 sshUser: os.userInfo().username,
             },
             schema: MachineBeatResponseSchema,
         });
         await writeAuthorizedKeys(answer.authorizedKeys);
+        const building = buildEnvironment(answer.environment, say);
+        if (say === undefined)
+            void building.catch(() => undefined);
+        else
+            await building;
         for (const work of answer.work) {
             if (running.has(work.id))
                 continue;
@@ -170,7 +177,7 @@ async function pick(machines) {
         choices: machines.map((candidate) => ({
             name: `${candidate.name.padEnd(24)} ${candidate.state.padEnd(12)} ${specs(candidate)}  ${beat(candidate)}`,
             value: candidate,
-            description: candidate.sshAddress === null ? 'No address yet, so nothing to open' : undefined,
+            disabled: candidate.sshAddress === null ? '(no address yet, so nothing to open)' : false,
         })),
         pageSize: 12,
     });
@@ -197,7 +204,10 @@ async function openTerminal(target) {
     const where = `${target.sshUser ?? 'root'}@${target.sshAddress}`;
     ui.say(`\n${ui.dim('\u2192')} ${ui.name(target.name)} ${ui.dim(`\u00b7 ${where}`)}\n\n`);
     return new Promise((resolve) => {
-        const session = spawn('ssh', ['-t', where], { stdio: 'inherit' });
+        const session = spawn('ssh', ['-t', where], {
+            stdio: 'inherit',
+            env: { ...process.env, TERM: portableTerm(process.env.TERM) },
+        });
         session.on('error', (error) => {
             ui.say(ui.bad(`could not start ssh`, error.message));
             resolve(1);
@@ -205,6 +215,9 @@ async function openTerminal(target) {
         session.on('exit', (code) => resolve(code ?? 0));
     });
 }
+export function portableTerm(local) {
+    return local !== undefined && PORTABLE_TERMS.has(local) ? local : 'xterm-256color';
+}
 function nowhereToGo({ url }) {
     ui.say(`\n${ui.attention('No workstations here yet.')}\n\n`);
     ui.say(ui.field('Add one', ui.link(`${url}/workstations`)));
@@ -212,13 +225,52 @@ function nowhereToGo({ url }) {
     ui.say('\n');
     return 1;
 }
-async function tools() {
+async function checks() {
     if (probed !== null && Date.now() - probed.at < PROBE_EVERY_MS)
         return probed.tools;
-    const found = await setup.run({ install: process.env.CRAFTSPACE_NO_INSTALL !== '1', rewire });
+    const first = await probe.tools();
+    const unwired = first.some((tool) => tool.id === 'brain' && !tool.ok);
+    const found = unwired && installs() ? await rewire().then(() => probe.tools(), () => first) : first;
     probed = { at: Date.now(), tools: found };
     return found;
 }
+async function buildEnvironment(next, say) {
+    if (building || !installs() || next.templateId === null)
+        return;
+    const built = await readEnvironment();
+    if (!buildIsDue(built, next.templateId))
+        return;
+    building = true;
+    try {
+        say?.(ui.heading(`Building the ${next.steps.length} setup scripts your team runs on every box`));
+        const results = await setup.runSteps({ steps: next.steps, say });
+        await writeEnvironment({ templateId: next.templateId, results, at: Date.now() });
+    }
+    finally {
+        building = false;
+    }
+}
+function buildIsDue(built, templateId) {
+    if (built === null || built.templateId !== templateId)
+        return true;
+    if (built.results.every((result) => result.ok))
+        return false;
+    return Date.now() - built.at > REBUILD_AFTER_MS;
+}
+async function readEnvironment() {
+    const raw = await readFile(environmentPath(), 'utf8').catch(() => null);
+    if (raw === null)
+        return null;
+    const parsed = BuiltSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+}
+async function writeEnvironment(built) {
+    await mkdir(machine.home(), { recursive: true, mode: 0o700 });
+    await writeFile(environmentPath(), JSON.stringify(built, null, 2), { mode: 0o600 });
+}
+function installs() {
+    return process.env.CRAFTSPACE_NO_INSTALL !== '1';
+}
 async function rewire() {
     const { url, token } = await requireSignedIn();
     await writeAgentConfigs({ url, token, writes: [] });
@@ -497,6 +549,9 @@ function tokenPath() {
 function ownedPath() {
     return path.join(machine.home(), 'owned.json');
 }
+function environmentPath() {
+    return path.join(machine.home(), 'environment.json');
+}
 function load() {
     const cores = Math.max(1, os.cpus().length);
     const busy = Math.min(100, ((os.loadavg()[0] ?? 0) / cores) * 100);
@@ -515,6 +570,11 @@ function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
 const ConfigSchema = z.object({ url: z.string(), machineId: z.string() });
+const BuiltSchema = z.object({
+    templateId: z.string(),
+    results: z.array(WorkstationStepResultSchema),
+    at: z.number(),
+});
 const OwnedSchema = z.object({ paths: z.array(z.string()) });
 const SERVICE_NAME = 'craftspace';
 const LAUNCH_LABEL = 'app.craftspace.machine';
@@ -525,9 +585,26 @@ const KEYS_BEGIN = '# craftspace begin';
 const KEYS_END = '# craftspace end';
 const UPDATE_EVERY_MS = 6 * 60 * 60 * 1_000;
 const BEATING = 'beating every 15s, outbound only, and keeps this set up';
+const PORTABLE_TERMS = new Set([
+    'ansi',
+    'dumb',
+    'linux',
+    'rxvt',
+    'rxvt-unicode',
+    'rxvt-unicode-256color',
+    'screen',
+    'screen-256color',
+    'vt100',
+    'vt220',
+    'xterm',
+    'xterm-color',
+    'xterm-256color',
+]);
 const LINGER_LINE = `sudo loginctl enable-linger ${os.userInfo().username}`;
 const DEFAULT_URL = process.env.CRAFTSPACE_URL ?? 'https://craftspace.app';
 const PROBE_EVERY_MS = 300_000;
+const REBUILD_AFTER_MS = 21_600_000;
 let probed = null;
+let building = false;
 const reports = new Map();
 const running = new Set();

package/dist/probe.d.ts

@@ -4,4 +4,3 @@ export declare const probe: {
         mcpPath?: string;
     }): Promise<MachineTool[]>;
 };
-export declare function githubUser(hostsYml: string): string | null;

package/dist/probe.js

@@ -1,21 +1,10 @@
-import { execFile } from 'node:child_process';
 import net from 'node:net';
-import { access, readFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { promisify } from 'node:util';
-const run = promisify(execFile);
 export const probe = {
     async tools({ mcpPath = path.join(os.homedir(), '.mcp.json') } = {}) {
-        const [brain, claude, codex, git, chrome, ssh] = await Promise.all([
-            brainWired(mcpPath),
-            version({ id: 'claude', command: 'claude' }),
-            version({ id: 'codex', command: 'codex' }),
-            gitAndGithub(),
-            chromeInstalled(),
-            sshListening(),
-        ]);
-        return [brain, claude, codex, git, chrome, ssh];
+        return Promise.all([brainWired(mcpPath), sshListening()]);
     },
 };
 async function brainWired(mcpPath) {
@@ -31,43 +20,6 @@ async function brainWired(mcpPath) {
         detail: wired ? short(mcpPath) : `${short(mcpPath)} has no craftspace entry`,
     };
 }
-async function version({ id, command }) {
-    const found = await firstLine(command, ['--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 (!git.ran)
-        return { id: 'git', ok: false, detail: 'git is not installed' };
-    const gh = await firstLine('gh', ['--version']);
-    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.line} · ${gh.line}, run gh auth login on this machine`
-            : `${git.line} · ${gh.line}, signed in as ${account}`,
-    };
-}
-async function githubAccount() {
-    const raw = await readFile(path.join(os.homedir(), '.config', 'gh', 'hosts.yml'), 'utf8').catch(() => null);
-    return raw === null ? null : githubUser(raw);
-}
-export function githubUser(hostsYml) {
-    return /^ {4}user: *(\S+) *$/m.exec(hostsYml)?.[1] ?? null;
-}
-async function chromeInstalled() {
-    for (const command of [...MAC_CHROME, ...LINUX_CHROME]) {
-        const found = await firstLine(command, ['--version']);
-        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' };
-}
 function sshListening() {
     return new Promise((resolve) => {
         const socket = net.connect({ host: '127.0.0.1', port: 22 });
@@ -78,25 +30,10 @@ function sshListening() {
         socket.setTimeout(SSH_PROBE_TIMEOUT_MS);
         socket.on('connect', () => answer(true, 'sshd is listening on port 22'));
         socket.on('timeout', () => answer(false, 'nothing answered on port 22'));
-        socket.on('error', () => answer(false, 'sshd is not running, so nobody can ssh in'));
+        socket.on('error', () => answer(false, 'sshd is not running, so nobody can open a terminal here'));
     });
 }
-async function firstLine(command, args) {
-    if (command.includes('/')) {
-        const reachable = await access(command).then(() => true, () => false);
-        if (!reachable)
-            return { ran: false, why: 'absent' };
-    }
-    const answer = await run(command, args, { timeout: PROBE_TIMEOUT_MS }).catch((thrown) => thrown);
-    if (answer instanceof Error)
-        return { ran: false, why: answer.code === 'ENOENT' ? 'absent' : 'broken' };
-    const line = answer.stdout.split('\n')[0]?.trim() ?? '';
-    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;
 }
-const MAC_CHROME = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
-const LINUX_CHROME = ['google-chrome', 'google-chrome-stable', 'chromium'];
-const PROBE_TIMEOUT_MS = 5_000;
 const SSH_PROBE_TIMEOUT_MS = 1_500;

package/dist/setup.d.ts

@@ -1,9 +1,8 @@
-import type { MachineTool } from '@craftspace/shared';
+import { type WorkstationStep, type WorkstationStepResult } from '@craftspace/shared';
 export declare const setup: {
     widenPath(): void;
-    run({ install, rewire, say, }: {
-        install: boolean;
-        rewire?: () => Promise<void>;
+    runSteps({ steps, say, }: {
+        steps: WorkstationStep[];
         say?: (line: string) => void;
-    }): Promise<MachineTool[]>;
+    }): Promise<WorkstationStepResult[]>;
 };

package/dist/setup.js

@@ -1,10 +1,8 @@
 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';
+import { WORKSTATION_STEP_DETAIL_MAX_CHARS, } from '@craftspace/shared';
 import { ui } from './ui.js';
-const run = promisify(execFile);
 export const setup = {
     widenPath() {
         const current = (process.env.PATH ?? '').split(path.delimiter).filter((entry) => entry !== '');
@@ -12,44 +10,39 @@ export const setup = {
         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 withReasons(found);
-        const repairs = { ...REPAIRS, ...(rewire === undefined ? {} : { brain: { name: 'the brain', fix: rewire } }) };
-        const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== undefined && isDue(tool.id));
-        if (broken.length === 0)
-            return withReasons(found);
-        let ready = 0;
-        for (const [index, tool] of broken.entries()) {
-            const repair = repairs[tool.id];
-            if (repair === undefined)
-                continue;
-            say?.(ui.progress({ name: repair.name, done: index, total: broken.length }));
-            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);
-            if (failed === null)
-                ready += 1;
-            say?.(`${ui.clear()}${failed === null ? ui.ok(repair.name) : ui.bad(repair.name, failed)}`);
+    async runSteps({ steps, say, }) {
+        const results = [];
+        for (const [index, step] of steps.entries()) {
+            say?.(ui.progress({ name: step.name, done: index, total: steps.length }));
+            const startedAt = Date.now();
+            const outcome = await runScript(step.script);
+            results.push({ ...outcome, id: step.id, name: step.name, ms: Date.now() - startedAt });
+            say?.(`${ui.clear()}${outcome.ok ? ui.ok(step.name) : ui.bad(step.name, outcome.detail)}`);
         }
-        say?.(ui.tally({ done: ready, total: broken.length, noun: 'ready' }));
-        return withReasons(await probe.tools());
+        if (results.length > 0) {
+            say?.(ui.tally({ done: results.filter((result) => result.ok).length, total: results.length, noun: 'ready' }));
+        }
+        return results;
     },
 };
-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 runScript(script) {
+    return new Promise((resolve) => {
+        execFile('/bin/sh', ['-e', '-c', script], { timeout: STEP_TIMEOUT_MS, maxBuffer: SCRIPT_BUFFER_BYTES }, (error, stdout, stderr) => {
+            if (error === null)
+                return resolve({ ok: true, detail: lastLines(stdout) });
+            resolve({ ok: false, detail: lastLines(`${stderr}\n${stdout}`) || error.message.split('\n')[0] || 'it failed' });
+        });
     });
 }
+function lastLines(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '')
+        .slice(-KEPT_LINES)
+        .join(' · ')
+        .slice(0, WORKSTATION_STEP_DETAIL_MAX_CHARS);
+}
 function toolDirs() {
     const prefix = process.env.npm_config_prefix;
     return [
@@ -61,48 +54,6 @@ function toolDirs() {
         '/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: 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'] }),
-    },
-};
-async function npmGlobal(name) {
-    await run('npm', ['install', '-g', name], { timeout: INSTALL_TIMEOUT_MS });
-}
-async function installPackage({ brew, apt, dnf }) {
-    if (process.platform === 'darwin') {
-        await run('brew', ['install', ...brew], { timeout: INSTALL_TIMEOUT_MS });
-        return;
-    }
-    const manager = await firstAvailable(['apt-get', 'dnf']);
-    if (manager === null)
-        throw new Error('no package manager this CLI knows how to drive');
-    const packages = manager === 'apt-get' ? apt : dnf;
-    await run('sudo', ['-n', manager, 'install', '-y', ...packages], { timeout: INSTALL_TIMEOUT_MS });
-}
-async function firstAvailable(commands) {
-    for (const command of commands) {
-        const there = await run('/bin/sh', ['-c', `command -v ${command}`]).then(() => true, () => false);
-        if (there)
-            return command;
-    }
-    return null;
-}
-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;
+const STEP_TIMEOUT_MS = 600_000;
+const SCRIPT_BUFFER_BYTES = 4 * 1024 * 1024;
+const KEPT_LINES = 3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftspace/cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "description": "Sign a Mac or Linux machine into Craftspace and keep its agent setup in step.",
   "license": "MIT",