directionallylocal 0.5.0 → 0.6.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { briefStatus, connectLaptop, laptopsCommand, logsCommand, pairLaptop, se
 import { cancel, connect, describeError, laptopHome, pull, run, runs, servers, use, watch } from "./laptop/commands.js";
 import { loadRemotes } from "./laptop/config.js";
 import { keys } from "./laptop/keys.js";
+import { model } from "./laptop/settings.js";
 import { projectSession } from "./laptop/session.js";
 import { setup } from "./laptop/setup.js";
 import { localCommand } from "./local/cli.js";
@@ -36,6 +37,7 @@ On your laptop:
   dl servers              where agents run (dl servers remove NAME · dl servers rename OLD NEW)
   dl use [NAME]           where tasks go without --server (no NAME: show it)
   dl keys [openrouter|github]   which keys are set, or replace one (--server NAME)
+  dl model [ID]           the model for tasks and sessions (no ID: pick from a list)
   run options: --server NAME, -m/--model MODEL, --repo OWNER/NAME, --detach
   dl local status         agents running on this computer: running?, where, how many fit
   dl local uninstall [--purge]   stop and remove them (--purge also deletes keys and data)
@@ -293,6 +295,8 @@ export async function main(argv, io = {
                 return await servers(parsed.positionals.slice(1), laptopIO);
             case "use":
                 return await use(parsed.positionals.slice(1), laptopIO);
+            case "model":
+                return await model(parsed.positionals.slice(1), { io: laptopIO, terminal });
             case "runs":
                 // On a server, its runs; on a laptop, the tasks it sent.
                 if (!(await readState(system))) {

package/dist/laptop/commands.js

@@ -1,18 +1,18 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import { homedir, hostname } from "node:os";
+import { hostname } from "node:os";
 import { promisify } from "node:util";
 import { isModelNotPriced } from "../model-prices.js";
 import { palette } from "../ui.js";
 import { RemoteApiError, RemoteClient, TERMINAL_STATUSES } from "./client.js";
 import { defaultRemoteName, loadRemotes, loadRemotesFile, normalizeServerUrl, recordLastUsed, REMOTE_NAME_RE, removeRemote, renameRemote, resolveRemote, resolveTarget, saveRemote, setDefaultRemote, } from "./config.js";
-import { autopilotConfigPath } from "./credentials.js";
 import { PAIRED_NAME } from "../local/layout.js";
 import { detectGitHubRepository, snapshotWorkingTree } from "./git.js";
+import { DEFAULT_MODEL, laptopModel } from "./settings.js";
 import { sshCommandLine } from "./ssh.js";
 import { openBrowser } from "./open-browser.js";
 import { withConnections } from "./tunnel.js";
+export { DEFAULT_MODEL, readAutopilotModel } from "./settings.js";
 /**
  * `dl` on a laptop: send tasks to where agents run (this computer, or your own server),
  * follow them, and check out the pull requests. It talks to the server's API directly (the
@@ -23,8 +23,6 @@ import { withConnections } from "./tunnel.js";
  */
 const execFileAsync = promisify(execFile);
 const RUN_END_EVENTS = new Set(["completed", "failed", "cancelled", "interrupted"]);
-/** The model a task gets when neither -m nor the laptop's Autopilot picks one the server offers. */
-export const DEFAULT_MODEL = "moonshotai/kimi-k2.6";
 const processIO = {
     out: (text) => process.stdout.write(text),
     err: (text) => process.stderr.write(text),
@@ -68,7 +66,7 @@ export async function connect(input, io = processIO) {
  */
 export async function run(input, io = processIO) {
     const { remote, reason } = await resolveTarget(input.server);
-    const preferred = input.preferredModel ?? await (input.autopilotModel ?? (() => readAutopilotModel()))();
+    const preferred = input.preferredModel ?? await (input.autopilotModel ?? laptopModel)();
     return withConnections(input.open, async (connections) => runOn(await connections.client(remote), remote, reason, { ...input, ...(preferred ? { preferredModel: preferred } : {}) }, io));
 }
 async function runOn(client, remote, reason, input, io) {
@@ -264,7 +262,7 @@ export async function renameServer(args, io = processIO, path) {
     return 0;
 }
 /** `dl` on a laptop: what this is, which servers it's connected to, what to type next. */
-export async function laptopHome(io = processIO, open) {
+export async function laptopHome(io = processIO, open, model = laptopModel) {
     const c = palette(io.color === true);
     const remotes = await loadRemotes();
     if (remotes.length === 0)
@@ -278,11 +276,12 @@ export async function laptopHome(io = processIO, open) {
             total += list?.length ?? 0;
         }
     });
-    const current = await defaultName();
+    const [current, chosen] = await Promise.all([defaultName(), model()]);
     io.out(`\n  ${c.bold("Directionally Local")}  ${c.dim("on this laptop")}\n\n`);
     io.out("  Coding agents that run on this computer or your own server: send a task, get a pull request back.\n\n");
     io.out(`  ${c.dim("Runs on".padEnd(11))}${remotes.map((remote) => `${mark(remote, current, c)} ${remote.name} ${c.dim(where(remote))}`).join(", ")}   ${c.dim(remotes.length > 1 ? "dl servers · dl use NAME" : "dl servers")}\n`);
-    io.out(`  ${c.dim("Tasks".padEnd(11))}${running} running · ${total} in all   ${c.dim("dl runs")}\n\n`);
+    io.out(`  ${c.dim("Tasks".padEnd(11))}${running} running · ${total} in all   ${c.dim("dl runs")}\n`);
+    io.out(`  ${c.dim("Model".padEnd(11))}${chosen ?? DEFAULT_MODEL}   ${c.dim("dl model")}\n\n`);
     io.out(`  ${c.dim("Start a session: cd into a GitHub repository, then type")}  ${c.bold("dl")}\n`);
     io.out(`  ${c.dim("Or hand off a one-off task:")}  ${c.bold('dl run "fix the flaky checkout test"')}\n\n`);
     return true;
@@ -402,7 +401,7 @@ async function findRun(id, server, connections) {
     return matches[0];
 }
 /**
- * The task's model: -m/--model; else the laptop's Autopilot default, if the server offers it;
+ * The task's model: -m/--model; else the laptop's default (dl model, else Autopilot's), if the server offers it;
  * else DEFAULT_MODEL, if offered. Never just the first in the server's list (that's the
  * whole OpenRouter catalog, in no useful order).
  */
@@ -419,30 +418,9 @@ export function pickModel(models, requested, preferred) {
         return DEFAULT_MODEL;
     if (models.length === 0)
         throw new Error("The server offers no models; check its OpenRouter key (on the server: dl doctor)");
-    const tried = preferred && preferred !== DEFAULT_MODEL ? `your Autopilot model (${preferred}) or ${DEFAULT_MODEL}` : DEFAULT_MODEL;
+    const tried = preferred && preferred !== DEFAULT_MODEL ? `your model (${preferred}) or ${DEFAULT_MODEL}` : DEFAULT_MODEL;
     throw new Error(`The server doesn't offer ${tried}. ${how}`);
 }
-/**
- * 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;
-    }
-}
 /** Where a place is, as people know it: this computer, its URL, or the SSH destination its tunnel goes to. */
 function where(remote) {
     if (remote.ssh)

package/dist/laptop/session.js

@@ -7,7 +7,8 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { palette } from "../ui.js";
 import { RemoteApiError } from "./client.js";
-import { describeError, pickModel, readAutopilotModel } from "./commands.js";
+import { describeError, pickModel } from "./commands.js";
+import { laptopModel } from "./settings.js";
 import { recordLastUsed, resolveTarget } from "./config.js";
 import { detectGitHubRepository, snapshotWorkingTree } from "./git.js";
 import { findSession, forgetSession, rememberSession, sessionsPath } from "./session-store.js";
@@ -121,7 +122,7 @@ export async function projectSession(input, io) {
                     const [workspaces, models, preferred] = await step(Promise.all([
                         client.workspaces(),
                         client.models(),
-                        input.model ? Promise.resolve(undefined) : (input.autopilotModel ?? (() => readAutopilotModel()))(),
+                        input.model ? Promise.resolve(undefined) : (input.autopilotModel ?? laptopModel)(),
                     ]));
                     const workspace = workspaces[0];
                     if (!workspace)

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

@@ -9,6 +9,7 @@ import { loadRemotes, loadRemotesFile, normalizeServerUrl, REMOTE_NAME_RE, remot
 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 = [
@@ -40,6 +41,7 @@ export async function setupWizard(deps) {
         await saveRemote(remote, remotesFile);
         if (isNew)
             await chooseDefault(deps, remote, remotesFile);
+        await chooseModel(deps);
         finishScreen(deps.newUi(), capacity);
         return remote;
     }
@@ -100,6 +102,7 @@ async function setUpServer(deps) {
     connectedUi.finish();
     if (!known.some((entry) => entry.name === paired.name))
         await chooseDefault(deps, remote, remotesFile);
+    await chooseModel(deps);
     finishScreen(deps.newUi(), capacity);
     return remote;
 }
@@ -155,6 +158,21 @@ async function chooseDefault(deps, added, 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}` : ""}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "directionallylocal",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Directionally Local: background coding agents on your own server. One-line server install, and the dl command for your server and laptop.",
   "license": "Apache-2.0",
   "homepage": "https://directionallylocal.com",