directionallylocal 0.3.0 → 0.4.1

package/dist/laptop/setup.js

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
-import { readdir, readFile } from "node:fs/promises";
+import { access as fileAccess, readdir, readFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { TtyPrompter } from "../prompt.js";
 import { palette, PlainUi, TerminalUi } from "../ui.js";
@@ -40,34 +40,12 @@ export async function setupWizard(deps) {
     return setUpServer(deps);
 }
 async function setUpServer(deps) {
-    const c = palette(deps.color);
     const home = deps.sources.home;
     const sshDir = join(home, ".ssh");
     const hosts = parseSshConfig(await deps.sources.readFile(join(sshDir, "config")) ?? "", home);
     // 1. Which server, and can we get in?
-    let { access, display } = await chooseServer(deps, hosts);
-    let facts;
-    for (let attempt = 0; !facts; attempt++) {
-        const ui = deps.newUi();
-        ui.plan([{ id: "ssh", label: "Server" }]);
-        ui.start("ssh", display);
-        try {
-            facts = await checkServer(access, deps.ssh, display);
-        }
-        catch (error) {
-            ui.fail("ssh", error instanceof SshAuthError ? "SSH key not accepted" : "can't set up here");
-            ui.finish();
-            if (!(error instanceof SshAuthError) || attempt >= 2)
-                throw explainAuth(error, access);
-            access = { ...access, identityFile: await chooseKey(deps, sshDir, access) };
-            continue;
-        }
-        display = `${facts.user}@${display.replace(/^[^@]*@/, "")}`;
-        ui.done("ssh", `${display}  ${facts.os} · ${facts.arch}`);
-        ui.finish();
-        if (facts.newHostKey)
-            deps.newUi().line("info", "New server", "first connection: trusted its host key (accept-new)");
-    }
+    const chosen = await chooseServer(deps, hosts);
+    const { access, facts } = await reachServer(deps, sshDir, deps.identityFile ? { ...chosen.access, identityFile: deps.identityFile } : chosen.access, chosen.display);
     // 2. Install dl there, then ask only for the keys it still lacks.
     await bootstrap(access, facts, deps.ssh, deps.newUi(), deps.installUrl);
     const needs = await serverNeeds(access, facts, deps.ssh);
@@ -90,7 +68,7 @@ async function setUpServer(deps) {
     if (!remote) {
         const pairing = await pairLaptop(access, facts, deps.ssh, `${laptopName(deps.hostname)} (dl)`);
         remote = {
-            name: saved?.name ?? await remoteName(access, remotesFile),
+            name: saved?.name ?? await remoteName(access, remotesFile, chosen.alias ?? facts.hostname),
             url: normalizeServerUrl(pairing.url),
             token: pairing.token,
             credentialId: pairing.credentialId,
@@ -135,6 +113,7 @@ async function chooseServer(deps, hosts) {
         if (host) {
             ui.answered("SSH", host.alias);
             return {
+                alias: host.alias,
                 access: { target: host.alias },
                 display: `${host.user ? `${host.user}@` : ""}${host.hostName ?? host.alias}${host.port && host.port !== 22 ? `:${host.port}` : ""}`,
             };
@@ -155,30 +134,85 @@ async function chooseServer(deps, hosts) {
         }
     }
 }
-/** The server refused the default keys: offer the ones in ~/.ssh and retry with -i. */
-async function chooseKey(deps, sshDir, access) {
-    const c = palette(deps.color);
-    const keys = discoverKeys(sshDir, await deps.sources.listDir(sshDir)).filter((key) => key !== access.identityFile);
-    if (keys.length === 0)
-        throw explainAuth(new SshAuthError(access, "no other keys in ~/.ssh"), access);
-    deps.write(`\n  ${c.dim("Which key does this server accept?")}\n`);
-    keys.forEach((key, index) => deps.write(`  ${c.cyan(String(index + 1))}  ${key.replace(deps.sources.home, "~")}\n`));
-    deps.write("\n");
+/**
+ * Connects and checks the server. If it refuses the default keys (ssh's own: the agent and
+ * ~/.ssh/id_*), each key pair in ~/.ssh is tried in turn with -i, without asking: auth
+ * refusals come back fast, so this takes seconds. Only when none works does it stop, with
+ * what to do. A key named with --identity is the only one tried.
+ */
+async function reachServer(deps, sshDir, first, target) {
+    const home = deps.sources.home;
     const ui = deps.newUi();
-    const answer = (await deps.prompter.text(ui.prompt("SSH key", `1-${keys.length}`))).trim();
-    const key = keys[(Number(answer) || 1) - 1] ?? keys[0];
-    ui.answered("SSH key", key.replace(deps.sources.home, "~"));
-    return key;
+    ui.plan([{ id: "ssh", label: "Server" }]);
+    ui.start("ssh", target);
+    const tried = [];
+    let searching = false;
+    let newHostKey = false;
+    const attempt = async (access) => {
+        try {
+            return await checkServer(access, deps.ssh, target);
+        }
+        catch (error) {
+            if (error instanceof SshAuthError) {
+                newHostKey ||= error.newHostKey;
+                if (access.identityFile)
+                    tried.push(access.identityFile);
+                return undefined;
+            }
+            if (searching)
+                ui.plan([{ id: "ssh", label: "Server" }]);
+            ui.fail("ssh", "can't set up here");
+            ui.finish();
+            throw error;
+        }
+    };
+    let access = first;
+    let facts = await attempt(access);
+    if (!facts && !first.identityFile) {
+        const keys = discoverKeys(sshDir, await deps.sources.listDir(sshDir));
+        searching = keys.length > 0;
+        if (searching)
+            ui.plan([{ id: "keys", label: "Trying your SSH keys…" }]);
+        for (const key of keys) {
+            access = { ...first, identityFile: key };
+            ui.start("keys", tilde(key, home));
+            facts = await attempt(access);
+            if (facts)
+                break;
+        }
+    }
+    if (searching)
+        ui.plan([{ id: "ssh", label: "Server" }]);
+    if (!facts) {
+        ui.fail("ssh", first.identityFile ? `${tilde(first.identityFile, home)} not accepted` : tried.length > 0 ? "none of your SSH keys was accepted" : "SSH key not accepted");
+        ui.finish();
+        throw noKeyWorks(first, tried, discoverKeys(sshDir, await deps.sources.listDir(sshDir)), home);
+    }
+    const display = `${facts.user}@${target.replace(/^[^@]*@/, "")}`;
+    ui.done("ssh", access.identityFile ? `${display} with ${tilde(access.identityFile, home)} · ${facts.os} · ${facts.arch}` : `${display}  ${facts.os} · ${facts.arch}`);
+    ui.finish();
+    if (facts.newHostKey || newHostKey)
+        deps.newUi().line("info", "New server", "first connection: trusted its host key (accept-new)");
+    return { access, facts };
 }
-function explainAuth(error, access) {
-    if (!(error instanceof SshAuthError))
-        return error instanceof Error ? error : new Error(String(error));
-    return new Error([
-        error.message,
-        "  Add this computer's public key to the server (it asks for the password once):",
-        `     ssh-copy-id ${access.port ? `-p ${access.port} ` : ""}${access.target}`,
+/** Every key was refused: what to do next, with this server and this laptop's own key filled in. */
+function noKeyWorks(access, tried, keys, home) {
+    const port = access.port ? `-p ${access.port} ` : "";
+    const key = keys[0] ? tilde(keys[0], home) : undefined;
+    const lines = [
+        access.identityFile
+            ? `${access.target} didn't accept ${tilde(access.identityFile, home)}.`
+            : `${access.target} didn't accept this computer's SSH keys (${["the default ones", ...tried.map((file) => tilde(file, home))].join(", ")}).`,
+        "  Add your public key to the server (it asks for the password once):",
+        ...(key ? [] : ["     ssh-keygen -t ed25519"]),
+        `     ssh-copy-id -i ${key ?? "~/.ssh/id_ed25519"}.pub ${port}${access.target}`,
         "  If your key has a passphrase, load it first with: ssh-add",
-    ].join("\n"));
+        "  Or name the key this server takes: dl setup --identity ~/.ssh/KEY",
+    ];
+    return new Error(lines.join("\n"));
+}
+function tilde(path, home) {
+    return path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
 }
 function sameServer(remote, access) {
     return remote.ssh?.target === access.target && remote.ssh.port === access.port;
@@ -189,12 +223,14 @@ async function stillWorks(remote, open) {
         return true;
     }).catch(() => false);
 }
-/** box (from an ssh alias) or 203-0-113-10, unique unless it's this same server again. */
-async function remoteName(access, remotesFile) {
+/**
+ * What this laptop calls the server: the ~/.ssh/config alias the user picked, else the
+ * server's own hostname, else its address (203-0-113-10). Unique unless it's this same server.
+ */
+async function remoteName(access, remotesFile, preferred) {
     const host = hostOf(access.target).toLowerCase();
-    const label = /^\d+(\.\d+){3}$/.test(host) || host.includes(":") ? host.replace(/[.:]/g, "-") : host.split(".")[0] ?? "server";
-    const base = label.replace(/[^a-z0-9-]/g, "-").replace(/^-+/, "").slice(0, 36) || "server";
-    const name = REMOTE_NAME_RE.test(base) ? base : "server";
+    const fromAddress = /^\d+(\.\d+){3}$/.test(host) || host.includes(":") ? host.replace(/[.:]/g, "-") : host.split(".")[0] ?? "";
+    const name = [preferred, fromAddress].map((label) => serverLabel(label ?? "")).find((label) => label !== undefined) ?? "server";
     const remotes = await loadRemotes(remotesFile);
     for (let n = 1;; n++) {
         const candidate = n === 1 ? name : `${name}-${n}`;
@@ -203,6 +239,11 @@ async function remoteName(access, remotesFile) {
             return candidate;
     }
 }
+/** A hostname as a server name (lowercase, dashes, room for a -2), or undefined if nothing usable is left. */
+export function serverLabel(text) {
+    const label = text.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 36).replace(/-+$/, "");
+    return REMOTE_NAME_RE.test(label) && label !== "localhost" ? label : undefined;
+}
 function finishScreen(ui, capacity) {
     ui.ready(capacity ? `Ready · fits ~${capacity} agents at once (estimate)` : "Ready", [
         { label: "From any GitHub repository", value: RUN_EXAMPLE },
@@ -230,6 +271,12 @@ export async function setup(options) {
     const color = io.color === true;
     const execFileAsync = promisify(execFile);
     const home = homedir();
+    let identityFile;
+    if (options.identityFile !== undefined) {
+        // The private key, even when the .pub next to it was named.
+        identityFile = resolve(options.identityFile.replace(/^~(?=$|\/)/, home).replace(/\.pub$/, ""));
+        await fileAccess(identityFile).catch(() => { throw new Error(`No SSH key at ${options.identityFile} (--identity takes the private key, e.g. ~/.ssh/id_ed25519)`); });
+    }
     await setupWizard({
         newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
         prompter: new TtyPrompter(),
@@ -248,6 +295,7 @@ export async function setup(options) {
         hostname: hostname(),
         installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
         ...(options.localSetup ? { localSetup: options.localSetup } : {}),
+        ...(identityFile ? { identityFile } : {}),
     });
     return 0;
 }

package/dist/laptop/ssh.js

@@ -139,19 +139,23 @@ export function lines(collect, onLine) {
             onLine(part.replace(/\r$/, ""));
     };
 }
-/** The server refused our keys; the wizard offers others from ~/.ssh. */
+/** The server refused our keys; the wizard tries the others in ~/.ssh. */
 export class SshAuthError extends Error {
     access;
-    constructor(access, detail) {
+    newHostKey;
+    constructor(access, detail, newHostKey = false) {
         super(`The server didn't accept this computer's SSH key (${detail}).`);
         this.access = access;
+        this.newHostKey = newHostKey;
         this.name = "SshAuthError";
     }
 }
 const SUPPORTED_OS = new Set(["ubuntu 22.04", "ubuntu 24.04", "debian 12"]);
-// One round trip: who we are, the OS, the CPU, and whether we can become root without a password.
+// One round trip: who we are, the OS, the CPU, whether we can become root without a password,
+// and the server's own name (what the laptop calls it unless ~/.ssh/config already names it).
 const PROBE = 'id -u; id -un; . /etc/os-release; echo "$ID $VERSION_ID"; uname -m; ' +
-    'if [ "$(id -u)" = 0 ]; then echo root; elif sudo -n true 2>/dev/null; then echo sudo; else echo nosudo; fi';
+    'if [ "$(id -u)" = 0 ]; then echo root; elif sudo -n true 2>/dev/null; then echo sudo; else echo nosudo; fi; ' +
+    'hostname -s 2>/dev/null || cat /etc/hostname 2>/dev/null';
 /** Connects once and checks the server can take an install: a supported OS, and root or passwordless sudo. */
 export async function checkServer(access, ssh, display) {
     const result = await ssh(access, PROBE);
@@ -159,14 +163,14 @@ export async function checkServer(access, ssh, display) {
     if (result.code === 255 || result.stdout.trim() === "") {
         const detail = lastLine(result.stderr) || `ssh exited with ${result.code}`;
         if (/Permission denied|Too many authentication failures|no mutual signature|Authentication failed/i.test(result.stderr)) {
-            throw new SshAuthError(access, detail);
+            throw new SshAuthError(access, detail, newHostKey);
         }
         if (/Host key verification failed|REMOTE HOST IDENTIFICATION HAS CHANGED/i.test(result.stderr)) {
             throw new Error(`${display}'s SSH host key changed since this computer last connected, so it stopped (that can mean someone is in the middle). If you rebuilt the server, remove the old key with: ssh-keygen -R ${hostOf(access.target)}`);
         }
         throw new Error(`Couldn't reach ${display} over SSH: ${detail}\n  Check that this works: ${sshCommandLine(access)}`);
     }
-    const [uid, user, osLine, arch, privilege] = result.stdout.trim().split("\n").map((line) => line.trim());
+    const [uid, user, osLine, arch, privilege, name] = result.stdout.trim().split("\n").map((line) => line.trim());
     const os = formatOs(osLine ?? "");
     const facts = {
         user: user || "?",
@@ -175,6 +179,7 @@ export async function checkServer(access, ssh, display) {
         os,
         arch: arch === "aarch64" ? "arm64" : arch || "?",
         newHostKey,
+        ...(name ? { hostname: name } : {}),
     };
     if (!facts.root && !facts.sudo) {
         throw new Error([

package/dist/layout.js

@@ -8,6 +8,8 @@ export const PATHS = {
     hotcellEnv: "/etc/hotcell/hotcell.env",
     hotcellEtc: "/etc/hotcell",
     hotcellHome: "/var/lib/hotcell",
+    /** OpenRouter's prices, so Hotcell's spend-capped gateway forwards current models. */
+    modelPrices: "/var/lib/hotcell/model-prices.json",
     autopilotEtc: "/etc/autopilot",
     autopilotEnv: "/etc/autopilot/autopilot.env",
     githubEnv: "/etc/autopilot/github.env",
@@ -70,6 +72,8 @@ export function hotcellEnv(input) {
         HOTCELL_EGRESS_HOST: input.bridgeIp,
         HOTCELL_EGRESS_PORT: String(HOTCELL_EGRESS_PORT),
         HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+        // Under a spend cap the gateway refuses models it can't price; `dl up` refreshes this list.
+        HOTCELL_MODEL_PRICES: PATHS.modelPrices,
     });
 }
 export function autopilotEnv(input) {

package/dist/local/cli.js

@@ -28,12 +28,15 @@ export function formatLocalStatus(status, c, home) {
     const mark = (ok) => (ok ? c.green("✓") : c.red("✗"));
     const line = (ok, label, detail) => `  ${mark(ok)} ${label.padEnd(12)}${c.dim(detail)}\n`;
     const describe = (entry) => entry.running ? `running${entry.pid ? ` (pid ${entry.pid})` : ""}` : entry.installed ? "stopped" : "not installed";
-    const healthy = services.hotcell.running && services.autopilot.running && status.answering && status.dockerRunning;
+    const healthy = services.hotcell.running && services.autopilot.running && status.answering && status.dockerRunning && status.modelPrices.ok;
     return [
         `\n  ${c.bold("Directionally Local")}  ${c.dim("on this computer")}  ${healthy ? c.green("running") : c.red("needs attention")}\n\n`,
         line(status.dockerRunning, "Docker", status.dockerRunning ? state.dockerRuntime : `${state.dockerRuntime} isn't running; start it`),
         line(services.hotcell.running, "Hotcell", `${describe(services.hotcell)} · 127.0.0.1:${state.ports.hotcell} · ${state.hotcellVersion}`),
         line(services.autopilot.running && status.answering, "Autopilot", `${describe(services.autopilot)}${status.answering ? "" : ", not answering"} · ${state.url} · ${state.autopilotVersion}`),
+        status.modelPrices.warn
+            ? `  ${c.yellow("!")} ${"Prices".padEnd(12)}${c.dim(status.modelPrices.detail)}\n`
+            : line(status.modelPrices.ok, "Prices", status.modelPrices.detail),
         `\n  ${c.dim("Fits")}        ${status.capacity !== undefined ? `~${status.capacity} agents at once (estimate, from Docker's memory)` : "unknown while Docker is stopped"}\n`,
         `  ${c.dim("Installed")}   ${short(status.paths.current)}\n`,
         `  ${c.dim("Logs")}        ${short(status.paths.logs)}\n`,

package/dist/local/keys.js

@@ -0,0 +1,100 @@
+/**
+ * `dl keys` for "on this computer": the same as on a server, in the user's home. The
+ * OpenRouter key goes to Hotcell's 0600 file keystore over stdin (HOTCELL_KEYSTORE=file,
+ * see setup.ts for why not the Keychain), the GitHub token to the 0600 github.env, and
+ * the service that reads it (a LaunchAgent or a systemd user unit) restarts.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { checkKey, githubListing, hotcellKeyListed, KeyRejectedError } from "../keys.js";
+import { RealSystem } from "../system.js";
+import { supportedPlatform } from "./check.js";
+import { LOCAL_SERVICES, localGithubEnv, localHotcellBin, localPaths, parseLocalEnvFile, serviceFile } from "./layout.js";
+import { httpStatus } from "./probes.js";
+import { userId } from "./services.js";
+import { hotcellCliEnv } from "./setup.js";
+import { readLocalState } from "./state.js";
+async function installed(options) {
+    const home = options.home ?? homedir();
+    const platform = supportedPlatform(options.platform ?? process.platform);
+    if (!platform)
+        throw new Error("Agents run on this computer only on macOS and Linux.");
+    const system = options.system ?? new RealSystem(() => { });
+    const paths = localPaths(home, platform);
+    const state = await readLocalState(system, paths);
+    if (!state)
+        throw new Error("Directionally Local isn't set up on this computer; run dl setup.");
+    return {
+        system,
+        home,
+        platform,
+        paths,
+        state,
+        node: options.execPath ?? process.execPath,
+        sleep: options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+    };
+}
+/** Stores the key where setup does, restarts the service that reads it, and waits for it to answer. */
+export async function setLocalKey(which, value, options = {}) {
+    const key = value.trim();
+    const checked = await checkKey(which, key, options.fetchImpl);
+    if (checked.problem)
+        throw new KeyRejectedError(checked.problem);
+    const ctx = await installed(options);
+    const { system, paths, state, node } = ctx;
+    const uid = await userId(system);
+    if (which === "openrouter") {
+        await system.run(node, [localHotcellBin(paths), "keys", "add", "openrouter", "--stdin"], {
+            input: key,
+            env: hotcellCliEnv(paths),
+            describe: "hotcell keys add openrouter --stdin",
+        });
+        await restartService(ctx, uid, "hotcell");
+        await waitUntil(ctx, "Hotcell", async () => await httpStatus(system, node, `http://127.0.0.1:${state.ports.hotcell}/`) > 0);
+        return { ok: true, key: which, detail: "replaced in Hotcell; Hotcell restarted" };
+    }
+    await system.writeFile(paths.githubEnv, localGithubEnv(key), { mode: 0o600, secret: true });
+    await restartService(ctx, uid, "autopilot");
+    // Without a token the Aster API answers 401: up, and refusing strangers.
+    await waitUntil(ctx, "Autopilot", async () => await httpStatus(system, node, `${state.url}/api/v1/health`) === 401);
+    return { ok: true, key: which, detail: `${checked.detail ? `${checked.detail}; ` : ""}Autopilot restarted` };
+}
+/** Which keys this computer's install has; never their values. */
+export async function listLocalKeys(options = {}) {
+    const { system, paths, node } = await installed(options);
+    let openrouter = { key: "openrouter", set: false };
+    if (await system.exists(localHotcellBin(paths))) {
+        const listed = await system.probe(node, [localHotcellBin(paths), "keys", "ls"], { env: { ...hotcellCliEnv(paths), NO_COLOR: "1" } });
+        if (listed.code === 0)
+            openrouter = { key: "openrouter", ...hotcellKeyListed(listed.stdout, "openrouter") };
+    }
+    const token = parseLocalEnvFile(await system.readFile(paths.githubEnv)).GITHUB_TOKEN;
+    return [openrouter, await githubListing(token, options.fetchImpl)];
+}
+/**
+ * Restarts one service so it reads its keys again: `launchctl kickstart -k` on macOS (or
+ * bootstrap, when it isn't loaded), `systemctl --user restart` on Linux.
+ */
+async function restartService(ctx, uid, service) {
+    const { system, platform, paths } = ctx;
+    if (platform === "darwin") {
+        const restarted = await system.run("launchctl", ["kickstart", "-k", `gui/${uid}/${LOCAL_SERVICES[service].label}`], { allowFailure: true });
+        if (restarted.code === 0)
+            return;
+        const file = serviceFile(paths, platform, service);
+        if (!(await system.exists(file)))
+            throw new Error(`The ${service} service isn't installed on this computer; run dl setup to repair it.`);
+        await system.run("launchctl", ["bootstrap", `gui/${uid}`, file]);
+        return;
+    }
+    await system.run("systemctl", ["--user", "restart", LOCAL_SERVICES[service].unit]);
+}
+async function waitUntil(ctx, what, ready) {
+    for (let attempt = 0; attempt < 60; attempt++) {
+        if (await ready())
+            return;
+        await ctx.sleep(1_000);
+    }
+    const log = join(ctx.paths.logs, LOCAL_SERVICES[what === "Hotcell" ? "hotcell" : "autopilot"].log);
+    throw new Error(`${what} didn't come back up; see ${log.startsWith(`${ctx.home}/`) ? `~${log.slice(ctx.home.length)}` : log}`);
+}

package/dist/local/layout.js

@@ -21,6 +21,7 @@ export function localPaths(home, platform) {
         githubEnv: join(config, "github.env"),
         asterConfig: join(config, "aster.json"),
         hotcellHome: join(root, "hotcell"),
+        modelPrices: join(root, "hotcell", "model-prices.json"),
         autopilotHome,
         workspace: join(autopilotHome, "workspaces", "default"),
         services: platform === "darwin" ? join(home, "Library", "LaunchAgents") : join(home, ".config", "systemd", "user"),
@@ -89,6 +90,8 @@ export function localHotcellEnv(input) {
         HOTCELL_EGRESS_HOST: input.net.listenHost,
         HOTCELL_EGRESS_PORT: String(ports.hotcellEgress),
         HOTCELL_EGRESS_ADVERTISE_HOST: "host.docker.internal",
+        // Under a spend cap the gateway refuses models it can't price; setup refreshes this list.
+        HOTCELL_MODEL_PRICES: paths.modelPrices,
     });
 }
 export function localAutopilotEnv(input) {

package/dist/local/setup.js

@@ -28,6 +28,7 @@ import { removeRemote } from "../laptop/config.js";
 import { RealSystem } from "../system.js";
 import { checkComputer, computerProblems, localCapacity, servicePath, supportedPlatform } from "./check.js";
 import { LOCAL_SERVICES, PAIRED_NAME, PREFERRED_PORTS, autopilotXdg, localAsterConfig, localAutopilotBin, localAutopilotEnv, localGithubEnv, localHotcellBin, localHotcellEnv, localPaths, parseLocalEnvFile, serviceSpecs, } from "./layout.js";
+import { fileMtime, modelPricesHealth, refreshModelPrices } from "../model-prices.js";
 import { httpStatus, portFree } from "./probes.js";
 import { installService, removeServices, serviceState, stopService, userId } from "./services.js";
 import { readLocalState, writeLocalState } from "./state.js";
@@ -153,6 +154,14 @@ export async function setUpOnThisComputer(input) {
         const previousAutopilot = parseLocalEnvFile(await system.readFile(paths.autopilotEnv));
         const ports = await choosePorts(ctx, node, net, previousPorts(previous, previousAutopilot));
         const apiKey = previous.HOTCELL_API_KEY || randomBytes(24).toString("hex");
+        // Hotcell reads it once at start, so it's in place before the service starts below.
+        const prices = await refreshModelPrices(system, {
+            path: paths.modelPrices,
+            write: { mode: 0o644 },
+            fetchImpl: input.fetchImpl ?? fetch,
+            warn: (text) => ui.warn(text),
+            retry: "dl setup",
+        });
         await system.writeFile(paths.hotcellEnv, localHotcellEnv({ paths, apiKey, ports, net }), { mode: 0o600, secret: true });
         if (!(await system.readFile(paths.asterConfig)))
             await system.writeFile(paths.asterConfig, localAsterConfig(paths), { mode: 0o600 });
@@ -168,7 +177,7 @@ export async function setUpOnThisComputer(input) {
         // Without a token the Aster API answers 401: up, and refusing strangers.
         await waitUntil(ctx, "Autopilot", join(paths.logs, LOCAL_SERVICES.autopilot.log), async () => await httpStatus(system, node, `http://127.0.0.1:${ports.autopilot}/api/v1/health`) === 401);
         await pruneReleases(system, paths, release);
-        return { value: ports, detail: `start at login · logs in ${tilde(paths.logs, ctx.home)}` };
+        return { value: ports, detail: `start at login · logs in ${tilde(paths.logs, ctx.home)}${prices ? ` · ${prices}` : ""}` };
     });
     const url = `http://127.0.0.1:${ports.autopilot}`;
     return await step("connect", async () => {
@@ -296,7 +305,8 @@ export async function localStatus(options = {}) {
             capacity = localCapacity({ memoryMb: Math.round(Number(mem) / 1024 / 1024), cpus: Number(cpus) || 0 });
         }
     }
-    return { installed: Boolean(state), state, services: { hotcell, autopilot }, answering, capacity, dockerRunning, paths, platform: ctx.rawPlatform };
+    const modelPrices = modelPricesHealth(await system.readFile(paths.modelPrices), await fileMtime(system, paths.modelPrices, platform), (options.now ?? (() => new Date()))(), "dl setup");
+    return { installed: Boolean(state), state, services: { hotcell, autopilot }, answering, capacity, dockerRunning, modelPrices, paths, platform: ctx.rawPlatform };
 }
 function checkOptions(ctx, options) {
     return {
@@ -320,7 +330,7 @@ async function openDockerApp(ctx, facts, options) {
     }
     return facts;
 }
-function hotcellCliEnv(paths) {
+export function hotcellCliEnv(paths) {
     return { HOME: paths.hotcellHome, HOTCELL_HOME: paths.hotcellHome, HOTCELL_KEYSTORE: "file" };
 }
 async function hotcellHasKey(system, node, paths, provider) {

package/dist/local/test-support/fake-computer.js

@@ -9,6 +9,8 @@ export class FakeComputer {
     home;
     dryRun = false;
     files = new Map();
+    /** Modification times (seconds) for `stat`; set on every write. */
+    mtimes = new Map();
     dirs = new Map();
     commands = [];
     probes = [];
@@ -17,6 +19,8 @@ export class FakeComputer {
     containers = [];
     /** launchd labels or systemd units that are running. */
     running = new Set();
+    /** Services restarted in place (launchctl kickstart -k, systemctl --user restart), in order. */
+    restarted = [];
     /** Ports something else on this computer listens on. */
     busy = new Set();
     credentials = [];
@@ -60,6 +64,7 @@ export class FakeComputer {
     }
     async writeFile(path, content, options = {}) {
         this.files.set(path, { content, mode: options.mode ?? 0o644 });
+        this.mtimes.set(path, Math.floor(Date.now() / 1000));
     }
     async mkdir(path, options = {}) {
         this.dirs.set(path, options.mode);
@@ -128,8 +133,13 @@ export class FakeComputer {
                 this.files.set(`${home}/keys.json`, { content: "{}", mode: 0o600 });
                 return ok("stored\n");
             }
-            if (args[1] === "keys" && args[2] === "ls")
-                return !this.files.has(`${options.env?.HOTCELL_HOME ?? ""}/keys.json`) ? ok("") : ok([...this.hotcellKeys.keys()].map((key) => `  ${key}  file\n`).join(""));
+            if (args[1] === "keys" && args[2] === "ls") {
+                if (!this.files.has(`${options.env?.HOTCELL_HOME ?? ""}/keys.json`))
+                    return ok("");
+                // Like Hotcell's own listing: a header, then each provider with its masked value.
+                const mask = (value) => value.length <= 8 ? "•".repeat(Math.max(4, value.length)) : `${value.slice(0, 5)}…${value.slice(-2)}`;
+                return ok(`PROVIDER  KEY           SOURCE\n${[...this.hotcellKeys].map(([key, value]) => `${key.padEnd(8)}  ${mask(value).padEnd(12)}  file\n`).join("")}`);
+            }
             return ok();
         }
         if (command.endsWith("/node") && args[0]?.endsWith("autopilot-ai/bin/autopilot.mjs")) {
@@ -172,8 +182,10 @@ export class FakeComputer {
             case "systemctl":
                 if (args[1] === "is-system-running")
                     return this.systemdUser ? ok("running\n") : fail("Failed to connect to bus");
-                if (args[1] === "restart")
+                if (args[1] === "restart") {
                     this.running.add(args[2]);
+                    this.restarted.push(args[2]);
+                }
                 if (args[1] === "disable" && args[2] === "--now")
                     this.running.delete(args[3]);
                 if (args[1] === "is-active")
@@ -192,6 +204,14 @@ export class FakeComputer {
                     const label = args[1].split("/").at(-1);
                     return this.running.delete(label) ? ok() : fail("Boot-out failed: 3: No such process");
                 }
+                if (args[0] === "kickstart") {
+                    // -k restarts a loaded service; one that isn't loaded can't be kickstarted.
+                    const label = args.at(-1).split("/").at(-1);
+                    if (!this.running.has(label))
+                        return fail("Could not find service");
+                    this.restarted.push(label);
+                    return ok();
+                }
                 if (args[0] === "print") {
                     const label = args[1].split("/").at(-1);
                     return this.running.has(label) ? ok(`${args[1]} = {\n\tstate = running\n\tpid = 4242\n}\n`) : fail("Could not find service");
@@ -220,6 +240,10 @@ export class FakeComputer {
             case "ls":
                 return ok([...this.dirs.keys()].filter((dir) => dir.startsWith(`${args[1]}/`) && !dir.slice(args[1].length + 1).includes("/")).map((dir) => dir.split("/").at(-1)).join("\n"));
             case "mktemp": return ok("/tmp/tmp.build\n");
+            case "stat": {
+                const mtime = this.files.has(args.at(-1)) ? this.mtimes.get(args.at(-1)) : undefined;
+                return mtime === undefined ? fail("No such file or directory") : ok(`${mtime}\n`);
+            }
             case "wc": return ok("0\n");
             case "/usr/local/bin/docker": {
                 if (args[0] === "context")