directionallylocal 0.0.0-stage → 0.1.2

package/dist/laptop/client.js

@@ -0,0 +1,223 @@
+/**
+ * Client for a paired server's Aster API (/api/v1). Same contract the iOS app and a
+ * future desktop app use: device pairing, code conversations as runs, resumable SSE.
+ */
+export const TERMINAL_STATUSES = new Set(["completed", "failed", "cancelled", "interrupted", "merged", "destroyed"]);
+export class RemoteApiError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "RemoteApiError";
+    }
+}
+export class RemoteClient {
+    baseUrl;
+    token;
+    fetchImpl;
+    constructor(baseUrl, token, fetchImpl = fetch) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.fetchImpl = fetchImpl;
+    }
+    startDeviceAuthorization(clientName) {
+        return this.request("POST", "/auth/device", { body: { clientName }, auth: false });
+    }
+    /** Polls until the owner decides; resolves with the credential, rejects on denial or expiry. */
+    async waitForCredential(device, options = {}) {
+        const sleep = options.sleep ?? ((ms) => delay(ms, options.signal));
+        let intervalMs = Math.max(1, device.interval) * 1000;
+        const deadline = Date.now() + device.expiresIn * 1000;
+        while (Date.now() < deadline) {
+            await sleep(intervalMs);
+            try {
+                return await this.request("POST", "/auth/device/token", { body: { deviceCode: device.deviceCode }, auth: false, signal: options.signal });
+            }
+            catch (error) {
+                if (!(error instanceof RemoteApiError))
+                    throw error;
+                if (error.code === "authorization_pending")
+                    continue;
+                if (error.code === "slow_down") {
+                    intervalMs += 5_000;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new RemoteApiError(400, "expired_token", "The pairing code expired before it was approved; run the command again");
+    }
+    health() {
+        return this.request("GET", "/health");
+    }
+    async workspaces() {
+        return (await this.request("GET", "/workspaces")).workspaces;
+    }
+    async models() {
+        return (await this.request("GET", "/models")).models;
+    }
+    createCodeConversation(input) {
+        const { idempotencyKey, ...body } = input;
+        return this.withRetries(() => this.request("POST", "/conversations", {
+            body: { ...body, kind: "code" },
+            headers: { "Idempotency-Key": idempotencyKey },
+        }));
+    }
+    submitTurn(conversationId, text, clientTurnId) {
+        return this.withRetries(() => this.request("POST", `/conversations/${encodeURIComponent(conversationId)}/turns`, { body: { clientTurnId, text } }));
+    }
+    getConversation(conversationId) {
+        return this.request("GET", `/conversations/${encodeURIComponent(conversationId)}`);
+    }
+    async listConversations(limit = 50) {
+        return (await this.request("GET", `/conversations?limit=${limit}`)).conversations;
+    }
+    cancel(conversationId) {
+        return this.request("POST", `/conversations/${encodeURIComponent(conversationId)}/cancel`);
+    }
+    /**
+     * Events after `cursor`, reconnecting with the last seen ID when the stream drops,
+     * until the caller stops iterating or the signal aborts.
+     */
+    async *events(conversationId, cursor, signal) {
+        let last = cursor;
+        let failures = 0;
+        while (!signal?.aborted) {
+            try {
+                const response = await this.fetchImpl(this.url(`/conversations/${encodeURIComponent(conversationId)}/events`), {
+                    headers: { ...this.authHeaders(), Accept: "text/event-stream", "Last-Event-ID": String(last) },
+                    signal,
+                });
+                if (!response.ok || !response.body)
+                    throw await toApiError(response);
+                failures = 0;
+                for await (const event of parseEventStream(response.body)) {
+                    if (event.id <= last)
+                        continue;
+                    last = event.id;
+                    yield event;
+                }
+            }
+            catch (error) {
+                if (signal?.aborted)
+                    return;
+                if (error instanceof RemoteApiError && error.status < 500)
+                    throw error;
+                if (++failures > 30)
+                    throw error;
+            }
+            await delay(Math.min(1_000 * failures, 10_000), signal).catch(() => { });
+        }
+    }
+    async request(method, path, options = {}) {
+        const response = await this.fetchImpl(this.url(path), {
+            method,
+            headers: {
+                ...(options.auth === false ? {} : this.authHeaders()),
+                ...(options.body === undefined ? {} : { "Content-Type": "application/json" }),
+                ...options.headers,
+            },
+            ...(options.body === undefined ? {} : { body: JSON.stringify(options.body) }),
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (!response.ok)
+            throw await toApiError(response);
+        return await response.json();
+    }
+    /** Retries network failures and 5xx; safe only for requests carrying an idempotency key. */
+    async withRetries(attempt) {
+        for (let tries = 1;; tries++) {
+            try {
+                return await attempt();
+            }
+            catch (error) {
+                const retryable = !(error instanceof RemoteApiError) || error.status >= 500;
+                if (!retryable || tries >= 3)
+                    throw error;
+                await delay(1_000 * tries);
+            }
+        }
+    }
+    url(path) {
+        return `${this.baseUrl}/api/v1${path}`;
+    }
+    authHeaders() {
+        return this.token ? { Authorization: `Bearer ${this.token}` } : {};
+    }
+}
+/** Minimal text/event-stream parser for the server's `id:`/`event:`/`data:` frames. */
+export async function* parseEventStream(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for await (const chunk of body) {
+        buffer += decoder.decode(chunk, { stream: true }).replace(/\r\n/g, "\n");
+        let boundary;
+        while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+            const frame = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const event = parseFrame(frame);
+            if (event)
+                yield event;
+        }
+    }
+}
+function parseFrame(frame) {
+    let id;
+    let type = "message";
+    const data = [];
+    for (const line of frame.split("\n")) {
+        if (!line || line.startsWith(":"))
+            continue;
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        const value = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "id" && /^\d+$/.test(value))
+            id = Number(value);
+        else if (field === "event")
+            type = value;
+        else if (field === "data")
+            data.push(value);
+    }
+    if (id === undefined)
+        return undefined;
+    let parsed = {};
+    try {
+        parsed = data.length ? JSON.parse(data.join("\n")) : {};
+    }
+    catch {
+        return undefined;
+    }
+    return { id, type, data: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {} };
+}
+async function toApiError(response) {
+    let code = `http_${response.status}`;
+    let message = `Server returned ${response.status}`;
+    try {
+        const body = await response.json();
+        if (body.error?.code)
+            code = body.error.code;
+        if (body.error?.message)
+            message = body.error.message;
+    }
+    catch {
+        // not a JSON error body
+    }
+    return new RemoteApiError(response.status, code, message);
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted)
+            return reject(signal.reason);
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/laptop/commands.js

@@ -0,0 +1,335 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { hostname } from "node:os";
+import { promisify } from "node:util";
+import { palette } from "../ui.js";
+import { RemoteApiError, RemoteClient, TERMINAL_STATUSES } from "./client.js";
+import { defaultRemoteName, loadRemotes, normalizeServerUrl, REMOTE_NAME_RE, removeRemote, resolveRemote, saveRemote } from "./config.js";
+import { detectGitHubRepository, snapshotWorkingTree } from "./git.js";
+import { openBrowser } from "./open-browser.js";
+/**
+ * `dl` on a laptop: connect to a server, send it tasks, follow them, and check out the
+ * pull requests. It talks to the server's API directly (the same one Autopilot's
+ * `--on` uses, and shares its list of servers), so the laptop needs nothing else.
+ */
+const execFileAsync = promisify(execFile);
+const RUN_END_EVENTS = new Set(["completed", "failed", "cancelled", "interrupted"]);
+const processIO = {
+    out: (text) => process.stdout.write(text),
+    err: (text) => process.stderr.write(text),
+    color: process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== "dumb",
+};
+/** `dl connect <url>`: pair this laptop with a server. No keys are copied. */
+export async function connect(input, io = processIO) {
+    const c = palette(io.color === true);
+    const url = normalizeServerUrl(input.url);
+    const name = input.name ?? defaultRemoteName(url);
+    if (!REMOTE_NAME_RE.test(name))
+        throw new Error("Server names are 1-40 lowercase letters, digits, or dashes");
+    const anonymous = new RemoteClient(url, undefined);
+    const device = await anonymous.startDeviceAuthorization(clientName());
+    io.out(`\n  ${c.bold("Connect this laptop")} ${c.dim(`to ${url}`)}\n\n`);
+    io.out(`  Approve code ${c.bold(device.userCode)} in the browser you approve laptops with:\n     ${device.verificationUriComplete}\n`);
+    if (input.open !== false && openBrowser(device.verificationUriComplete))
+        io.out(`     ${c.dim("(opened it for you)")}\n`);
+    io.out(`  ${c.dim(`Or on the server: dl connect-laptop ${device.userCode}`)}\n\n  ${c.cyan("·")} Waiting for approval…\n`);
+    const credential = await anonymous.waitForCredential(device, {
+        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.sleep ? { sleep: input.sleep } : {}),
+    });
+    const remote = {
+        name,
+        url,
+        token: credential.token,
+        credentialId: credential.credentialId,
+        expiresAt: credential.expiresAt,
+        addedAt: new Date().toISOString(),
+    };
+    await new RemoteClient(url, remote.token).health();
+    await saveRemote(remote);
+    io.out(`${rewrite(io)}  ${c.green("✓")} Connected as ${c.bold(name)}  ${c.dim(`until ${remote.expiresAt.slice(0, 10)}`)}\n\n`);
+    io.out(`  ${c.dim("Next, from inside a GitHub repository:")}\n     ${c.bold('dl run "fix the flaky checkout test"')}\n\n`);
+    return remote;
+}
+/**
+ * `dl run "task"`: the task runs in its own sandbox on the server, starting from this
+ * checkout (uncommitted changes go along). Follows it until it ends; Ctrl-C only detaches.
+ */
+export async function run(input, io = processIO) {
+    const c = palette(io.color === true);
+    const remote = await resolveRemote(input.server);
+    const client = new RemoteClient(remote.url, remote.token);
+    const repository = input.repository ?? await detectGitHubRepository(input.cwd);
+    const snapshot = await snapshotWorkingTree(input.cwd);
+    const [workspaces, models] = await Promise.all([client.workspaces(), client.models()]);
+    const workspace = workspaces[0];
+    if (!workspace)
+        throw new Error(`${remote.name} has no workspace this laptop can use`);
+    const model = pickModel(models, input.model, input.preferredModel);
+    const changes = snapshot.files.length ? ` + ${snapshot.files.length} local change${snapshot.files.length === 1 ? "" : "s"}` : "";
+    io.err(`\n  ${c.cyan("·")} Sending to ${c.bold(remote.name)}: ${repository} at ${snapshot.baseCommit.slice(0, 7)}${changes}  ${c.dim(model)}\n`);
+    const conversation = await client.createCodeConversation({
+        workspaceId: workspace.id,
+        model,
+        repository,
+        baseCommit: snapshot.baseCommit,
+        ...(snapshot.patch ? { patch: snapshot.patch } : {}),
+        idempotencyKey: `dl-${randomUUID()}`,
+    });
+    await client.submitTurn(conversation.conversationId, input.task, `dl-${randomUUID()}`);
+    const id = conversation.conversationId.slice(0, 8);
+    io.err(`${rewrite(io)}  ${c.green("✓")} Started ${c.bold(id)} on ${remote.name}  ${c.dim(`branch ${conversation.branch ?? "?"}`)}\n`);
+    if (input.detach) {
+        io.err(`\n  ${c.dim("It runs on its own. Follow it:")} dl watch ${id}\n\n`);
+        return 0;
+    }
+    io.err(`  ${c.dim(`Ctrl-C stops watching; the task keeps running (dl watch ${id}).`)}\n\n`);
+    return follow(client, remote, conversation.conversationId, conversation.lastEventId, input.signal, io);
+}
+/** `dl runs`: tasks on every connected server, newest first. */
+export async function runs(input, io = processIO) {
+    const c = palette(io.color === true);
+    const remotes = input.server ? [await resolveRemote(input.server)] : await loadRemotes();
+    if (remotes.length === 0)
+        throw new Error("This laptop isn't connected to a server yet. Run: dl connect https://your-server");
+    const rows = [];
+    for (const remote of remotes) {
+        try {
+            const list = await new RemoteClient(remote.url, remote.token).listConversations();
+            rows.push(...list.filter((entry) => entry.kind === "code").map((entry) => ({ ...entry, server: remote.name })));
+        }
+        catch (error) {
+            io.err(`  ${c.red("✗")} ${remote.name}: ${describeError(error)}\n`);
+        }
+    }
+    rows.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    if (input.json) {
+        io.out(`${JSON.stringify(rows, null, 2)}\n`);
+        return;
+    }
+    if (rows.length === 0) {
+        io.out(`\n  No tasks yet. From inside a GitHub repository:  ${c.bold('dl run "fix the flaky checkout test"')}\n\n`);
+        return;
+    }
+    io.out("\n");
+    for (const entry of rows) {
+        const running = entry.activeRunId !== null;
+        const glyph = running ? c.cyan("◐") : entry.status === "completed" || entry.status === "merged" ? c.green("✓") : ["failed", "interrupted"].includes(entry.status) ? c.red("✗") : c.dim("○");
+        const multi = remotes.length > 1 ? `${entry.server}  ` : "";
+        io.out(`  ${glyph} ${entry.conversationId.slice(0, 8)}  ${multi}${(running ? "running" : entry.status).padEnd(11)} ${(entry.repository ?? "").padEnd(26)} ${c.dim(entry.pullRequestURL ?? entry.branch ?? "")}\n`);
+    }
+    io.out(`\n  ${c.dim("Follow one:")} dl watch <id>   ${c.dim("Check one out:")} dl pull <id>\n\n`);
+}
+/** `dl watch <id>`: replay and follow a task's output. */
+export async function watch(input, io = processIO) {
+    const { remote, run: found } = await findRun(input.id, input.server);
+    const client = new RemoteClient(remote.url, remote.token);
+    const finished = TERMINAL_STATUSES.has(found.status) && !found.activeRunId;
+    return follow(client, remote, found.conversationId, 0, input.signal, io, finished ? found.lastEventId : undefined);
+}
+export async function cancel(input, io = processIO) {
+    const c = palette(io.color === true);
+    const { remote, run: found } = await findRun(input.id, input.server);
+    await new RemoteClient(remote.url, remote.token).cancel(found.conversationId);
+    io.out(`  ${c.green("✓")} Stopped ${found.conversationId.slice(0, 8)}\n`);
+}
+/** `dl pull <id>`: check out a task's branch here. */
+export async function pull(input, io = processIO) {
+    const c = palette(io.color === true);
+    const { run: found } = await findRun(input.id, input.server);
+    const branch = found.branch;
+    if (!branch)
+        throw new Error("That task has no branch");
+    if (found.activeRunId)
+        io.err(`  ${c.yellow("!")} It's still running; you'll get what it has pushed so far.\n`);
+    const git = (args) => execFileAsync("git", ["-C", input.cwd, ...args]);
+    try {
+        await git(["fetch", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+    }
+    catch {
+        throw new Error(`Branch ${branch} isn't on GitHub yet (a task pushes it when it finishes a step)`);
+    }
+    const exists = await git(["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`]).then(() => true, () => false);
+    if (exists) {
+        await git(["switch", branch]);
+        await git(["merge", "--ff-only", `origin/${branch}`]);
+    }
+    else {
+        await git(["switch", "-c", branch, "--track", `origin/${branch}`]);
+    }
+    io.out(`  ${c.green("✓")} On ${c.bold(branch)}${found.pullRequestURL ? `  ${c.dim(found.pullRequestURL)}` : ""}\n`);
+}
+/** `dl servers [remove NAME]`: the servers this laptop is connected to. */
+export async function servers(args, io = processIO) {
+    const c = palette(io.color === true);
+    if (args[0] === "remove") {
+        const name = args[1] ?? "";
+        if (!(await removeRemote(name))) {
+            io.err(`  ${c.red("✗")} Not connected to "${name}".\n`);
+            return 1;
+        }
+        io.out(`  ${c.green("✓")} Forgot ${name}. To disconnect it on the server too: sudo dl laptops remove "${clientName()}"\n`);
+        return 0;
+    }
+    const remotes = await loadRemotes();
+    if (remotes.length === 0) {
+        io.out(`\n  Not connected to a server yet.  ${c.bold("dl connect https://your-server")}\n\n`);
+        return 0;
+    }
+    io.out("\n");
+    for (const remote of remotes)
+        io.out(`  ${c.green("●")} ${remote.name.padEnd(16)} ${remote.url}  ${c.dim(`until ${remote.expiresAt.slice(0, 10)}`)}\n`);
+    io.out("\n");
+    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) {
+    const c = palette(io.color === true);
+    const remotes = await loadRemotes();
+    if (remotes.length === 0)
+        return false;
+    let running = 0;
+    let total = 0;
+    for (const remote of remotes) {
+        const list = await new RemoteClient(remote.url, remote.token).listConversations().catch(() => undefined);
+        running += list?.filter((entry) => entry.activeRunId !== null).length ?? 0;
+        total += list?.length ?? 0;
+    }
+    io.out(`\n  ${c.bold("Directionally Local")}  ${c.dim("on this laptop")}\n\n`);
+    io.out("  Background coding agents on your own server: send a task, get a pull request back.\n\n");
+    io.out(`  ${c.dim("Servers".padEnd(11))}${remotes.map((remote) => `${remote.name} ${c.dim(remote.url)}`).join(", ")}   ${c.dim("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`);
+    return true;
+}
+async function follow(client, remote, conversationId, cursor, signal, io, replayUntil) {
+    const c = palette(io.color === true);
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    signal?.addEventListener("abort", stop, { once: true });
+    const renderer = new EventRenderer(io, c);
+    let outcome;
+    try {
+        if (replayUntil === undefined || replayUntil > cursor) {
+            for await (const event of client.events(conversationId, cursor, controller.signal)) {
+                renderer.render(event);
+                if (RUN_END_EVENTS.has(event.type))
+                    outcome = event.type;
+                if (replayUntil === undefined ? RUN_END_EVENTS.has(event.type) : event.id >= replayUntil)
+                    break;
+            }
+        }
+        if (replayUntil !== undefined && !controller.signal.aborted)
+            outcome ??= "completed";
+    }
+    finally {
+        signal?.removeEventListener("abort", stop);
+        controller.abort();
+    }
+    renderer.finish();
+    const id = conversationId.slice(0, 8);
+    if (!outcome) {
+        io.err(`\n  ${c.dim(`Stopped watching ${id}; it keeps running on ${remote.name}.`)} dl watch ${id}\n`);
+        return 0;
+    }
+    const final = await client.getConversation(conversationId);
+    if (outcome === "completed") {
+        io.err(`\n  ${c.green("✓")} ${c.bold(id)} done${final.pullRequestURL ? `  ${final.pullRequestURL}` : c.dim("  (no changes, so no pull request)")}\n`);
+        if (final.pullRequestURL)
+            io.err(`  ${c.dim("Check it out here:")} dl pull ${id}\n`);
+        io.err("\n");
+        return 0;
+    }
+    io.err(`\n  ${c.red("✗")} ${id} ${outcome}\n\n`);
+    return 1;
+}
+/** Writes the agent's text as it streams and one line per tool call. */
+class EventRenderer {
+    io;
+    c;
+    midLine = false;
+    constructor(io, c) {
+        this.io = io;
+        this.c = c;
+    }
+    render(event) {
+        const data = event.data;
+        if (event.type === "assistant.delta") {
+            const text = typeof data.text === "string" ? data.text : typeof data.delta === "string" ? data.delta : "";
+            if (!text)
+                return;
+            this.io.out(text);
+            this.midLine = !text.endsWith("\n");
+            return;
+        }
+        if (event.type === "tool.activity" && data.activity === "started") {
+            const input = typeof data.input === "string" ? ` ${oneLine(data.input, 110)}` : "";
+            this.line(`  ${this.c.dim(`› ${String(data.tool ?? "tool")}${input}`)}`);
+            return;
+        }
+        if (event.type === "tool.activity" && data.activity === "failed") {
+            this.line(`  ${this.c.red(`✗ ${String(data.tool ?? "tool")} failed`)}`);
+            return;
+        }
+        if (event.type === "checkpoint.created" && typeof data.message === "string") {
+            this.line(`  ${this.c.dim(`● ${oneLine(data.message, 100)}`)}`);
+        }
+    }
+    finish() {
+        if (this.midLine)
+            this.io.out("\n");
+        this.midLine = false;
+    }
+    line(text) {
+        this.finish();
+        this.io.out(`${text}\n`);
+    }
+}
+async function findRun(id, server) {
+    const needle = id.trim().toLowerCase();
+    if (!/^[0-9a-f-]{4,36}$/.test(needle))
+        throw new Error("Task IDs are the short hex IDs dl runs shows");
+    const remotes = server ? [await resolveRemote(server)] : await loadRemotes();
+    const matches = [];
+    for (const remote of remotes) {
+        const list = await new RemoteClient(remote.url, remote.token).listConversations(200).catch(() => []);
+        for (const entry of list)
+            if (entry.conversationId.startsWith(needle))
+                matches.push({ remote, run: entry });
+    }
+    if (matches.length === 0)
+        throw new Error(`No task ${id} on ${server ?? "any connected server"}`);
+    if (matches.length > 1)
+        throw new Error(`${id} matches several tasks; use more characters`);
+    return matches[0];
+}
+function pickModel(models, requested, preferred) {
+    if (requested) {
+        if (!models.includes(requested))
+            throw new Error(`The server doesn't offer ${requested}`);
+        return requested;
+    }
+    if (preferred && models.includes(preferred))
+        return preferred;
+    const first = models[0];
+    if (!first)
+        throw new Error("The server offers no models");
+    return first;
+}
+function clientName() {
+    const host = hostname().replace(/\.local$/, "").replace(/[^\p{L}\p{N} ._'()@-]/gu, "-").slice(0, 40) || "laptop";
+    return `${host} (dl)`;
+}
+/** On a terminal, replace the previous "·" line with its outcome; elsewhere just add a line. */
+function rewrite(io) {
+    return io.color === true ? "\x1b[1F\x1b[2K" : "";
+}
+function oneLine(text, max) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+export function describeError(error) {
+    if (error instanceof RemoteApiError)
+        return `${error.message} (${error.code})`;
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/laptop/config.js

@@ -0,0 +1,89 @@
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const REMOTE_NAME_RE = /^[a-z0-9][a-z0-9-]{0,39}$/;
+export function remotesPath(env = process.env) {
+    if (env.AUTOPILOT_REMOTES_FILE)
+        return env.AUTOPILOT_REMOTES_FILE;
+    const configHome = env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(configHome, "autopilot", "remotes.json");
+}
+export async function loadRemotes(path = remotesPath()) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.remotes) ? parsed.remotes.filter(isRemote) : [];
+}
+/** Adds or replaces a remote by name. The file holds bearer tokens, so it is 0600 in a 0700 directory. */
+export async function saveRemote(remote, path = remotesPath()) {
+    const remotes = (await loadRemotes(path)).filter((entry) => entry.name !== remote.name);
+    remotes.push(remote);
+    await writeRemotes(remotes, path);
+}
+export async function removeRemote(name, path = remotesPath()) {
+    const remotes = await loadRemotes(path);
+    const kept = remotes.filter((entry) => entry.name !== name);
+    if (kept.length === remotes.length)
+        return false;
+    await writeRemotes(kept, path);
+    return true;
+}
+/** The named remote, or the only one when no name is given. */
+export async function resolveRemote(name, path = remotesPath()) {
+    const remotes = await loadRemotes(path);
+    if (remotes.length === 0)
+        throw new Error("No servers paired yet. Run: autopilot remote add https://your-server");
+    if (name === undefined) {
+        if (remotes.length === 1)
+            return remotes[0];
+        throw new Error(`Several servers are paired; pick one with --on (${remotes.map((entry) => entry.name).join(", ")})`);
+    }
+    const remote = remotes.find((entry) => entry.name === name);
+    if (!remote)
+        throw new Error(`No server named "${name}". Paired: ${remotes.map((entry) => entry.name).join(", ")}`);
+    return remote;
+}
+/** A short default name from the URL's host: https://acme.example.com -> acme. */
+export function defaultRemoteName(url) {
+    const host = new URL(url).hostname.toLowerCase();
+    const label = /^\d+(\.\d+){3}$/.test(host) ? host.replace(/\./g, "-") : host.split(".")[0] ?? "server";
+    const name = label.replace(/[^a-z0-9-]/g, "-").replace(/^-+/, "").slice(0, 40);
+    return REMOTE_NAME_RE.test(name) ? name : "server";
+}
+/** Server URLs must be HTTPS, except loopback (an SSH tunnel or local testing). */
+export function normalizeServerUrl(input) {
+    let url;
+    try {
+        url = new URL(/^[a-z]+:\/\//i.test(input) ? input : `https://${input}`);
+    }
+    catch {
+        throw new Error(`Not a URL: ${input}`);
+    }
+    const loopback = url.hostname === "localhost" || url.hostname === "[::1]" || url.hostname.startsWith("127.");
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+        throw new Error("Use an https:// server URL (http:// is only allowed for localhost)");
+    }
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error("The server URL must not include credentials, a query, or a fragment");
+    return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+async function writeRemotes(remotes, path) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.${process.pid}.tmp`;
+    await writeFile(temp, `${JSON.stringify({ version: 1, remotes }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(temp, 0o600);
+    await rename(temp, path);
+}
+function isRemote(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return ["name", "url", "token", "credentialId", "expiresAt", "addedAt"].every((key) => typeof entry[key] === "string");
+}