directionallylocal 0.4.0 → 0.5.0

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 = [];
@@ -62,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);
@@ -237,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")

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/prompt.js

@@ -1,11 +1,52 @@
 import { openSync, closeSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { ReadStream, WriteStream } from "node:tty";
+import { palette } from "./ui.js";
+/** Thrown when someone presses Esc or Ctrl-C at a question; the terminal is already restored. */
+export class PromptCancelled extends Error {
+    constructor() {
+        super("Cancelled.");
+        this.name = "PromptCancelled";
+    }
+}
+function openDevTty() {
+    let fd;
+    try {
+        fd = openSync("/dev/tty", "r+");
+    }
+    catch {
+        throw new Error("No terminal to ask on; pass the answers as environment variables (see `dl --help`).");
+    }
+    const input = new ReadStream(fd);
+    const output = new WriteStream(fd);
+    return {
+        input,
+        output,
+        close: () => {
+            input.destroy();
+            output.destroy();
+            try {
+                closeSync(fd);
+            }
+            catch { /* already closed with the streams */ }
+        },
+    };
+}
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
 /**
  * Reads from /dev/tty, so prompts work under `curl … | sh` where stdin is the script.
  * Without a terminal every question fails with the env var that answers it.
  */
 export class TtyPrompter {
+    open;
+    color;
+    env;
+    constructor(options = {}) {
+        this.open = options.open ?? openDevTty;
+        this.env = options.env ?? process.env;
+        this.color = options.color ?? (!this.env.NO_COLOR && this.env.TERM !== "dumb");
+    }
     async choose(question, options, fallback) {
         const lines = options.map((option, index) => `  ${index + 1}. ${option.label}`).join("\n");
         const answer = (await this.ask(`${question}\n${lines}\nChoice [1]: `, false)).trim();
@@ -14,22 +55,50 @@ export class TtyPrompter {
         const index = Number(answer) - 1;
         return options[index]?.value ?? options.find((option) => option.value === answer)?.value ?? fallback;
     }
+    async select(question, options, initial = 0) {
+        if (options.length === 0)
+            throw new Error("select() needs at least one option");
+        const start = Math.min(Math.max(0, initial), options.length - 1);
+        const terminal = this.open();
+        const raw = typeof terminal.input.setRawMode === "function" && terminal.input.isTTY === true && this.env.TERM !== "dumb";
+        if (!raw) {
+            terminal.close();
+            return this.numbered(question, options, start);
+        }
+        return new ArrowSelect(terminal, question, options, start, this.color).run();
+    }
     secret(question) {
         return this.ask(question, true);
     }
     text(question) {
         return this.ask(question, false);
     }
-    ask(question, hidden) {
-        let fd;
-        try {
-            fd = openSync("/dev/tty", "r+");
-        }
-        catch {
-            throw new Error("No terminal to ask on; pass the answers as environment variables (see `dl --help`).");
+    /** The plain fallback: a numbered list, then a typed choice (Enter for the preselected one). */
+    async numbered(question, options, start) {
+        const c = palette(this.color);
+        const width = Math.max(...options.map((option) => option.label.length)) + 2;
+        const list = options.map((option, index) => `  ${c.cyan(String(index + 1))}  ${option.detail ? `${option.label.padEnd(width)} ${c.dim(option.detail)}` : option.label}`).join("\n");
+        const typed = options.find((option) => option.input);
+        const range = options.length === 2 ? "1 or 2" : `1-${options.length}`;
+        const hint = `${range}${typed ? `, or ${typed.input.placeholder.split(",")[0]}` : ""} · Enter for ${start + 1}`;
+        const split = question.lastIndexOf("\n");
+        const styled = split >= 0 ? `${question.slice(0, split)}  ${c.dim(hint)}${question.slice(split)}` : question;
+        for (let attempt = 1;; attempt++) {
+            const answer = (await this.ask(`${attempt === 1 ? `${list}\n\n` : ""}${styled}`, false)).trim();
+            const index = answer === "" ? start : /^\d+$/.test(answer) ? Number(answer) - 1 : -1;
+            const option = options[index];
+            if (option?.input)
+                return { value: option.value, text: (await this.ask(option.input.prompt, false)).trim() };
+            if (option)
+                return { value: option.value };
+            if (typed && answer)
+                return { value: typed.value, text: answer };
+            if (attempt >= 3)
+                throw new Error(`Pick one of ${range}`);
         }
-        const input = new ReadStream(fd);
-        const output = new WriteStream(fd);
+    }
+    ask(question, hidden) {
+        const { input, output, close } = this.open();
         // A styled prompt is "label line\n› ": print the label line ourselves and give readline
         // only the last line, so its redraws (and the hidden-input filter) stay on one line.
         const split = question.lastIndexOf("\n");
@@ -38,7 +107,7 @@ export class TtyPrompter {
         if (head)
             output.write(head);
         return new Promise((resolve) => {
-            const rl = createInterface({ input, output, terminal: true });
+            const rl = createInterface({ input, output, terminal: input.isTTY === true });
             if (hidden) {
                 // Echo nothing while the secret is typed.
                 rl._writeToOutput = (text) => {
@@ -50,17 +119,248 @@ export class TtyPrompter {
                 if (hidden)
                     output.write("\n");
                 rl.close();
-                input.destroy();
-                output.destroy();
-                try {
-                    closeSync(fd);
-                }
-                catch { /* already closed with the streams */ }
+                close();
                 resolve(answer.trim());
             });
         });
     }
 }
+/** Splits a chunk of terminal input into keys (one chunk can hold several, e.g. a paste). */
+export function parseKeys(chunk) {
+    const keys = [];
+    let text = "";
+    const push = (key) => {
+        if (text)
+            keys.push({ text });
+        text = "";
+        keys.push(key);
+    };
+    for (let i = 0; i < chunk.length; i++) {
+        const ch = chunk[i];
+        if (ch === "\x1b") {
+            const next = chunk[i + 1];
+            if (next === "[" || next === "O") {
+                // CSI / SS3: skip the parameters up to the final byte.
+                let end = i + 2;
+                while (end < chunk.length && !/[A-Za-z~]/.test(chunk[end]))
+                    end++;
+                const final = chunk[end];
+                if (final === "A")
+                    push("up");
+                else if (final === "B")
+                    push("down");
+                i = end;
+            }
+            else {
+                push("escape");
+            }
+        }
+        else if (ch === "\r" || ch === "\n") {
+            push("enter");
+        }
+        else if (ch === "\x03" || ch === "\x04") {
+            push("cancel");
+        }
+        else if (ch === "\x7f" || ch === "\b") {
+            push("backspace");
+        }
+        else if (ch === "\x15") {
+            push("clear");
+        }
+        else if (ch >= " ") {
+            text += ch;
+        }
+    }
+    if (text)
+        keys.push({ text });
+    return keys;
+}
+/**
+ * The arrow-key list, drawn inline under the question in normal scrollback: ↑/↓ or j/k move
+ * the `›` cursor, a digit jumps, Enter picks, Esc or Ctrl-C cancels. It redraws only its own
+ * lines and hides the cursor meanwhile; raw mode and the cursor come back on every way out,
+ * including a crash or a SIGINT/SIGTERM from elsewhere.
+ */
+class ArrowSelect {
+    terminal;
+    options;
+    cursor;
+    typing = false;
+    text = "";
+    digits = "";
+    drawn = 0;
+    head;
+    marker;
+    caret;
+    c;
+    constructor(terminal, question, options, start, color) {
+        this.terminal = terminal;
+        this.options = options;
+        this.c = palette(color);
+        this.cursor = start;
+        this.caret = color ? "\x1b[7m \x1b[27m" : "▏";
+        const split = question.lastIndexOf("\n");
+        this.head = split >= 0 ? question.slice(0, split) : question.trimEnd();
+        this.marker = split >= 0 ? question.slice(split + 1) : `${this.c.cyan("›")} `;
+    }
+    run() {
+        const { input, output } = this.terminal;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            const restore = () => {
+                input.setRawMode?.(false);
+                output.write(SHOW_CURSOR);
+            };
+            const onExit = () => restore();
+            const onSignal = () => { restore(); process.exit(130); };
+            const end = (outcome) => {
+                if (finished)
+                    return;
+                finished = true;
+                input.off("data", onData);
+                process.off("exit", onExit);
+                process.off("SIGINT", onSignal);
+                process.off("SIGTERM", onSignal);
+                restore();
+                this.terminal.close();
+                outcome();
+            };
+            const onData = (chunk) => {
+                try {
+                    for (const key of parseKeys(typeof chunk === "string" ? chunk : chunk.toString("utf8"))) {
+                        const result = this.handle(key);
+                        if (result === "cancel") {
+                            this.erase(true);
+                            end(() => reject(new PromptCancelled()));
+                            return;
+                        }
+                        if (result) {
+                            // Leave what an answered text prompt leaves: the question and `› choice`.
+                            this.erase(false);
+                            output.write(`${this.marker}${result.text ?? this.options.find((option) => option.value === result.value).label}\n`);
+                            end(() => resolve(result));
+                            return;
+                        }
+                    }
+                    this.draw();
+                }
+                catch (error) {
+                    end(() => reject(error));
+                }
+            };
+            process.once("exit", onExit);
+            process.on("SIGINT", onSignal);
+            process.on("SIGTERM", onSignal);
+            input.setRawMode(true);
+            input.on("data", onData);
+            input.resume();
+            output.write(`${HIDE_CURSOR}${this.fit(this.head, this.c.dim("  ↑/↓ to move · Enter to pick"))}\n`);
+            this.draw();
+        });
+    }
+    /** Applies a key: a result when something was picked, "cancel" to stop, else nothing (redraw). */
+    handle(key) {
+        if (key === "cancel")
+            return "cancel";
+        if (this.typing) {
+            if (key === "escape") {
+                this.typing = false;
+                this.text = "";
+            }
+            else if (key === "enter")
+                return this.text.trim() ? { value: this.options[this.cursor].value, text: this.text.trim() } : undefined;
+            else if (key === "backspace")
+                this.text = this.text.slice(0, -1);
+            else if (key === "clear")
+                this.text = "";
+            else if (typeof key === "object")
+                this.text += key.text;
+            return undefined;
+        }
+        if (key === "escape")
+            return "cancel";
+        if (key === "up")
+            this.move(-1);
+        else if (key === "down")
+            this.move(1);
+        else if (key === "enter") {
+            const option = this.options[this.cursor];
+            if (!option.input)
+                return { value: option.value };
+            this.typing = true;
+        }
+        else if (typeof key === "object") {
+            for (const ch of key.text) {
+                if (ch === "k")
+                    this.move(-1);
+                else if (ch === "j")
+                    this.move(1);
+                else if (/\d/.test(ch))
+                    this.jump(ch);
+            }
+        }
+        return undefined;
+    }
+    move(by) {
+        this.digits = "";
+        this.cursor = (this.cursor + by + this.options.length) % this.options.length;
+    }
+    /** A digit jumps to that option; with 10 or more, a second digit right after makes 10+. */
+    jump(digit) {
+        const combined = Number(this.digits + digit) - 1;
+        if (this.digits && combined < this.options.length) {
+            this.cursor = combined;
+            this.digits = "";
+            return;
+        }
+        const single = Number(digit) - 1;
+        if (single >= 0 && single < this.options.length)
+            this.cursor = single;
+        this.digits = this.options.length >= 10 && single >= 0 ? digit : "";
+    }
+    lines() {
+        if (this.typing) {
+            const option = this.options[this.cursor];
+            const placeholder = this.text ? "" : this.c.dim(option.input.placeholder);
+            // The real cursor stays hidden (it sits below the list); draw one where typing goes.
+            return [this.c.dim(`  ${option.label} · Esc to go back`), `${this.marker}${this.text}${this.caret}${placeholder}`];
+        }
+        const width = Math.max(...this.options.map((option) => option.label.length)) + 2;
+        return this.options.map((option, index) => {
+            const selected = index === this.cursor;
+            const label = option.detail ? option.label.padEnd(width) : option.label;
+            const line = `  ${selected ? this.c.cyan("›") : " "} ${selected ? this.c.bold(label) : label}`;
+            return this.fit(line, option.detail ? this.c.dim(option.detail) : "");
+        });
+    }
+    /** Redraws the lines under the question in place; lines never wrap, so the count holds. */
+    draw() {
+        const lines = this.lines();
+        const rewind = this.drawn > 0 ? `\x1b[${this.drawn}F` : "";
+        // When there are fewer lines than last time (typing mode), clear what's left below.
+        const stale = this.drawn > lines.length ? "\x1b[J" : "";
+        this.terminal.output.write(`${rewind}${lines.map((line) => `\x1b[2K${line}\n`).join("")}${stale}`);
+        this.drawn = lines.length;
+    }
+    /** Erases the list (and, when cancelling, the question too). */
+    erase(all) {
+        const up = this.drawn + (all ? 1 : 0);
+        this.terminal.output.write(`${up > 0 ? `\x1b[${up}F` : ""}\x1b[J`);
+        this.drawn = 0;
+    }
+    /** `styled` plus a dim tail, the tail cut so the line fits the terminal's width. */
+    fit(styled, tail) {
+        const columns = this.terminal.output.columns || 80;
+        const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "");
+        const room = columns - 1 - visible(styled).length;
+        const plainTail = visible(tail);
+        if (plainTail.length <= room)
+            return `${styled}${tail}`;
+        if (room <= 1)
+            return styled;
+        return `${styled}${this.c.dim(`${plainTail.slice(0, room - 1)}…`)}`;
+    }
+}
 /** Answers from a map (tests); a missing answer is a test bug, so it throws. */
 export class ScriptedPrompter {
     answers;
@@ -71,6 +371,23 @@ export class ScriptedPrompter {
     async choose(question) {
         return this.answer(question);
     }
+    /**
+     * An answer is a number (1-based), an option's value or label, or "" for the preselected
+     * one. Picking an option that takes input then asks its prompt; other text goes to it directly.
+     */
+    async select(question, options, initial = 0) {
+        const answer = this.answer(question).trim();
+        const index = answer === "" ? initial : /^\d+$/.test(answer) ? Number(answer) - 1 : options.findIndex((option) => option.value === answer || option.label === answer);
+        const option = options[index];
+        if (option?.input)
+            return { value: option.value, text: this.answer(option.input.prompt).trim() };
+        if (option)
+            return { value: option.value };
+        const typed = options.find((entry) => entry.input);
+        if (typed)
+            return { value: typed.value, text: answer };
+        throw new Error(`no option "${answer}" for: ${question}`);
+    }
     async secret(question) {
         return this.answer(question);
     }

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. */
@@ -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.

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "directionallylocal",
-  "version": "0.4.0",
+  "version": "0.5.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",
   "repository": {
     "type": "git",
@@ -34,5 +35,8 @@
     "@types/node": "^22.10.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "autopilot-ai": "^2.7.0"
   }
 }