directionallylocal 0.4.1 → 0.6.0

package/dist/cli.js

@@ -7,6 +7,8 @@ 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";
 import { setUpOnThisComputer } from "./local/setup.js";
@@ -23,6 +25,9 @@ Send a task; it runs in its own sandbox and comes back as a pull request.
 On your laptop:
   dl                      set up the first time; afterwards, an overview
   dl setup                set up or repair where your agents run (safe to re-run)
+  dl  (in a GitHub repo)  talk to the repository's agent; it keeps running when you leave
+  dl new                  in a GitHub repo: start a fresh conversation for it
+  dl status               where your agents run and what they're doing (works anywhere)
   dl connect URL          connect to a server someone else set up (approve the code it shows)
   dl run "TASK"           run a task, from inside a GitHub repository
                           (your uncommitted changes go along; Ctrl-C stops watching, not the task)
@@ -32,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)
@@ -206,8 +212,15 @@ export async function main(argv, io = {
                 if (!state) {
                     if (values.brief)
                         return 0;
-                    // A laptop connected to servers gets its own home; otherwise, what this is and how to start.
-                    if (!command && await laptopHome(laptopIO))
+                    // Inside a GitHub repository, that repository's conversation; elsewhere, the laptop's home.
+                    if (!command && terminal && (await loadRemotes()).length > 0) {
+                        const code = await projectSession({ cwd: process.cwd(), ...(values.server ? { server: values.server } : {}), ...(values.model ? { model: values.model } : {}) }, laptopIO);
+                        if (code !== undefined)
+                            return code;
+                    }
+                    // A laptop connected to servers gets its own home (`dl status` shows it from anywhere);
+                    // otherwise, what this is and how to start.
+                    if ((!command || command === "status") && await laptopHome(laptopIO))
                         return 0;
                     // A laptop with nothing set up yet: the wizard (it needs someone to answer it).
                     if (!command && terminal && !isRoot() && (await loadRemotes()).length === 0)
@@ -271,10 +284,19 @@ export async function main(argv, io = {
                     await pull({ id, cwd: process.cwd(), ...server }, laptopIO);
                 return 0;
             }
+            case "new": {
+                const code = await projectSession({ cwd: process.cwd(), fresh: true, ...(values.server ? { server: values.server } : {}), ...(values.model ? { model: values.model } : {}) }, laptopIO);
+                if (code !== undefined)
+                    return code;
+                io.err(`  dl new starts a fresh conversation from inside a GitHub repository (with something set up: dl setup).\n`);
+                return 1;
+            }
             case "servers":
                 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,12 +276,14 @@ 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("Send a task, from inside a GitHub repository:")}\n     ${c.bold('dl run "fix the flaky checkout test"')}\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;
 }
 async function follow(client, remote, conversationId, cursor, signal, io, replayUntil) {
@@ -401,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).
  */
@@ -418,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/credentials.js

@@ -45,14 +45,14 @@ export async function gatherKeys(needs, input) {
     const wanted = needs.filter((need) => need === "github" || need === "openrouter");
     if (wanted.length === 0)
         return answers;
-    ui.questions(`${wanted.length === 1 ? "1 key" : "2 keys"}, kept on your server only; then it sets itself up.`);
+    ui.questions(`${wanted.length === 1 ? "1 key" : "2 keys"}, kept on ${input.place ?? "your server"} only; then it sets itself up.`);
     if (wanted.includes("github"))
         answers.githubToken = await githubToken(input);
     if (wanted.includes("openrouter"))
         answers.openrouterKey = await openrouterKey(input);
     return answers;
 }
-export async function githubToken({ ui, prompter, sources }) {
+export async function githubToken({ ui, prompter, sources, place = "your server" }) {
     const fromCli = (await sources.gh().catch(() => undefined))?.trim();
     if (fromCli) {
         const checked = await validateGitHubToken(fromCli, sources.fetch);
@@ -61,7 +61,7 @@ export async function githubToken({ ui, prompter, sources }) {
         }
         else {
             const who = checked.login ? ` (${checked.login})` : "";
-            if (await confirm(ui, prompter, `Use your GitHub CLI login${who}? It stays on your server.`)) {
+            if (await confirm(ui, prompter, `Use your GitHub CLI login${who}? It stays on ${place}.`)) {
                 ui.answered("GitHub", `${checked.login ? `signed in as ${checked.login} · ` : ""}from the GitHub CLI`);
                 return fromCli;
             }
@@ -73,7 +73,7 @@ export async function githubToken({ ui, prompter, sources }) {
         return { value: token, ...(checked.problem ? { problem: checked.problem } : {}), ...(checked.login ? { detail: `signed in as ${checked.login}` } : {}) };
     });
 }
-export async function openrouterKey({ ui, prompter, sources }) {
+export async function openrouterKey({ ui, prompter, sources, place = "your server" }) {
     const candidates = [];
     const fromEnv = sources.env.OPENROUTER_API_KEY?.trim();
     if (fromEnv)
@@ -88,7 +88,7 @@ export async function openrouterKey({ ui, prompter, sources }) {
             ui.warn(`The OpenRouter key ${candidate.from} didn't work (${problem})`);
             continue;
         }
-        if (await confirm(ui, prompter, `${candidate.question} It stays on your server.`)) {
+        if (await confirm(ui, prompter, `${candidate.question} It stays on ${place}.`)) {
             ui.answered("OpenRouter", candidate.from);
             return candidate.key;
         }

package/dist/laptop/session-store.js

@@ -0,0 +1,62 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function sessionsPath(env = process.env) {
+    const configHome = env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(configHome, "directionallylocal", "sessions.json");
+}
+export async function loadSessions(path = sessionsPath()) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed.sessions) ? parsed.sessions.filter(isEntry) : [];
+    }
+    catch {
+        // A damaged file only costs a new conversation; it gets rewritten on the next save.
+        return [];
+    }
+}
+export async function findSession(key, path = sessionsPath()) {
+    return (await loadSessions(path)).find((entry) => sameKey(entry, key));
+}
+/** Remembers (or replaces) the conversation for this place + repository + checkout. */
+export async function rememberSession(entry, path = sessionsPath()) {
+    const kept = (await loadSessions(path)).filter((existing) => !sameKey(existing, entry));
+    kept.push({ ...entry, updatedAt: new Date().toISOString() });
+    await writeSessions(kept, path);
+}
+/** Forgets this key's conversation (it keeps running on the place); true when there was one. */
+export async function forgetSession(key, path = sessionsPath()) {
+    const sessions = await loadSessions(path);
+    const kept = sessions.filter((entry) => !sameKey(entry, key));
+    if (kept.length === sessions.length)
+        return false;
+    await writeSessions(kept, path);
+    return true;
+}
+function sameKey(a, b) {
+    return a.place === b.place && a.repository === b.repository && a.root === b.root;
+}
+async function writeSessions(sessions, path) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${process.pid}.tmp`;
+    const body = { version: 1, sessions };
+    await writeFile(temp, `${JSON.stringify(body, null, 2)}\n`, { mode: 0o600 });
+    await chmod(temp, 0o600);
+    await rename(temp, path);
+}
+function isEntry(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return ["place", "repository", "root", "conversationId", "updatedAt"].every((key) => typeof entry[key] === "string") &&
+        (entry.branch === undefined || typeof entry.branch === "string");
+}

package/dist/laptop/session.js

@@ -0,0 +1,280 @@
+import { execFile, spawn } from "node:child_process";
+import { constants, existsSync, readFileSync } from "node:fs";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, delimiter, dirname, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { palette } from "../ui.js";
+import { RemoteApiError } from "./client.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";
+import { openRemoteForSession, withConnections } from "./tunnel.js";
+/**
+ * `dl` inside a project: Autopilot's own interactive screen, attached to this repository's
+ * conversation on the place agents run (`autopilot attach-remote`). The first time it starts
+ * one from this checkout (base commit + uncommitted changes, as `dl run` sends them); after
+ * that it reopens the same one. dl only finds the conversation, holds the SSH tunnel open,
+ * and gets out of the way: Autopilot owns the terminal until the user detaches.
+ */
+const execFileAsync = promisify(execFile);
+const realSpawn = (command, args, env) => spawn(command, args, { stdio: "inherit", env });
+const FORWARDED = ["SIGINT", "SIGTERM", "SIGHUP"];
+const UPDATE = "npm install -g directionallylocal";
+class Interrupted extends Error {
+}
+/**
+ * Opens the session, or returns undefined when this isn't a project dl can open one for
+ * (not a Git repository, origin not on GitHub, nothing pushed yet, or no place to pick),
+ * after a one-line note for the last three, so the caller shows the overview instead.
+ */
+export async function projectSession(input, io) {
+    const c = palette(io.color === true);
+    const note = (text) => io.err(`  ${c.yellow("!")} ${text}\n`);
+    const root = await gitRoot(input.cwd);
+    if (!root)
+        return undefined;
+    let repository;
+    try {
+        repository = await detectGitHubRepository(root);
+    }
+    catch {
+        note(`${basename(root)}'s origin isn't on GitHub, so there's no agent conversation to open here.`);
+        return undefined;
+    }
+    let target;
+    try {
+        target = await resolveTarget(input.server);
+    }
+    catch (error) {
+        if (input.server !== undefined)
+            throw error;
+        note(describeError(error));
+        return undefined;
+    }
+    const { remote } = target;
+    const key = { place: remote.name, repository, root };
+    const file = input.sessionsFile ?? sessionsPath();
+    const autopilot = await (input.autopilot ?? findAutopilot)();
+    // Asked while the tunnel opens; it only matters right before launching.
+    const ready = autopilot ? (input.probe ?? supportsAttachRemote)(autopilot).catch(() => false) : Promise.resolve(false);
+    const missing = () => {
+        io.err(`  ${c.red("✗")} The Autopilot that comes with dl ${autopilot ? "is too old to open a session" : "isn't installed"}. Update: ${c.bold(UPDATE)}\n`);
+        return 1;
+    };
+    // Ctrl-C (or a hang-up) before Autopilot starts stops dl, closing the tunnel on the way out;
+    // once it runs, Autopilot handles Ctrl-C itself and dl only passes on SIGTERM/SIGHUP.
+    const signals = input.signals ?? process;
+    let child;
+    let interrupt = () => { };
+    const interrupted = new Promise((_, reject) => { interrupt = () => reject(new Interrupted()); });
+    interrupted.catch(() => { });
+    const handlers = FORWARDED.map((name) => {
+        const handler = () => {
+            if (!child)
+                interrupt();
+            else if (name !== "SIGINT")
+                child.kill(name);
+        };
+        signals.on(name, handler);
+        return [name, handler];
+    });
+    const step = (work) => Promise.race([work, interrupted]);
+    try {
+        return await withConnections(input.open ?? openRemoteForSession, async (connections) => {
+            const client = await step(connections.client(remote));
+            let remembered = input.fresh ? undefined : await findSession(key, file);
+            if (remembered) {
+                const alive = await step(client.getConversation(remembered.conversationId).then((conversation) => conversation.status !== "destroyed", (error) => {
+                    if (error instanceof RemoteApiError && (error.status === 404 || error.status === 410))
+                        return false;
+                    throw error;
+                }));
+                if (!alive) {
+                    await forgetSession(key, file);
+                    note(`The last conversation for ${repository} on ${remote.name} is gone; starting a new one.`);
+                    remembered = undefined;
+                }
+            }
+            const scratch = await mkdtemp(join(tmpdir(), "dl-session-"));
+            try {
+                const stateFile = join(scratch, "state.json");
+                const args = ["attach-remote", "--state-file", stateFile, "--title", `${remote.name} · ${repository}`];
+                let detail;
+                if (remembered) {
+                    args.push("--conversation", remembered.conversationId);
+                    detail = remembered.conversationId.slice(0, 8);
+                }
+                else {
+                    let snapshot;
+                    try {
+                        snapshot = await step(snapshotWorkingTree(root));
+                    }
+                    catch (error) {
+                        if (error instanceof Interrupted)
+                            throw error;
+                        note(`${describeError(error)}.`.replace(/\.\.$/, "."));
+                        return undefined;
+                    }
+                    const [workspaces, models, preferred] = await step(Promise.all([
+                        client.workspaces(),
+                        client.models(),
+                        input.model ? Promise.resolve(undefined) : (input.autopilotModel ?? laptopModel)(),
+                    ]));
+                    const workspace = workspaces[0];
+                    if (!workspace)
+                        throw new Error(`${remote.name} has no workspace this laptop can use`);
+                    const model = pickModel(models, input.model, preferred);
+                    args.push("--workspace", workspace.id, "--repo", repository, "--model", model, "--base-commit", snapshot.baseCommit);
+                    if (snapshot.patch) {
+                        const patchFile = join(scratch, "changes.patch");
+                        await writeFile(patchFile, snapshot.patch, { mode: 0o600 });
+                        args.push("--patch-file", patchFile);
+                    }
+                    const changes = snapshot.files.length ? ` + ${snapshot.files.length} local change${snapshot.files.length === 1 ? "" : "s"}` : "";
+                    detail = `new conversation from ${snapshot.baseCommit.slice(0, 7)}${changes}, ${model}`;
+                }
+                if (!autopilot || !(await step(ready)))
+                    return missing();
+                // `dl new`: the old conversation keeps running on the place (dl runs lists it).
+                if (input.fresh)
+                    await forgetSession(key, file);
+                io.err(`\n  ${c.cyan("·")} Connecting to ${c.bold(remote.name)} · ${repository} …  ${c.dim(`(${detail})`)}\n`);
+                // The token goes in the environment only: argv is visible to every user on the machine.
+                const env = { ...process.env, AUTOPILOT_REMOTE_URL: client.baseUrl, AUTOPILOT_REMOTE_TOKEN: remote.token };
+                let saved = remembered?.conversationId;
+                const save = async () => {
+                    const state = await readState(stateFile);
+                    if (!state || state.conversationId === saved)
+                        return;
+                    saved = state.conversationId;
+                    await rememberSession({ ...key, conversationId: state.conversationId, ...(state.branch ? { branch: state.branch } : {}) }, file);
+                };
+                // Remember it as soon as it exists, so a closed terminal doesn't lose it.
+                const poll = setInterval(() => { void save().catch(() => { }); }, 500);
+                poll.unref?.();
+                const outcome = await new Promise((resolve) => {
+                    const started = (input.spawn ?? realSpawn)(autopilot.command, [...autopilot.args, ...args], env);
+                    child = started;
+                    started.on("exit", (code) => resolve({ code }));
+                    started.on("error", (error) => resolve(error));
+                }).finally(() => clearInterval(poll));
+                await save().catch(() => { });
+                if (outcome instanceof Error)
+                    return missing();
+                if (outcome.code === 2)
+                    return missing();
+                if (outcome.code !== 0)
+                    return 1;
+                await recordLastUsed(remote.name).catch(() => undefined);
+                io.err(`\n  It keeps running on ${c.bold(remote.name)}. Type ${c.bold("dl")} here to come back, or ${c.bold("dl runs")}.\n\n`);
+                return 0;
+            }
+            finally {
+                await rm(scratch, { recursive: true, force: true });
+            }
+        });
+    }
+    catch (error) {
+        if (!(error instanceof Interrupted))
+            throw error;
+        io.err("\n");
+        return 130;
+    }
+    finally {
+        for (const [name, handler] of handlers)
+            signals.off(name, handler);
+    }
+}
+/** What `attach-remote --state-file` wrote, once the conversation exists. */
+async function readState(path) {
+    const raw = await readFile(path, "utf8").catch(() => undefined);
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.conversationId !== "string" || !parsed.conversationId)
+            return undefined;
+        return { conversationId: parsed.conversationId, ...(typeof parsed.branch === "string" && parsed.branch ? { branch: parsed.branch } : {}) };
+    }
+    catch {
+        return undefined; // still being written
+    }
+}
+async function gitRoot(cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The Autopilot installed with dl (run with this Node), else an `autopilot` on PATH. */
+export async function findAutopilot() {
+    const bundled = bundledAutopilot();
+    if (bundled)
+        return { command: process.execPath, args: [bundled] };
+    const onPath = await autopilotOnPath();
+    return onPath ? { command: onPath, args: [] } : undefined;
+}
+/**
+ * autopilot-ai's bin script, found from where Node resolves the package for dl. Its exports
+ * don't include package.json, so the entry point is resolved and its package root found above it.
+ */
+export function bundledAutopilot(resolve = (specifier) => import.meta.resolve(specifier)) {
+    for (const specifier of ["autopilot-ai/package.json", "autopilot-ai"]) {
+        let dir;
+        try {
+            dir = dirname(fileURLToPath(resolve(specifier)));
+        }
+        catch {
+            continue;
+        }
+        for (;;) {
+            const manifest = join(dir, "package.json");
+            if (existsSync(manifest)) {
+                try {
+                    const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+                    if (pkg.name === "autopilot-ai") {
+                        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.autopilot;
+                        const path = typeof bin === "string" ? resolvePath(dir, bin) : undefined;
+                        return path && existsSync(path) ? path : undefined;
+                    }
+                }
+                catch {
+                    // not a readable manifest; keep looking up
+                }
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return undefined;
+}
+export async function autopilotOnPath(env = process.env) {
+    for (const dir of (env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        const candidate = join(dir, "autopilot");
+        if (await access(candidate, constants.X_OK).then(() => true, () => false))
+            return candidate;
+    }
+    return undefined;
+}
+/** An Autopilot that knows `attach-remote` lists its options (an older one prints its general help). */
+export async function supportsAttachRemote(autopilot) {
+    try {
+        const { stdout, stderr } = await execFileAsync(autopilot.command, [...autopilot.args, "attach-remote", "--help"], {
+            timeout: 30_000,
+            env: { ...process.env, NO_COLOR: "1" },
+        });
+        return `${stdout}${stderr}`.includes("--state-file");
+    }
+    catch {
+        return false;
+    }
+}