@craftspace/cli 0.4.3 → 0.6.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<{

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, MachineRepoSchema, 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,18 +86,27 @@ export const machine = {
                 ...load(),
                 sessions: await readSessions(),
                 runs: drainReports(),
-                tools: await tools(),
+                tools: await checks(),
+                environment: built?.results ?? [],
+                templateId: built?.templateId ?? null,
+                workDir: setup.workDir(),
+                repos: built?.repos ?? [],
                 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;
             running.add(work.id);
             void runner
-                .unattended({ work, onProgress: report })
+                .unattended({ work, cwd: startIn(built), onProgress: report })
                 .then(report)
                 .catch((error) => report({ id: work.id, state: 'failed', output: messageOf(error) }))
                 .finally(() => running.delete(work.id));
@@ -109,7 +118,7 @@ export const machine = {
         let busy = false;
         let checkedAt = 0;
         for (;;) {
-            if (!busy && Date.now() - checkedAt > UPDATE_EVERY_MS) {
+            if (!busy && (failures > 2 || Date.now() - checkedAt > UPDATE_EVERY_MS)) {
                 checkedAt = Date.now();
                 const moved = await update.toLatest();
                 if (moved !== null) {
@@ -170,7 +179,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,
     });
@@ -218,13 +227,75 @@ 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();
+    const buildsSteps = buildIsDue(built, next.templateId);
+    const clonesRepos = cloneIsDue(built, next.repos);
+    if (!buildsSteps && !clonesRepos)
+        return;
+    building = true;
+    try {
+        let results = built?.results ?? [];
+        let repos = built?.repos ?? [];
+        if (buildsSteps) {
+            say?.(ui.heading(`Building the ${next.steps.length} setup scripts your team runs on every box`));
+            results = await setup.runSteps({ steps: next.steps, say });
+        }
+        if (clonesRepos) {
+            say?.(ui.heading(`Cloning the ${next.repos.length} repos your team works in, into ${setup.workDir()}`));
+            repos = await setup.cloneRepos({ repos: next.repos, say });
+            await acceptClaudeGates(['craftspace'], repos.filter((repo) => repo.ok).map((repo) => repo.path));
+        }
+        await writeEnvironment({ templateId: next.templateId, results, repos, at: Date.now() });
+    }
+    finally {
+        building = false;
+    }
+}
+function cloneIsDue(built, wanted) {
+    const cloned = built?.repos ?? [];
+    if (wanted.length === 0 && cloned.length === 0)
+        return false;
+    if (wanted.length !== cloned.length)
+        return true;
+    const missing = wanted.some((repo) => !cloned.some((seen) => seen.name === repo.name && seen.ref === repo.ref && seen.ok));
+    return missing || Date.now() - (built?.at ?? 0) > REBUILD_AFTER_MS;
+}
+function startIn(built) {
+    return built?.repos.find((repo) => repo.ok)?.path ?? os.homedir();
+}
+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: [] });
@@ -357,22 +428,29 @@ async function writeAgentConfigs({ url, token, writes, }) {
 function serversIn(writes) {
     return writes.flatMap((write) => isPlainObject(write.contents.mcpServers) ? Object.keys(write.contents.mcpServers) : []);
 }
-async function acceptClaudeGates(servers) {
+async function acceptClaudeGates(servers, dirs = [os.homedir()]) {
     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)
+    const opened = { ...projects };
+    let moved = false;
+    for (const dir of dirs) {
+        const found = opened[dir];
+        const here = isPlainObject(found) ? { ...found } : {};
+        const enabled = new Set([...asArray(here.enabledMcpjsonServers), ...servers]);
+        if (here.hasTrustDialogAccepted === true && enabled.size === asArray(here.enabledMcpjsonServers).length)
+            continue;
+        here.hasTrustDialogAccepted = true;
+        here.enabledMcpjsonServers = [...enabled];
+        opened[dir] = here;
+        moved = true;
+    }
+    if (!moved)
         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 });
+    await writeFile(target, `${JSON.stringify({ ...parsed, projects: opened }, null, 2)}\n`, { mode: 0o600 });
 }
 function asArray(value) {
     return Array.isArray(value) ? value : [];
@@ -426,7 +504,8 @@ async function installService() {
         await writeFile(path.join(dir, `${SERVICE_NAME}.service`), systemdUnit());
         await run('loginctl', ['enable-linger', os.userInfo().username]).catch(() => undefined);
         await run('systemctl', ['--user', 'daemon-reload']).catch(() => undefined);
-        await run('systemctl', ['--user', 'enable', '--now', SERVICE_NAME]).catch(() => undefined);
+        await run('systemctl', ['--user', 'enable', SERVICE_NAME]).catch(() => undefined);
+        await run('systemctl', ['--user', 'restart', SERVICE_NAME]).catch(() => undefined);
         return;
     }
     if (process.platform === 'darwin') {
@@ -503,6 +582,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);
@@ -521,6 +603,12 @@ 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),
+    repos: z.array(MachineRepoSchema).default([]),
+    at: z.number(),
+});
 const OwnedSchema = z.object({ paths: z.array(z.string()) });
 const SERVICE_NAME = 'craftspace';
 const LAUNCH_LABEL = 'app.craftspace.machine';
@@ -549,6 +637,8 @@ const PORTABLE_TERMS = new Set([
 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/run.d.ts

@@ -1,8 +1,9 @@
 import { type MachineRunReport, type MachineWork } from '@craftspace/shared';
 export declare const runner: {
     attended(argv: string[]): Promise<number>;
-    unattended({ work, onProgress, }: {
+    unattended({ work, cwd, onProgress, }: {
         work: MachineWork;
+        cwd?: string;
         onProgress?: (report: MachineRunReport) => void;
     }): Promise<MachineRunReport>;
 };

package/dist/run.js

@@ -9,7 +9,7 @@ export const runner = {
             child.on('close', (code) => resolve(code ?? 0));
         });
     },
-    async unattended({ work, onProgress, }) {
+    async unattended({ work, cwd = os.homedir(), onProgress, }) {
         const argv = headlessArgv(work);
         const raw = argv[0] === 'script';
         let output = '';
@@ -37,7 +37,7 @@ export const runner = {
         const code = await new Promise((resolve) => {
             const child = spawn(argv[0], argv.slice(1), {
                 stdio: ['ignore', 'pipe', 'pipe'],
-                cwd: os.homedir(),
+                cwd,
                 env: {
                     ...process.env,
                     TERM: process.env.TERM ?? 'xterm-256color',

package/dist/setup.d.ts

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

package/dist/setup.js

@@ -1,10 +1,9 @@
 import { execFile } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
 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 +11,95 @@ 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)}`);
+    workDir() {
+        return path.join(os.homedir(), WORK_DIR_NAME);
+    },
+    async cloneRepos({ repos, say, }) {
+        if (repos.length === 0)
+            return [];
+        await mkdir(setup.workDir(), { recursive: true });
+        const cloned = [];
+        for (const [index, repo] of repos.entries()) {
+            say?.(ui.progress({ name: repo.name, done: index, total: repos.length }));
+            const at = path.join(setup.workDir(), repo.name.split('/').pop() ?? repo.name);
+            const outcome = await checkout(repo, at);
+            cloned.push({ name: repo.name, ref: repo.ref, path: at, ...outcome });
+            say?.(`${ui.clear()}${outcome.ok ? ui.ok(`${repo.name} · ${outcome.detail}`) : ui.bad(repo.name, outcome.detail)}`);
         }
-        say?.(ui.tally({ done: ready, total: broken.length, noun: 'ready' }));
-        return withReasons(await probe.tools());
+        say?.(ui.tally({ done: cloned.filter((repo) => repo.ok).length, total: cloned.length, noun: 'cloned' }));
+        return cloned;
+    },
+    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)}`);
+        }
+        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;
+async function checkout(repo, at) {
+    const opened = await git(['-C', at, 'rev-parse', '--abbrev-ref', 'HEAD']);
+    if (!opened.ok) {
+        const url = `https://github.com/${repo.name}.git`;
+        const made = await git(['clone', '--depth', String(CLONE_DEPTH), '--branch', repo.ref, url, at]);
+        if (!made.ok)
+            return { ok: false, detail: made.detail };
+        return { ok: true, detail: await state({ repo, at, branch: repo.ref, dirty: false }) };
+    }
+    const branch = opened.detail;
+    const dirty = (await git(['-C', at, 'status', '--porcelain'])).detail !== '';
+    const pulled = branch === repo.ref && !dirty ? await git(['-C', at, 'pull', '--ff-only']) : null;
+    return { ok: true, detail: await state({ repo, at, branch, dirty, pulled }) };
 }
-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) };
+async function state({ repo, at, branch, dirty, pulled, }) {
+    const head = await git(['-C', at, 'rev-parse', '--short', 'HEAD']);
+    return [
+        `${branch} @ ${head.detail}`,
+        branch === repo.ref ? '' : `your team asks for ${repo.ref}`,
+        dirty ? 'uncommitted work here, so it was left alone' : '',
+        pulled?.ok === false ? `could not pull: ${pulled.detail}` : '',
+    ]
+        .filter((part) => part !== '')
+        .join(' · ');
+}
+function git(argv) {
+    return new Promise((resolve) => {
+        execFile('git', argv, {
+            timeout: CLONE_TIMEOUT_MS,
+            maxBuffer: SCRIPT_BUFFER_BYTES,
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: '', GIT_LFS_SKIP_SMUDGE: '1' },
+        }, (error, stdout, stderr) => {
+            if (error === null)
+                return resolve({ ok: true, detail: stdout.trim() });
+            resolve({ ok: false, detail: lastLines(`${stderr}\n${stdout}`) || error.message.split('\n')[0] || 'git failed' });
+        });
     });
 }
+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 +111,9 @@ 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 WORK_DIR_NAME = 'craftspace';
+const CLONE_DEPTH = 20;
+const CLONE_TIMEOUT_MS = 900_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.3",
+  "version": "0.6.0",
   "type": "module",
   "description": "Sign a Mac or Linux machine into Craftspace and keep its agent setup in step.",
   "license": "MIT",