directionallylocal 0.4.1 → 0.6.0

package/dist/laptop/settings.js

@@ -0,0 +1,193 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fetchModelPrices } from "../model-prices.js";
+import { PromptCancelled, TtyPrompter } from "../prompt.js";
+import { palette, PlainUi, TerminalUi } from "../ui.js";
+import { autopilotConfigPath } from "./credentials.js";
+/**
+ * dl's own settings on this laptop (~/.config/directionallylocal/config.json). Today only
+ * the model tasks and sessions use when none is named with -m. It's dl's, so people who
+ * never installed Autopilot can set it; Autopilot's own default is still honoured when
+ * dl has none.
+ */
+/** What tasks and sessions use when neither -m, dl model nor Autopilot names a model. */
+export const DEFAULT_MODEL = "deepseek/deepseek-v4.1-flash-1017";
+/** The suggestions setup and `dl model` offer first; any OpenRouter ID works too. */
+export const SUGGESTED_MODELS = [
+    { id: "deepseek/deepseek-v4.1-flash-1017", note: "fast and cheap" },
+    { id: "moonshotai/kimi-k2.6", note: "strong at agentic coding" },
+    { id: "anthropic/claude-sonnet-5.5", note: "stronger, pricier" },
+    { id: "openai/gpt-6.1-sol", note: "stronger, pricier" },
+];
+export const OPENROUTER_ID_EXAMPLE = "provider/model, e.g. z-ai/glm-5";
+export function settingsPath(env = process.env) {
+    const configHome = env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(configHome, "directionallylocal", "config.json");
+}
+export async function loadSettings(path = settingsPath()) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.model === "string" && parsed.model.trim() ? { model: parsed.model.trim() } : {};
+    }
+    catch {
+        // A damaged file only loses the saved model; the next save rewrites it.
+        return {};
+    }
+}
+export async function saveModel(model, path = settingsPath()) {
+    const settings = { ...(await loadSettings(path)), model };
+    await mkdir(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify({ version: 1, ...settings }, null, 2)}\n`, { mode: 0o600 });
+    await rename(temp, path);
+}
+/** The model to use when none is named: dl's setting, else Autopilot's default, with where it came from. */
+export async function preferredModel(autopilotModel, path) {
+    const { model } = await loadSettings(path);
+    if (model)
+        return { model, source: "dl" };
+    const fromAutopilot = await autopilotModel();
+    return fromAutopilot ? { model: fromAutopilot, source: "autopilot" } : undefined;
+}
+/** This laptop's default model: the one set with `dl model`, else Autopilot's. */
+export async function laptopModel() {
+    return (await preferredModel(() => readAutopilotModel()))?.model;
+}
+/**
+ * The laptop's Autopilot default model: KIMI_MODEL (Autopilot's own override) or the
+ * `model` in its config. undefined when neither is set or the config can't be read.
+ */
+export async function readAutopilotModel(sources = {}) {
+    const env = sources.env ?? process.env;
+    const fromEnv = env.KIMI_MODEL?.trim();
+    if (fromEnv)
+        return fromEnv;
+    const read = sources.readFile ?? ((path) => readFile(path, "utf8").catch(() => undefined));
+    const raw = await read(autopilotConfigPath(env, sources.home ?? homedir()));
+    if (!raw)
+        return undefined;
+    try {
+        const model = JSON.parse(raw).model;
+        return typeof model === "string" && model.trim() ? model.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** OpenRouter's prices, or undefined when they can't be fetched: the list then just has no prices. */
+export async function modelPrices(fetchImpl = fetch) {
+    return fetchModelPrices(fetchImpl).then(({ table }) => table, () => undefined);
+}
+/**
+ * The picker's options: the suggestions (with prices when known, and the current model
+ * added if it isn't one), then "Another model", which takes a typed ID.
+ */
+export function modelOptions(current, prices, anotherPrompt) {
+    const known = prices ? SUGGESTED_MODELS.filter((entry) => entry.id.toLowerCase() in prices) : SUGGESTED_MODELS;
+    const entries = current && !known.some((entry) => entry.id === current) ? [{ id: current, note: "your current model" }, ...known] : known;
+    return [
+        ...entries.map((entry) => ({ value: entry.id, label: entry.id, detail: [entry.note, priceLabel(prices?.[entry.id.toLowerCase()])].filter(Boolean).join(" · ") })),
+        { value: "another", label: "Another model", detail: "any OpenRouter model ID", input: { prompt: anotherPrompt, placeholder: OPENROUTER_ID_EXAMPLE } },
+    ];
+}
+function priceLabel(price) {
+    if (!price)
+        return "";
+    if (price.inputPerMTok === 0 && price.outputPerMTok === 0)
+        return "free";
+    return `$${price.inputPerMTok} in / $${price.outputPerMTok} out per M tokens`;
+}
+/** A typed model ID, or why it isn't one. Checked against OpenRouter's catalog when it's known. */
+export function checkModelId(text, prices) {
+    const model = text.trim();
+    if (!/^[a-z0-9][\w.-]*\/[\w.:-]+$/i.test(model))
+        return { ok: false, message: `"${model}" isn't an OpenRouter model ID (${OPENROUTER_ID_EXAMPLE})` };
+    if (prices && !(model.toLowerCase() in prices))
+        return { ok: false, message: `OpenRouter has no model ${model} (see https://openrouter.ai/models)` };
+    return { ok: true, model };
+}
+/** The arrow-key list of models, with `current` preselected; a typed ID gets 3 tries. */
+export async function askModel(prompter, ui, current, prices) {
+    const options = modelOptions(current, prices, ui.prompt("Model ID", OPENROUTER_ID_EXAMPLE));
+    const initial = Math.max(0, options.findIndex((option) => option.value === current));
+    for (let attempt = 1;; attempt++) {
+        const picked = await prompter.select(ui.prompt("Model", "used for tasks and sessions"), options, initial);
+        if (picked.value !== "another")
+            return picked.value;
+        const checked = checkModelId(picked.text ?? "", prices);
+        if (checked.ok)
+            return checked.model;
+        if (attempt >= 3)
+            throw new Error(checked.message);
+        ui.rejected(`${checked.message}. Try again.`);
+    }
+}
+/**
+ * `dl model [ID]`: the model `dl run` and new sessions use when -m doesn't name one. With an
+ * ID, sets it; without, picks from a list on a terminal, or says which it is otherwise.
+ */
+export async function modelCommand(args, deps) {
+    const c = palette(deps.color);
+    const current = await preferredModel(deps.autopilotModel, deps.settingsFile);
+    const model = current?.model ?? DEFAULT_MODEL;
+    const from = current?.source === "dl" ? "set with dl model" : current?.source === "autopilot" ? "Autopilot's default" : "dl's default";
+    if (args.length > 1) {
+        deps.write(`\n  ${c.red("✗")} dl model takes one model ID, e.g. dl model ${DEFAULT_MODEL}\n\n`);
+        return 2;
+    }
+    if (args.length === 0 && !deps.interactive) {
+        deps.write(`\n  ${c.bold("Model")}  ${model}  ${c.dim(`(${from})`)}\n  ${c.dim("Change it:")} dl model <id>  ${c.dim("(model IDs: https://openrouter.ai/models)")}\n\n`);
+        return 0;
+    }
+    const prices = await modelPrices(deps.fetch);
+    let chosen;
+    if (args[0] !== undefined) {
+        const checked = checkModelId(args[0], prices);
+        if (!checked.ok) {
+            deps.write(`\n  ${c.red("✗")} ${checked.message}\n\n`);
+            return 1;
+        }
+        chosen = checked.model;
+    }
+    else {
+        const ui = deps.newUi();
+        deps.write("\n");
+        try {
+            chosen = await askModel(deps.prompter, ui, model, prices);
+        }
+        catch (error) {
+            if (!(error instanceof PromptCancelled))
+                throw error;
+            deps.write(`  ${c.dim(`Unchanged: ${model}`)}\n\n`);
+            return 130;
+        }
+        ui.finish();
+    }
+    await saveModel(chosen, deps.settingsFile);
+    deps.write(`\n  ${c.green("✓")} ${c.bold("Model")}  ${chosen}\n  ${c.dim("Used by dl run and new sessions. A running session keeps its model; switch it there with")} /model\n\n`);
+    return 0;
+}
+/** `dl model` with the real terminal and network. */
+export async function model(args, options) {
+    const { io, terminal } = options;
+    const color = io.color === true;
+    return modelCommand(args, {
+        newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
+        prompter: new TtyPrompter({ color }),
+        write: io.out,
+        color,
+        interactive: terminal,
+        fetch: globalThis.fetch,
+        autopilotModel: () => readAutopilotModel(),
+    });
+}

package/dist/laptop/setup.js

@@ -3,21 +3,24 @@ import { access as fileAccess, readdir, readFile } from "node:fs/promises";
 import { homedir, hostname } from "node:os";
 import { join, resolve } from "node:path";
 import { promisify } from "node:util";
-import { TtyPrompter } from "../prompt.js";
+import { PromptCancelled, TtyPrompter } from "../prompt.js";
 import { palette, PlainUi, TerminalUi } from "../ui.js";
-import { loadRemotes, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote } from "./config.js";
+import { loadRemotes, loadRemotesFile, normalizeServerUrl, REMOTE_NAME_RE, remotesPath, saveRemote, setDefaultRemote } from "./config.js";
 import { confirm, gatherKeys } from "./credentials.js";
 import { bootstrap, INSTALL_URL, installOnServer, pairLaptop, serverNeeds } from "./remote-install.js";
 import { checkServer, describeHost, discoverKeys, hostOf, parseSshConfig, parseTarget, realSshExec, SshAuthError } from "./ssh.js";
+import { askModel, DEFAULT_MODEL, loadSettings, modelPrices, readAutopilotModel, saveModel } from "./settings.js";
 import { openRemote, withConnections } from "./tunnel.js";
 const RUN_EXAMPLE = 'dl run "fix the flaky checkout test"';
+const PLACES = [
+    { value: "local", label: "On this computer", detail: "start now · nothing to rent · pauses when this computer sleeps" },
+    { value: "server", label: "On my own server", detail: "keeps going when your laptop is closed · needs SSH access" },
+];
 export async function setupWizard(deps) {
     const c = palette(deps.color);
     deps.write(`\n  ${c.bold("Directionally Local")}\n  Background coding agents. Where should they run?\n\n`);
-    deps.write(`  ${c.cyan("1")}  ${"On this computer".padEnd(22)} ${c.dim("start now · nothing to rent · pauses when this computer sleeps")}\n`);
-    deps.write(`  ${c.cyan("2")}  ${"On my own server".padEnd(22)} ${c.dim("keeps going when your laptop is closed · needs SSH access")}\n\n`);
     const ui = deps.newUi();
-    let where = await pick(ui, deps.prompter, "Where", "1 or 2 · Enter for 1", { "1": "local", "2": "server" });
+    let where = (await deps.prompter.select(ui.prompt("Where"), PLACES, 0)).value;
     ui.answered("Where", where === "local" ? "On this computer" : "On my own server");
     if (where === "local" && !deps.localSetup) {
         ui.line("info", "On this computer", "coming soon");
@@ -30,11 +33,16 @@ export async function setupWizard(deps) {
     }
     if (where === "local") {
         const keysUi = deps.newUi();
-        const answers = await gatherKeys(["github", "openrouter"], { ui: keysUi, prompter: deps.prompter, sources: deps.sources });
+        const answers = await gatherKeys(["github", "openrouter"], { ui: keysUi, prompter: deps.prompter, sources: deps.sources, place: "this computer" });
         keysUi.finish();
-        const remote = await deps.localSetup({ ui: deps.newUi(), prompter: deps.prompter, answers: { openrouterKey: answers.openrouterKey, githubToken: answers.githubToken } });
-        await saveRemote(remote, deps.remotesFile ?? remotesPath());
-        finishScreen(deps.newUi(), undefined);
+        const { remote, capacity } = await deps.localSetup({ ui: deps.newUi(), prompter: deps.prompter, answers: { openrouterKey: answers.openrouterKey, githubToken: answers.githubToken } });
+        const remotesFile = deps.remotesFile ?? remotesPath();
+        const isNew = !(await loadRemotes(remotesFile)).some((entry) => entry.name === remote.name);
+        await saveRemote(remote, remotesFile);
+        if (isNew)
+            await chooseDefault(deps, remote, remotesFile);
+        await chooseModel(deps);
+        finishScreen(deps.newUi(), capacity);
         return remote;
     }
     return setUpServer(deps);
@@ -61,7 +69,8 @@ async function setUpServer(deps) {
     // 4. A credential for this laptop, checked through the tunnel every command will use. Each
     // `dl pair` makes a new credential on the server, so a re-run keeps the saved one if it works.
     const remotesFile = deps.remotesFile ?? remotesPath();
-    const saved = (await loadRemotes(remotesFile)).find((entry) => sameServer(entry, access));
+    const known = await loadRemotes(remotesFile);
+    const saved = known.find((entry) => sameServer(entry, access));
     let remote;
     if (saved && await stillWorks({ ...saved, ssh: access }, deps.open))
         remote = { ...saved, ssh: access };
@@ -91,25 +100,26 @@ async function setUpServer(deps) {
     await saveRemote(remote, remotesFile);
     connectedUi.line("done", "This laptop", `connected as ${remote.name}`);
     connectedUi.finish();
+    if (!known.some((entry) => entry.name === paired.name))
+        await chooseDefault(deps, remote, remotesFile);
+    await chooseModel(deps);
     finishScreen(deps.newUi(), capacity);
     return remote;
 }
 async function chooseServer(deps, hosts) {
-    const c = palette(deps.color);
     const ui = deps.newUi();
-    if (hosts.length > 0) {
-        deps.write(`\n  ${c.dim("Your servers in ~/.ssh/config:")}\n`);
-        hosts.forEach((host, index) => deps.write(`  ${c.cyan(String(index + 1))}  ${host.alias.padEnd(22)} ${c.dim(describeHost(host))}\n`));
-        deps.write(`  ${c.cyan(String(hosts.length + 1))}  Another server\n\n`);
-    }
-    else {
-        deps.write("\n");
-    }
-    const hint = hosts.length > 0 ? `1-${hosts.length + 1}, or user@host[:port]` : "user@host[:port], e.g. root@203.0.113.10";
+    deps.write("\n");
+    const example = "user@host[:port], e.g. root@203.0.113.10";
+    const options = [
+        ...hosts.map((host, index) => ({ value: String(index), label: host.alias, detail: describeHost(host) })),
+        { value: "another", label: "Another server", input: { prompt: ui.prompt("Server address", example), placeholder: example } },
+    ];
     for (let attempt = 1;; attempt++) {
-        let answer = (await deps.prompter.text(ui.prompt("Server", hint))).trim();
-        const index = /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
-        const host = hosts[index];
+        // Without saved hosts, a one-item list would only be in the way: just ask for the address.
+        const picked = hosts.length > 0
+            ? await deps.prompter.select(ui.prompt("Server"), options, 0)
+            : { value: "another", text: (await deps.prompter.text(ui.prompt("Server", example))).trim() };
+        const host = picked.value === "another" ? undefined : hosts[Number(picked.value)];
         if (host) {
             ui.answered("SSH", host.alias);
             return {
@@ -118,12 +128,8 @@ async function chooseServer(deps, hosts) {
                 display: `${host.user ? `${host.user}@` : ""}${host.hostName ?? host.alias}${host.port && host.port !== 22 ? `:${host.port}` : ""}`,
             };
         }
-        if (index === hosts.length && hosts.length > 0) {
-            ui.answered("SSH", "another server");
-            answer = (await deps.prompter.text(ui.prompt("Server address", "user@host[:port], e.g. root@203.0.113.10"))).trim();
-        }
         try {
-            const access = parseTarget(answer);
+            const access = parseTarget(picked.text ?? "");
             ui.answered("SSH", access.target);
             return { access, display: `${access.target}${access.port ? `:${access.port}` : ""}` };
         }
@@ -134,6 +140,50 @@ async function chooseServer(deps, hosts) {
         }
     }
 }
+/**
+ * With two or more places set up, where `dl run` sends tasks unless told otherwise. Asked
+ * only when setup adds a place, with the new one preselected; the first place becomes the
+ * default by itself (saveRemote).
+ */
+async function chooseDefault(deps, added, remotesFile) {
+    const { remotes } = await loadRemotesFile(remotesFile);
+    if (remotes.length < 2)
+        return;
+    const ui = deps.newUi();
+    deps.write("\n");
+    const options = remotes.map((remote) => ({ value: remote.name, label: remote.name, detail: describePlace(remote) }));
+    const initial = Math.max(0, remotes.findIndex((remote) => remote.name === added.name));
+    const { value } = await deps.prompter.select(ui.prompt("Where should tasks go by default?"), options, initial);
+    await setDefaultRemote(value, remotesFile);
+    ui.answered("Default", value);
+    ui.finish();
+}
+/**
+ * Which model tasks and sessions use, asked once: setup skips it when dl already has one
+ * (dl model changes it). Autopilot's own default is preselected for people who have one.
+ */
+async function chooseModel(deps) {
+    if ((await loadSettings(deps.settingsFile)).model)
+        return;
+    const [current, prices] = await Promise.all([readAutopilotModel(deps.sources), deps.sources.fetch ? modelPrices(deps.sources.fetch) : undefined]);
+    const ui = deps.newUi();
+    deps.write("\n");
+    const model = await askModel(deps.prompter, ui, current ?? DEFAULT_MODEL, prices);
+    await saveModel(model, deps.settingsFile);
+    ui.answered("Model", `${model}  (change it any time: dl model)`);
+    ui.finish();
+}
+function describePlace(remote) {
+    if (remote.ssh)
+        return `server · ${remote.ssh.target}${remote.ssh.port ? `:${remote.ssh.port}` : ""}`;
+    try {
+        const host = new URL(remote.url).hostname;
+        return host === "127.0.0.1" || host === "localhost" ? "this computer" : `server · ${host}`;
+    }
+    catch {
+        return remote.url;
+    }
+}
 /**
  * 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
@@ -246,25 +296,13 @@ export function serverLabel(text) {
 }
 function finishScreen(ui, capacity) {
     ui.ready(capacity ? `Ready · fits ~${capacity} agents at once (estimate)` : "Ready", [
-        { label: "From any GitHub repository", value: RUN_EXAMPLE },
-        { label: "See progress, then check out the result", value: "dl runs\ndl pull ID" },
-    ]);
+        { label: "Start a session: cd into a GitHub repository, then type", value: "dl" },
+        { label: "Or hand off a one-off task", value: RUN_EXAMPLE },
+    ], { footer: "dl status shows where agents run and what they're doing." });
 }
 function laptopName(name) {
     return name.replace(/\.local$/, "").replace(/[^\p{L}\p{N} ._'()@-]/gu, "-").slice(0, 40) || "laptop";
 }
-async function pick(ui, prompter, label, hint, choices) {
-    const values = Object.values(choices);
-    for (let attempt = 1;; attempt++) {
-        const answer = (await prompter.text(ui.prompt(label, hint))).trim();
-        const choice = answer === "" ? values[0] : choices[answer];
-        if (choice)
-            return choice;
-        if (attempt >= 3)
-            throw new Error(`Pick one of ${Object.keys(choices).join(", ")}`);
-        ui.rejected(`Type ${Object.keys(choices).join(" or ")}.`);
-    }
-}
 /** `dl setup` with the real terminal, ssh, gh, and filesystem. */
 export async function setup(options) {
     const { io, terminal } = options;
@@ -277,25 +315,34 @@ export async function setup(options) {
         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(),
-        write: io.out,
-        color,
-        ssh: realSshExec,
-        open: openRemote,
-        sources: {
-            env: process.env,
-            home,
-            readFile: (path) => readFile(path, "utf8").catch(() => undefined),
-            listDir: (path) => readdir(path).catch(() => []),
-            gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
-            fetch: globalThis.fetch,
-        },
-        hostname: hostname(),
-        installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
-        ...(options.localSetup ? { localSetup: options.localSetup } : {}),
-        ...(identityFile ? { identityFile } : {}),
-    });
+    try {
+        await setupWizard({
+            newUi: () => terminal ? new TerminalUi(io.out, undefined, color) : new PlainUi(io.out),
+            prompter: new TtyPrompter({ color }),
+            write: io.out,
+            color,
+            ssh: realSshExec,
+            open: openRemote,
+            sources: {
+                env: process.env,
+                home,
+                readFile: (path) => readFile(path, "utf8").catch(() => undefined),
+                listDir: (path) => readdir(path).catch(() => []),
+                gh: () => execFileAsync("gh", ["auth", "token"], { timeout: 5000 }).then(({ stdout }) => stdout.trim() || undefined, () => undefined),
+                fetch: globalThis.fetch,
+            },
+            hostname: hostname(),
+            installUrl: process.env.DL_INSTALL_URL || INSTALL_URL,
+            ...(options.localSetup ? { localSetup: options.localSetup } : {}),
+            ...(identityFile ? { identityFile } : {}),
+        });
+    }
+    catch (error) {
+        if (!(error instanceof PromptCancelled))
+            throw error;
+        // Esc / Ctrl-C at a question: the terminal is restored; say so quietly and stop.
+        io.out(`  ${palette(color).dim("Cancelled. Run")} dl setup ${palette(color).dim("when you're ready.")}\n\n`);
+        return 130;
+    }
     return 0;
 }

package/dist/laptop/tunnel.js

@@ -57,6 +57,14 @@ export function createOpener(options = {}) {
     };
 }
 export const openRemote = createOpener();
+/**
+ * For an interactive session: ssh in its own process group, so Ctrl-C typed into the agent's
+ * screen (which the terminal sends to its whole foreground group) doesn't drop the tunnel.
+ * The session closes it itself when the agent exits, or when dl is told to stop.
+ */
+export const openRemoteForSession = createOpener({
+    spawn: (args) => spawn("ssh", args, { stdio: ["ignore", "ignore", "pipe"], detached: true }),
+});
 /**
  * The endpoints one command uses: at most one tunnel per server, reused across its
  * requests, all closed when the command ends (commands close it in `finally`, which also

package/dist/local/setup.js

@@ -221,10 +221,8 @@ export async function setUpOnThisComputer(input) {
             expiresAt: new Date(credential.expiresAt).toISOString(),
             addedAt: at,
         };
-        return {
-            value: remote,
-            detail: `${url.replace(/^http:\/\//, "")} · fits ~${localCapacity(docker)} at once · tasks pause while this computer sleeps`,
-        };
+        // The address is an implementation detail here; how many fit goes on the wizard's Ready line.
+        return { value: { remote, capacity: localCapacity(docker) }, detail: "this computer · tasks pause while it sleeps" };
     });
 }
 /**