@craftspace/cli 0.2.2 → 0.4.0

package/dist/machine.d.ts

@@ -6,6 +6,7 @@ export declare const machine: {
         url: string;
         install: boolean;
     }): Promise<Machine>;
+    url(): Promise<string | null>;
     signIn({ url, why, install }: {
         url?: string;
         why: string;
@@ -17,11 +18,11 @@ export declare const machine: {
     }>;
     beatOnce(): Promise<boolean>;
     beatForever(): Promise<void>;
-    run({ argv, on }: {
-        argv: string[];
-        on?: string;
-    }): Promise<number>;
-    daemonLine(): Promise<string>;
+    run(): Promise<number>;
+    daemon(): Promise<{
+        text: string;
+        ok: boolean;
+    }>;
     logout(): Promise<void>;
 };
 export declare function tokenIn(line: string): string | undefined;

package/dist/machine.js

@@ -1,13 +1,15 @@
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 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, MachineRunSchema, MachineRunsResponseSchema, MachineSchema, MachineSessionSchema, MachinesResponseSchema, } from '@craftspace/shared';
+import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, 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';
+import { ui } from './ui.js';
+import { update } from './update.js';
 const run = promisify(execFile);
 export const machine = {
     home() {
@@ -37,22 +39,25 @@ export const machine = {
         await installService();
         probed = {
             at: Date.now(),
-            tools: await setup.run({ install, rewire, say: (text) => process.stdout.write(text) }),
+            tools: await setup.run({ install, rewire, say: ui.say }),
         };
         return answer.machine;
     },
+    async url() {
+        return (await readConfig())?.url ?? null;
+    },
     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>`);
+            throw new Error(`${why} Run: cs login --token <token>`);
         const page = `${where}/workstations`;
-        process.stdout.write(`\n${why}\n\n`);
+        ui.say(`\n${ui.attention(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');
+            ui.say(ui.note('Click "Add a workstation" there, then copy the line it gives you.'));
         }
         else {
-            process.stdout.write(`  Get one at ${page} under "Add a workstation".\n`);
+            ui.say(ui.note(`Get one at ${ui.link(page)} under "Add a workstation".`));
         }
         const token = tokenIn(await input({
             message: 'Paste it here',
@@ -61,7 +66,7 @@ export const machine = {
         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`);
+        ui.say(`\n${ui.ok(`Signed in as ${signed.ownerName}. This machine is ${ui.name(signed.name)}.`)}`);
         return { url: where, token, machine: signed };
     },
     async status() {
@@ -101,7 +106,16 @@ export const machine = {
     async beatForever() {
         let failures = 0;
         let busy = false;
+        let checkedAt = 0;
         for (;;) {
+            if (!busy && Date.now() - checkedAt > UPDATE_EVERY_MS) {
+                checkedAt = Date.now();
+                const moved = await update.toLatest();
+                if (moved !== null) {
+                    process.stderr.write(`craftspace ${CLI_VERSION} -> ${moved}, restarting\n`);
+                    return;
+                }
+            }
             try {
                 busy = await machine.beatOnce();
                 failures = 0;
@@ -113,21 +127,23 @@ export const machine = {
             await new Promise((resolve) => setTimeout(resolve, nextDelayMs(failures, busy)));
         }
     },
-    async run({ argv, on }) {
-        if (on === undefined)
-            return runHere(argv);
-        return runThere({ argv, on });
+    async run() {
+        const first = await signedInOrAsk();
+        const { auth, value: answer } = await withAuth(first, (live) => call({ ...live, method: 'GET', path: '/api/machines', schema: MachinesResponseSchema }));
+        if (answer.machines.length === 0)
+            return nowhereToGo(auth);
+        return openTerminal(await pick(answer.machines));
     },
-    async daemonLine() {
+    async daemon() {
         if (process.env.CRAFTSPACE_NO_SERVICE === '1')
-            return `not installed. Start it with: ${here()} daemon`;
+            return { text: `not installed. Start it with: ${here()} daemon`, ok: false };
         if (process.platform !== 'linux')
-            return BEATING;
+            return { text: BEATING, ok: true };
         if (!(await serviceRunning()))
-            return `not running. Start it with: ${here()} daemon`;
+            return { text: `not running. Start it with: ${here()} daemon`, ok: false };
         if (!(await userLingers()))
-            return `beating, but it stops when you log out. Run: ${LINGER_LINE}`;
-        return BEATING;
+            return { text: `beating, but it stops when you log out. Run: ${LINGER_LINE}`, ok: false };
+        return { text: BEATING, ok: true };
     },
     async logout() {
         const config = await readConfig();
@@ -144,116 +160,57 @@ async function requireSignedIn() {
     const config = await readConfig();
     const token = await readToken();
     if (!config || !token)
-        throw new Error('This machine is not signed in. Run: craftspace login --token <token>');
+        throw new Error('This machine is not signed in. Run: cs login --token <token>');
     return { url: config.url, token };
 }
-async function runHere(argv) {
-    const id = `local-${Date.now().toString(36)}`;
-    await writeSession({ id, state: 'working', title: argv.join(' ').slice(0, 200) });
-    try {
-        return await runner.attended(argv);
-    }
-    finally {
-        await clearSession(id);
-    }
-}
-async function runThere({ argv, 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,
-        method: 'POST',
-        path: `/api/machines/${target.id}/runs`,
-        body: { argv },
-        schema: MachineRunSchema,
-    });
-    process.stdout.write(`${target.name} · queued ${run.id}\n\n`);
-    let printed = 0;
-    for (;;) {
-        if (run.output.length > printed) {
-            process.stdout.write(run.output.slice(printed));
-            printed = run.output.length;
-        }
-        if (run.state === 'done')
-            return 0;
-        if (run.state === 'failed')
-            return run.exitCode ?? 1;
-        if (run.state === 'needs_input') {
-            process.stdout.write(`\n${target.name} is asking: ${run.question ?? 'it needs a decision'}\n> `);
-            const reply = await readStdinLine();
-            if (reply === null)
-                return 130;
-            run = await call({
-                url,
-                token,
-                method: 'POST',
-                path: `/api/machines/runs/${run.id}/answer`,
-                body: { text: reply },
-                schema: MachineRunSchema,
-            });
-            printed = run.output.length;
-            continue;
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-        run = await readRun({ url, token, machineId: target.id, runId: run.id });
-    }
-}
-async function readRun({ url, token, machineId, runId, }) {
-    const answer = await call({
-        url,
-        token,
-        method: 'GET',
-        path: `/api/machines/${machineId}/runs`,
-        schema: MachineRunsResponseSchema,
-    });
-    const found = answer.runs.find((candidate) => candidate.id === runId);
-    if (found === undefined)
-        throw new Error(`Run ${runId} is gone.`);
-    return found;
-}
-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)
-        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(', ')}`);
-    }
-    process.stdout.write(`\nNo workstation called ${name}.\n\n`);
+async function pick(machines) {
     return select({
-        message: 'Run it on',
-        choices: answer.machines.map((candidate) => ({
-            name: `${candidate.name.padEnd(20)} ${candidate.state}`,
+        message: 'Which workstation?',
+        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,
         })),
+        pageSize: 12,
     });
 }
-function readStdinLine() {
+function specs({ platform, cores, memoryGb }) {
+    return [platform, cores === null ? null : `${cores} vCPU`, memoryGb === null ? null : `${memoryGb} GB`]
+        .filter((part) => part !== null)
+        .join(' \u00b7 ');
+}
+function beat({ lastBeatAt }) {
+    if (lastBeatAt === null)
+        return 'never beat';
+    const seconds = Math.max(0, Math.round((Date.now() - new Date(lastBeatAt).getTime()) / 1000));
+    if (seconds < 60)
+        return `beat ${seconds}s ago`;
+    if (seconds < 3600)
+        return `beat ${Math.round(seconds / 60)}m ago`;
+    return `beat ${Math.round(seconds / 3600)}h ago`;
+}
+async function openTerminal(target) {
+    if (target.sshAddress === null) {
+        throw new Error(`${target.name} has not told us an address yet. It reports one on its next beat.`);
+    }
+    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) => {
-        let buffer = '';
-        process.stdin.setEncoding('utf8');
-        const done = (line) => {
-            process.stdin.off('data', onData);
-            process.stdin.off('end', onEnd);
-            process.stdin.pause();
-            resolve(line.trim() === '' ? null : line.trim());
-        };
-        const onData = (chunk) => {
-            buffer += chunk;
-            const at = buffer.indexOf('\n');
-            if (at !== -1)
-                done(buffer.slice(0, at));
-        };
-        const onEnd = () => done(buffer);
-        process.stdin.on('data', onData);
-        process.stdin.on('end', onEnd);
-        process.stdin.resume();
+        const session = spawn('ssh', ['-t', where], { stdio: 'inherit' });
+        session.on('error', (error) => {
+            ui.say(ui.bad(`could not start ssh`, error.message));
+            resolve(1);
+        });
+        session.on('exit', (code) => resolve(code ?? 0));
     });
 }
+function nowhereToGo({ url }) {
+    ui.say(`\n${ui.attention('No workstations here yet.')}\n\n`);
+    ui.say(ui.field('Add one', ui.link(`${url}/workstations`)));
+    ui.say(ui.field('Or sign in', 'a Mac or Linux box with: cs login'));
+    ui.say('\n');
+    return 1;
+}
 async function tools() {
     if (probed !== null && Date.now() - probed.at < PROBE_EVERY_MS)
         return probed.tools;
@@ -314,7 +271,7 @@ async function withAuth(auth, work) {
             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');
+        ui.say(`\n${ui.note('Picking up where you left off.')}\n`);
         return { auth: next, value: await work(next) };
     }
 }
@@ -374,14 +331,6 @@ async function writeAuthorizedKeys(keys) {
 function trimEnd(text) {
     return text.replace(/\s+$/, '');
 }
-async function writeSession(session) {
-    const dir = path.join(machine.home(), 'sessions');
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    await writeFile(path.join(dir, `${session.id}.json`), JSON.stringify(session), { mode: 0o600 });
-}
-async function clearSession(id) {
-    await rm(path.join(machine.home(), 'sessions', `${id}.json`), { force: true });
-}
 async function writeAgentConfigs({ url, token, writes, }) {
     const planned = writes.length > 0 ? writes : defaultWrites({ url, token });
     const owned = [];
@@ -573,7 +522,7 @@ const MAX_REPORTED_SESSIONS = 50;
 const MAX_BACKOFF_MS = 120_000;
 const KEYS_BEGIN = '# craftspace begin';
 const KEYS_END = '# craftspace end';
-const POLL_INTERVAL_MS = 1_000;
+const UPDATE_EVERY_MS = 6 * 60 * 60 * 1_000;
 const BEATING = 'beating every 15s, outbound only, and keeps this set up';
 const LINGER_LINE = `sudo loginctl enable-linger ${os.userInfo().username}`;
 const DEFAULT_URL = process.env.CRAFTSPACE_URL ?? 'https://craftspace.app';

package/dist/setup.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { probe } from './probe.js';
+import { ui } from './ui.js';
 const run = promisify(execFile);
 export const setup = {
     widenPath() {
@@ -19,19 +20,23 @@ export const setup = {
         const broken = found.filter((tool) => !tool.ok && repairs[tool.id] !== undefined && isDue(tool.id));
         if (broken.length === 0)
             return withReasons(found);
-        for (const tool of broken) {
+        let ready = 0;
+        for (const [index, tool] of broken.entries()) {
             const repair = repairs[tool.id];
             if (repair === undefined)
                 continue;
-            say?.(`Setting up ${repair.name}`);
+            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);
-            say?.(failed === null ? `  ${repair.name} is ready` : `  could not set up ${repair.name}: ${failed}`);
+            if (failed === null)
+                ready += 1;
+            say?.(`${ui.clear()}${failed === null ? ui.ok(repair.name) : ui.bad(repair.name, failed)}`);
         }
+        say?.(ui.tally({ done: ready, total: broken.length, noun: 'ready' }));
         return withReasons(await probe.tools());
     },
 };

package/dist/ui.d.ts

@@ -0,0 +1,29 @@
+export declare const ui: {
+    say(text: string): void;
+    heading(text: string): string;
+    field(label: string, value: string): string;
+    ok(text: string): string;
+    bad(text: string, why?: string): string;
+    note(text: string): string;
+    waiting(text: string): string;
+    clear(): string;
+    progress({ name, done, total }: {
+        name: string;
+        done: number;
+        total: number;
+    }): string;
+    bar({ done, total }: {
+        done: number;
+        total: number;
+    }): string;
+    tally({ done, total, noun }: {
+        done: number;
+        total: number;
+        noun: string;
+    }): string;
+    name(text: string): string;
+    link(text: string): string;
+    command(text: string): string;
+    dim(text: string): string;
+    attention(text: string): string;
+};

package/dist/ui.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+export const ui = {
+    say(text) {
+        process.stdout.write(text);
+    },
+    heading(text) {
+        return `\n${chalk.bold(text)}\n`;
+    },
+    field(label, value) {
+        return `  ${chalk.dim(label.padEnd(LABEL_WIDTH))}${value}\n`;
+    },
+    ok(text) {
+        return `  ${chalk.green('✔')} ${text}\n`;
+    },
+    bad(text, why) {
+        return `  ${chalk.red('✖')} ${text}${why === undefined ? '' : chalk.dim(` · ${why}`)}\n`;
+    },
+    note(text) {
+        return `  ${chalk.dim(text)}\n`;
+    },
+    waiting(text) {
+        return fancy ? `\r\u001b[K  ${chalk.dim(`… ${text}`)}` : `  ${chalk.dim(`… ${text}`)}\n`;
+    },
+    clear() {
+        return fancy ? '\r\u001b[K' : '';
+    },
+    progress({ name, done, total }) {
+        if (!fancy)
+            return `  ${chalk.dim(`… ${name}`)}\n`;
+        return `\r\u001b[K  ${ui.bar({ done, total })} ${chalk.dim(`${name}…`)}`;
+    },
+    bar({ done, total }) {
+        const filled = Math.round((done / Math.max(total, 1)) * BAR_CELLS);
+        return `${chalk.green('█'.repeat(filled))}${chalk.dim('░'.repeat(BAR_CELLS - filled))}`;
+    },
+    tally({ done, total, noun }) {
+        return `  ${ui.bar({ done, total })} ${chalk.bold(`${done}/${total}`)} ${chalk.dim(noun)}\n`;
+    },
+    name(text) {
+        return chalk.cyan(text);
+    },
+    link(text) {
+        return chalk.underline(chalk.dim(text));
+    },
+    command(text) {
+        return chalk.yellow(text);
+    },
+    dim(text) {
+        return chalk.dim(text);
+    },
+    attention(text) {
+        return chalk.yellow(text);
+    },
+};
+const fancy = process.stdout.isTTY === true;
+const LABEL_WIDTH = 13;
+const BAR_CELLS = 10;

package/dist/update.d.ts

@@ -0,0 +1,5 @@
+export declare const update: {
+    latest(): Promise<string | null>;
+    toLatest(): Promise<string | null>;
+};
+export declare function isNewer(candidate: string, current?: string): boolean;

package/dist/update.js

@@ -0,0 +1,46 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { CLI_PACKAGE, CLI_VERSION } from '@craftspace/shared';
+const run = promisify(execFile);
+export const update = {
+    async latest() {
+        const answer = await fetch(`${REGISTRY}/${CLI_PACKAGE}/latest`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        }).catch(() => null);
+        if (answer === null || !answer.ok)
+            return null;
+        const body = await answer.json().catch(() => null);
+        const version = isRecord(body) ? body.version : undefined;
+        return typeof version === 'string' && isNewer(version) ? version : null;
+    },
+    async toLatest() {
+        const version = await update.latest();
+        if (version === null)
+            return null;
+        const installed = await run('npm', ['install', '--global', '--no-fund', `${CLI_PACKAGE}@${version}`], {
+            timeout: INSTALL_TIMEOUT_MS,
+        }).then(() => true, () => false);
+        return installed ? version : null;
+    },
+};
+export function isNewer(candidate, current = CLI_VERSION) {
+    const mine = parts(current);
+    const theirs = parts(candidate);
+    for (let at = 0; at < 3; at += 1) {
+        const here = mine[at] ?? 0;
+        const there = theirs[at] ?? 0;
+        if (there !== here)
+            return there > here;
+    }
+    return false;
+}
+function parts(version) {
+    return (/^\d+\.\d+\.\d+/.exec(version.trim())?.[0] ?? '').split('.').map(Number);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+const REGISTRY = 'https://registry.npmjs.org';
+const REQUEST_TIMEOUT_MS = 10_000;
+const INSTALL_TIMEOUT_MS = 180_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craftspace/cli",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "type": "module",
   "description": "Sign a Mac or Linux machine into Craftspace and keep its agent setup in step.",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "node": ">=20"
   },
   "bin": {
+    "cs": "dist/index.js",
     "craftspace": "dist/index.js"
   },
   "files": [
@@ -32,6 +33,7 @@
     "@craftspace/shared": "*",
     "@inquirer/prompts": "^8.7.2",
     "@types/node": "^22.0.0",
+    "chalk": "^5.6.0",
     "commander": "^14.0.0",
     "esbuild": "^0.28.0",
     "typescript": "^5.6.0"