directionallylocal 0.3.0 → 0.4.1

package/dist/model-prices.js

@@ -0,0 +1,119 @@
+export const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+const FETCH_TIMEOUT_MS = 15_000;
+/** Older than this, `dl doctor` suggests refreshing it. */
+export const MODEL_PRICES_MAX_AGE_DAYS = 7;
+/** USD per token as OpenRouter gives it ("0.0000001"), or undefined when it isn't a usable price. */
+function perToken(value) {
+    const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+    // OpenRouter marks variable pricing with "-1"; genuine 0 is a free model and is kept.
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+/** Per million tokens, without float noise (0.0000001 × 1e6 is 0.09999999999999999). */
+function perMillion(price) {
+    return Math.round(price * 1e12) / 1e6;
+}
+/** OpenRouter's catalog response to a price table; entries without usable prices are skipped. */
+export function pricesFromCatalog(catalog) {
+    const data = catalog?.data;
+    if (!Array.isArray(data))
+        throw new Error("OpenRouter's model list had no models");
+    const table = {};
+    for (const entry of data) {
+        const id = typeof entry?.id === "string" ? entry.id.trim().toLowerCase() : "";
+        if (!id)
+            continue;
+        const input = perToken(entry?.pricing?.prompt);
+        const output = perToken(entry?.pricing?.completion);
+        if (input === undefined || output === undefined)
+            continue;
+        table[id] = { inputPerMTok: perMillion(input), outputPerMTok: perMillion(output) };
+    }
+    return table;
+}
+/** Downloads OpenRouter's public model list (no key needed) as a price table. */
+export async function fetchModelPrices(fetchImpl = fetch) {
+    let response;
+    try {
+        response = await fetchImpl(OPENROUTER_MODELS_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS), headers: { "User-Agent": "directionallylocal" } });
+    }
+    catch (error) {
+        throw new Error(`couldn't reach openrouter.ai: ${error.message}`);
+    }
+    if (!response.ok)
+        throw new Error(`openrouter.ai answered HTTP ${response.status}`);
+    const table = pricesFromCatalog(await response.json().catch(() => undefined));
+    const count = Object.keys(table).length;
+    if (count === 0)
+        throw new Error("OpenRouter's model list had no prices");
+    return { table, count };
+}
+export function renderModelPrices(table) {
+    const sorted = Object.fromEntries(Object.keys(table).sort().map((id) => [id, table[id]]));
+    return `${JSON.stringify(sorted, null, 2)}\n`;
+}
+/** How many models a written price file holds, or undefined when it isn't one. */
+export function countModelPrices(text) {
+    if (text === undefined)
+        return undefined;
+    try {
+        const parsed = JSON.parse(text);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return undefined;
+        return Object.values(parsed).filter((price) => typeof price?.inputPerMTok === "number" && typeof price?.outputPerMTok === "number").length;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Refreshes the price file. When OpenRouter can't be reached, an existing file is kept;
+ * either way it warns rather than failing the install. Returns a step detail, if any.
+ */
+export async function refreshModelPrices(system, input) {
+    if (system.dryRun) {
+        system.log(`  would fetch: ${OPENROUTER_MODELS_URL} -> ${input.path}`);
+        return undefined;
+    }
+    try {
+        const { table, count } = await fetchModelPrices(input.fetchImpl);
+        await system.writeFile(input.path, renderModelPrices(table), input.write);
+        return `prices for ${count} models`;
+    }
+    catch (error) {
+        const reason = error.message;
+        const kept = countModelPrices(await system.readFile(input.path));
+        if (kept !== undefined && kept > 0) {
+            input.warn(`Couldn't refresh model prices (${reason}); kept the last list (${kept} models).`);
+        }
+        else {
+            input.warn(`Couldn't download model prices (${reason}). Tasks will fail with "model not priced" until ${input.retry} can reach openrouter.ai.`);
+        }
+        return undefined;
+    }
+}
+/** For `dl doctor` and `dl local status`: the file's contents and its age (mtime, seconds). */
+export function modelPricesHealth(text, mtimeSeconds, now, refresh) {
+    if (text === undefined)
+        return { ok: false, warn: false, detail: `missing; tasks fail with "model not priced"` };
+    const count = countModelPrices(text);
+    if (count === undefined || count === 0)
+        return { ok: false, warn: false, detail: "unreadable; tasks may fail with \"model not priced\"" };
+    const models = `${count} model${count === 1 ? "" : "s"}`;
+    if (mtimeSeconds === undefined)
+        return { ok: true, warn: false, detail: models };
+    const days = Math.max(0, Math.floor((now.getTime() / 1000 - mtimeSeconds) / 86_400));
+    const age = days === 0 ? "updated today" : `${days} day${days === 1 ? "" : "s"} old`;
+    if (days > MODEL_PRICES_MAX_AGE_DAYS)
+        return { ok: true, warn: true, detail: `${models} · ${age}; ${refresh} refreshes it` };
+    return { ok: true, warn: false, detail: `${models} · ${age}` };
+}
+/** A file's mtime in seconds via stat (GNU on Linux, BSD on macOS); undefined when unknown. */
+export async function fileMtime(system, path, platform = "linux") {
+    const result = await system.probe("stat", platform === "darwin" ? ["-f", "%m", path] : ["-c", "%Y", path]);
+    const seconds = Number(result.stdout.trim());
+    return result.code === 0 && result.stdout.trim() !== "" && Number.isFinite(seconds) ? seconds : undefined;
+}
+/** A failed run's reason when Hotcell refused the model for lack of a price. */
+export function isModelNotPriced(text) {
+    return /model not priced/i.test(text);
+}

package/dist/up.js

@@ -5,6 +5,7 @@ import { AUTOPILOT_PORT, CELL_MEMORY_MB, GITHUB_PROXY_PORT, HOTCELL_EGRESS_PORT,
 import { ACCESS_MODES, readState, writeState } from "./state.js";
 import { PlainUi } from "./ui.js";
 import { ownerLink } from "./server-api.js";
+import { refreshModelPrices } from "./model-prices.js";
 const DRY_RUN_BRIDGE_IP = "172.17.0.1";
 const DRY_RUN_URL = "https://<this-machine>.<tailnet>.ts.net";
 /** `dl up`: install or repair Hotcell + Autopilot as services. Safe to re-run. */
@@ -35,7 +36,7 @@ export async function up(system, options) {
         { id: "software", label: "Installing Hotcell + Autopilot" },
         { id: "image", label: "Building the sandbox image" },
         { id: "services", label: "Starting services" },
-        { id: "access", label: access === "tailscale" ? "Opening private access" : "Starting the API" },
+        { id: "access", label: access === "tailscale" ? "Opening private access" : "Starting the server" },
     ]);
     const step = async (id, work) => {
         ui.start(id);
@@ -103,6 +104,14 @@ export async function up(system, options) {
         const hotcellValues = parseEnvFile(await system.readFile(PATHS.hotcellEnv));
         const apiKey = hotcellValues.HOTCELL_API_KEY || randomBytes(24).toString("hex");
         await system.mkdir(PATHS.hotcellEtc, { mode: 0o750, owner: `root:${USERS.hotcell}` });
+        // Read once at Hotcell's start, so it's in place before the restart below.
+        const prices = await refreshModelPrices(system, {
+            path: PATHS.modelPrices,
+            write: { mode: 0o644, owner: `${USERS.hotcell}:${USERS.hotcell}` },
+            fetchImpl,
+            warn: (text) => ui.warn(text),
+            retry: "dl up",
+        });
         await system.writeFile(PATHS.hotcellEnv, hotcellEnv({ apiKey, bridgeIp }), { mode: 0o640, owner: `root:${USERS.hotcell}`, secret: true });
         if (!(await system.readFile(PATHS.asterConfig))) {
             await system.writeFile(PATHS.asterConfig, asterConfig(), { mode: 0o640, owner: `root:${USERS.autopilot}` });
@@ -118,7 +127,7 @@ export async function up(system, options) {
         await system.run("systemctl", ["restart", SERVICES.hotcell]);
         await waitUntil(system, sleep, "Hotcell", async () => (await system.probe("curl", ["-fsS", "-o", "/dev/null", `http://127.0.0.1:${HOTCELL_PORT}/`])).code === 0
             || (await system.probe("sh", ["-c", `ss -ltn | grep -q '127.0.0.1:${HOTCELL_PORT}'`])).code === 0);
-        return { value: apiKey, detail: "sandboxes and keys ready" };
+        return { value: apiKey, detail: `sandboxes and keys ready${prices ? ` · ${prices}` : ""}` };
     });
     const url = await step("access", async () => {
         // Moving off Tailscale: stop publishing on the tailnet, so the only way in is the new one.
@@ -131,7 +140,9 @@ export async function up(system, options) {
         await system.run("systemctl", ["restart", SERVICES.autopilot]);
         // Without a token the Aster API answers 401: the server is up and refusing strangers.
         await waitUntil(system, sleep, "Autopilot", async () => (await system.probe("curl", ["-s", "-o", "/dev/null", "-w", "%{http_code}", `http://127.0.0.1:${AUTOPILOT_PORT}/api/v1/health`])).stdout.trim() === "401");
-        return { value: address, detail: address.replace(/^https?:\/\//, "") };
+        // The API only listens on this machine: say who can reach it rather than a loopback address.
+        const reach = access === "tailscale" ? address.replace(/^https?:\/\//, "") : access === "ssh" ? "private · reached over SSH" : "private · this machine only";
+        return { value: address, detail: reach };
     });
     const now = (options.now ?? (() => new Date()))().toISOString();
     const state = {
@@ -390,7 +401,7 @@ async function latestVersion(system, pkg) {
         throw new Error(`Couldn't look up the latest ${pkg} on npm${result.stderr ? `: ${result.stderr.trim()}` : ""}`);
     return version;
 }
-function asHotcell(system, args, options = {}) {
+export function asHotcell(system, args, options = {}) {
     return system.run("runuser", [
         "-u", USERS.hotcell, "--", "env", `HOTCELL_HOME=${PATHS.hotcellHome}`, "HOTCELL_KEYSTORE=file",
         "/usr/bin/node", hotcellBin(), ...args,
@@ -492,7 +503,7 @@ async function serveOverTailscale(system) {
         throw new Error("Tailscale is up but reported no DNS name for this machine; is MagicDNS on?");
     return `https://${dnsName}`;
 }
-async function waitUntil(system, sleep, what, ready, unit = what.toLowerCase()) {
+export async function waitUntil(system, sleep, what, ready, unit = what.toLowerCase()) {
     if (system.dryRun)
         return;
     for (let attempt = 0; attempt < 60; attempt++) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "directionallylocal",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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",
   "repository": {
     "type": "git",