@pmndrs/pine 0.0.0-stage → 0.1.1

package/src/http.js

@@ -0,0 +1,407 @@
+import crypto from "node:crypto";
+import http from "node:http";
+import { mainAgentId } from "./config.js";
+import { timingSafeEqual } from "./security.js";
+import { addServer, listServers, removeServer } from "./mcp-config.js";
+import { changes, diffOf, listDir, readText } from "./workspace-view.js";
+import { errText, topicMatches } from "./util.js";
+const MAX_BODY = 1024 * 1024;
+class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/**
+ * Control API and webhooks. Every request except /health and /hook/* needs the bearer token.
+ * Requests that come from a web page (an Origin header, a foreign Host) are refused, so a site
+ * open in a browser on this machine cannot drive the daemon.
+ */
+export class HttpServer {
+    cfg;
+    bus;
+    state;
+    tasks;
+    manager;
+    approvals;
+    log;
+    token;
+    server;
+    hits = new Map();
+    port = 0;
+    sources;
+    constructor(deps) {
+        this.sources = deps.sources;
+        this.cfg = deps.cfg;
+        this.bus = deps.bus;
+        this.state = deps.state;
+        this.tasks = deps.tasks;
+        this.manager = deps.manager;
+        this.approvals = deps.approvals;
+        this.log = deps.log;
+        this.token = deps.token;
+    }
+    async start() {
+        const { host, port } = this.cfg.http;
+        this.server = http.createServer((req, res) => void this.handle(req, res));
+        this.server.requestTimeout = 30_000;
+        this.server.headersTimeout = 10_000;
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(port, host, resolve);
+        });
+        this.port = this.server.address().port;
+        this.log.info(`http listening on ${host}:${this.port}`);
+    }
+    async stop() {
+        this.server?.closeAllConnections?.();
+        await new Promise((r) => (this.server ? this.server.close(() => r()) : r()));
+    }
+    async handle(req, res) {
+        const send = (status, body) => {
+            if (res.headersSent)
+                return;
+            res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store", "x-content-type-options": "nosniff" });
+            res.end(JSON.stringify(body));
+        };
+        const sendPicture = (p) => {
+            if (!p)
+                return send(404, { error: "no such picture" });
+            res.writeHead(200, { "content-type": p.mime, "content-length": p.bytes.length, "cache-control": "no-store", "x-content-type-options": "nosniff" });
+            res.end(p.bytes);
+        };
+        try {
+            const url = new URL(req.url ?? "/", "http://pine.local");
+            const parts = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+            const method = req.method ?? "GET";
+            if (method === "GET" && url.pathname === "/health")
+                return send(200, { ok: true });
+            if (parts[0] === "hook" && parts.length === 2 && method === "POST")
+                return send(202, await this.hook(parts[1], req));
+            this.guardBrowser(req);
+            const auth = req.headers.authorization ?? "";
+            if (!auth.startsWith("Bearer ") || !timingSafeEqual(auth.slice(7), this.token))
+                throw new HttpError(401, "missing or wrong bearer token");
+            if (method === "GET") {
+                const q = url.searchParams;
+                const num = (k) => (q.has(k) ? Number(q.get(k)) : undefined);
+                if (url.pathname === "/status")
+                    return send(200, { ...this.manager.status(), agents: Object.keys(this.cfg.agents), approvals: this.approvals.pending().length, bypassWhenTainted: this.cfg.security.bypassWhenTainted });
+                if (url.pathname === "/agents")
+                    return send(200, Object.values(this.cfg.agents).map((a) => ({ id: a.id, main: a.id === mainAgentId(this.cfg), description: a.description, workspace: a.workspace, model: a.model ?? this.cfg.defaults.model, thinking: a.thinking, mode: a.mode, delegates: a.delegates })));
+                if (url.pathname === "/tasks")
+                    return send(200, this.tasks.list({ agent: q.get("agent") ?? undefined, session: q.get("session") ?? undefined, status: q.get("status") ?? undefined, limit: num("limit") }));
+                if (url.pathname === "/models")
+                    return send(200, await this.manager.availableModels());
+                if (url.pathname === "/mcp")
+                    return send(200, listServers(this.cfg));
+                if (url.pathname === "/sources")
+                    return send(200, this.sources?.list() ?? []);
+                if (parts[0] === "agents" && parts[2] === "sources" && parts.length === 3) {
+                    if (!this.cfg.agents[parts[1]])
+                        throw new HttpError(404, "no such agent");
+                    return send(200, this.sources?.available(parts[1]) ?? []);
+                }
+                if (parts[0] === "agents" && parts[2] === "sessions" && parts.length === 3) {
+                    if (!this.cfg.agents[parts[1]])
+                        throw new HttpError(404, "no such agent");
+                    return send(200, this.manager.conversations(parts[1]));
+                }
+                if (url.pathname === "/ui/tabs")
+                    return send(200, this.manager.uiTabs());
+                if (parts[0] === "tasks" && parts[2] === "transcript" && parts.length === 3) {
+                    const t = this.manager.transcript(Number(parts[1]), q.get("full") === "1");
+                    return t ? send(200, t) : send(404, { error: "no such task" });
+                }
+                // Pictures for a UI to show. They are never sent to a model from here.
+                if (parts[0] === "media" && parts[1] === "tool" && parts.length === 3)
+                    return sendPicture(this.manager.toolImage(parts[2]));
+                if (parts[0] === "tasks" && parts[2] === "images" && parts.length === 4)
+                    return sendPicture(this.manager.taskImage(Number(parts[1]), Number(parts[3])));
+                if (parts[0] === "agents" && parts[2] === "image" && parts.length === 3)
+                    return sendPicture(this.manager.workspaceImage(parts[1], q.get("path") ?? "", q.get("session") ?? undefined));
+                // The folder a conversation works in, and what a UI shows of it: files, and what git says changed.
+                if (parts[0] === "agents" && parts[2] === "folder" && parts.length === 3) {
+                    if (!this.cfg.agents[parts[1]])
+                        throw new HttpError(404, "no such agent");
+                    return send(200, { folder: this.manager.folderOf(parts[1], q.get("session") ?? "main"), workspace: this.cfg.agents[parts[1]].workspace });
+                }
+                if (parts[0] === "agents" && parts[2] === "folders" && parts.length === 3) {
+                    if (!this.cfg.agents[parts[1]])
+                        throw new HttpError(404, "no such agent");
+                    return send(200, this.manager.folders(parts[1]));
+                }
+                if (parts[0] === "agents" && parts[2] === "view" && parts.length === 4) {
+                    const root = this.manager.viewRoot(parts[1], q.get("session") ?? "main");
+                    if (!root)
+                        throw new HttpError(404, "no such agent");
+                    const rel = q.get("path") ?? "";
+                    const found = parts[3] === "changes" ? { root, ...(await changes(root)) } : parts[3] === "diff" ? await diffOf(root, rel) : parts[3] === "tree" ? listDir(root, rel) : parts[3] === "file" ? readText(root, rel) : undefined;
+                    if (!found)
+                        throw new HttpError(404, "nothing there");
+                    return send(200, found);
+                }
+                if (parts[0] === "tasks" && parts.length === 2) {
+                    const t = this.tasks.get(Number(parts[1]));
+                    return t ? send(200, t) : send(404, { error: "no such task" });
+                }
+                if (url.pathname === "/events")
+                    return send(200, this.bus.query({ topic: q.get("topic") ?? undefined, after: num("after"), limit: num("limit") }));
+                if (url.pathname === "/events/stream")
+                    return this.stream(req, res, q.get("topic") ?? "#");
+                if (url.pathname === "/state")
+                    return send(200, this.state.list(q.get("key") ?? "#"));
+                if (url.pathname === "/approvals")
+                    return send(200, this.approvals.pending());
+                throw new HttpError(404, "not found");
+            }
+            if (method !== "POST")
+                throw new HttpError(405, "method not allowed");
+            // A message may carry attached files; everything else stays small.
+            const isPrompt = parts[0] === "agents" && parts[2] === "prompt" && parts.length === 3;
+            const body = (await this.json(req, isPrompt ? 64 * MAX_BODY : MAX_BODY));
+            if (url.pathname === "/images/fetch") {
+                if (typeof body.url !== "string")
+                    throw new HttpError(400, "url required");
+                try {
+                    return sendPicture(await this.manager.fetchImage(body.url));
+                }
+                catch (e) {
+                    throw new HttpError(502, errText(e));
+                }
+            }
+            if (url.pathname === "/events") {
+                if (typeof body.topic !== "string")
+                    throw new HttpError(400, "topic required");
+                const e = this.bus.publish(body.topic, body.payload ?? null, { source: "api", trust: body.trust === "untrusted" ? "untrusted" : "owner" });
+                return send(202, { id: e.id });
+            }
+            if (parts[0] === "agents" && parts[2] === "prompt" && parts.length === 3) {
+                if (typeof body.prompt !== "string" || !body.prompt)
+                    throw new HttpError(400, "prompt required");
+                const task = this.manager.submit({ agent: parts[1], prompt: body.prompt, session: body.session, trust: "owner", kind: "prompt", priority: 10, attachments: Array.isArray(body.attachments) ? body.attachments : undefined });
+                if (body.wait === false)
+                    return send(202, { task: task.id });
+                res.setTimeout(0);
+                req.on("close", () => !res.writableEnded && body.cancelOnDisconnect && this.manager.cancel(task.id));
+                return send(200, await this.manager.wait(task.id));
+            }
+            if (url.pathname === "/mcp/refresh") {
+                await this.manager.refreshSessions();
+                return send(200, { ok: true });
+            }
+            if (url.pathname === "/mcp") {
+                // The owner adds or removes a server while the daemon runs; sessions pick it up when next used.
+                if (typeof body.name !== "string")
+                    throw new HttpError(400, "name required");
+                const agent = typeof body.agent === "string" ? body.agent : undefined;
+                if (body.remove === true) {
+                    if (!removeServer(this.cfg, body.name, agent))
+                        throw new HttpError(404, "no such server");
+                }
+                else {
+                    if (!body.server || typeof body.server !== "object")
+                        throw new HttpError(400, "server required");
+                    if (JSON.stringify(body.server).includes("${"))
+                        throw new HttpError(400, "a server that refers to ${NAME} values is read from the file at startup: add it with the daemon stopped, or restart afterwards");
+                    addServer(this.cfg, body.name, body.server, agent);
+                }
+                await this.manager.refreshSessions(agent ? [agent] : undefined);
+                return send(200, { ok: true });
+            }
+            if (parts[0] === "agents" && parts[2] === "mode" && parts.length === 3) {
+                this.manager.setMode(parts[1], body.mode, body.anyway === true && typeof body.session === "string" ? body.session : undefined);
+                return send(200, { mode: body.mode });
+            }
+            if (parts[0] === "agents" && parts[2] === "thinking" && parts.length === 3) {
+                this.manager.setThinking(parts[1], String(body.level));
+                return send(200, { level: body.level });
+            }
+            if (parts[0] === "agents" && parts[2] === "model" && parts.length === 3) {
+                if (typeof body.model !== "string")
+                    throw new HttpError(400, "model required");
+                await this.manager.setModel(parts[1], body.model);
+                return send(200, { model: body.model });
+            }
+            if (parts[0] === "agents" && (parts[2] === "subscribe" || parts[2] === "unsubscribe") && parts.length === 3) {
+                if (!this.sources)
+                    throw new HttpError(404, "not found");
+                if (!this.cfg.agents[parts[1]])
+                    throw new HttpError(404, "no such agent");
+                if (typeof body.source !== "string" || !body.source)
+                    throw new HttpError(400, "source required");
+                try {
+                    if (parts[2] === "unsubscribe") {
+                        const sessions = await this.sources.unsubscribe(parts[1], body.source, typeof body.session === "string" ? body.session : undefined);
+                        return send(200, { unsubscribed: sessions.length > 0, sessions });
+                    }
+                    const { source: _s, ...details } = body;
+                    return send(200, await this.sources.subscribe(parts[1], body.source, details));
+                }
+                catch (e) {
+                    throw new HttpError(400, errText(e));
+                }
+            }
+            // For all agents.
+            if ((url.pathname === "/subscribe" || url.pathname === "/unsubscribe") && this.sources) {
+                if (typeof body.source !== "string" || !body.source)
+                    throw new HttpError(400, "source required");
+                try {
+                    if (url.pathname === "/unsubscribe")
+                        return send(200, { unsubscribed: await this.sources.unsubscribeAll(body.source) });
+                    const { source: _s, ...details } = body;
+                    return send(200, await this.sources.subscribeAll(body.source, details));
+                }
+                catch (e) {
+                    throw new HttpError(400, errText(e));
+                }
+            }
+            // A conversation was closed in a UI: what it was subscribed to on its own ends with it.
+            if (parts[0] === "agents" && parts[2] === "close" && parts.length === 3) {
+                if (!this.cfg.agents[parts[1]])
+                    throw new HttpError(404, "no such agent");
+                return send(200, { unsubscribed: (await this.sources?.closeSession(parts[1], String(body.session ?? ""))) ?? [] });
+            }
+            // The tabs a UI has open, kept so that it opens with the same ones next time.
+            if (url.pathname === "/ui/tabs")
+                return send(200, (this.manager.saveUiTabs(body.tabs, body.active, body.code), { ok: true }));
+            if (parts[0] === "agents" && parts[2] === "folder" && parts.length === 3) {
+                if (!this.cfg.agents[parts[1]])
+                    throw new HttpError(404, "no such agent");
+                try {
+                    return send(200, await this.manager.setFolder(parts[1], String(body.session ?? "main"), typeof body.folder === "string" && body.folder ? body.folder : null));
+                }
+                catch (e) {
+                    throw new HttpError(409, errText(e));
+                }
+            }
+            if (parts[0] === "agents" && ["remove", "rename", "pin"].includes(parts[2]) && parts.length === 3) {
+                if (!this.cfg.agents[parts[1]])
+                    throw new HttpError(404, "no such agent");
+                if (typeof body.session !== "string" || !body.session)
+                    throw new HttpError(400, "session: the conversation's name");
+                try {
+                    if (parts[2] === "pin")
+                        return send(200, { pinned: this.manager.pinSession(parts[1], body.session, body.pinned !== false) });
+                    if (parts[2] === "rename")
+                        return send(200, await this.manager.renameSession(parts[1], body.session, String(body.to ?? "")));
+                    return send(200, await this.manager.removeSession(parts[1], body.session));
+                }
+                catch (e) {
+                    throw new HttpError(409, errText(e));
+                }
+            }
+            if (parts[0] === "agents" && parts[2] === "reset" && parts.length === 3)
+                return send(200, { reset: await this.manager.resetSession(parts[1], body.session) });
+            if (parts[0] === "tasks" && parts[2] === "cancel" && parts.length === 3)
+                return send(200, { cancelled: this.manager.cancel(Number(parts[1])) });
+            if (parts[0] === "approvals" && parts.length === 2) {
+                const values = body.values && typeof body.values === "object" && !Array.isArray(body.values) ? body.values : undefined;
+                const missing = body.allow === true ? this.approvals.missing(parts[1], values) : [];
+                if (missing.length)
+                    throw new HttpError(400, `this request needs you to enter ${missing.join(", ")}: answer it in the terminal UI, where it is typed without being shown`);
+                return send(200, { decided: this.approvals.decide(parts[1], body.allow === true, "api", body.always === true, values) });
+            }
+            if (url.pathname === "/state") {
+                if (typeof body.key !== "string")
+                    throw new HttpError(400, "key required");
+                this.state.set(body.key, body.value ?? null, { source: "api" });
+                return send(200, { ok: true });
+            }
+            throw new HttpError(404, "not found");
+        }
+        catch (e) {
+            const status = e instanceof HttpError ? e.status : /unknown agent|too many queued|does not accept|invalid topic|invalid state key|busy|is not defined in models.json|mode must be one of|at most 10 files|larger than 20 MB|inbox folder|can attach files|usable server name|MCP server needs|not a valid URL|must use https|reasoning level must be/.test(errText(e)) ? 400 : 500;
+            if (status === 500)
+                this.log.error("http request failed", e);
+            send(status, { error: status === 500 ? "internal error" : errText(e) });
+        }
+    }
+    /** DNS rebinding and cross-site requests: only accept a loopback (or configured) Host, never an Origin. */
+    guardBrowser(req) {
+        if (req.headers.origin || req.headers["sec-fetch-site"])
+            throw new HttpError(403, "requests from web pages are not accepted");
+        const host = (req.headers.host ?? "").replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+        const allowed = ["127.0.0.1", "localhost", "::1", this.cfg.http.host];
+        if (!allowed.includes(host))
+            throw new HttpError(403, "unexpected Host header");
+    }
+    async raw(req, limit = MAX_BODY) {
+        const chunks = [];
+        let size = 0;
+        for await (const c of req) {
+            size += c.length;
+            if (size > limit)
+                throw new HttpError(413, "body too large");
+            chunks.push(c);
+        }
+        return Buffer.concat(chunks);
+    }
+    async json(req, limit = MAX_BODY) {
+        if (!(req.headers["content-type"] ?? "").startsWith("application/json"))
+            throw new HttpError(415, "content-type must be application/json");
+        const buf = await this.raw(req, limit);
+        try {
+            return buf.length ? JSON.parse(buf.toString("utf8")) : {};
+        }
+        catch {
+            throw new HttpError(400, "invalid JSON");
+        }
+    }
+    /** A webhook: outside content by definition, so the event is untrusted whatever it says. */
+    async hook(name, req) {
+        const hook = this.cfg.http.hooks[name];
+        // A running event source of type webhook (or one of your own) takes requests under its name.
+        const sourceHook = hook ? undefined : this.sources?.hookFor(name);
+        if (!hook && !sourceHook)
+            throw new HttpError(404, "not found");
+        const now = Date.now();
+        const recent = (this.hits.get(name) ?? []).filter((t) => now - t < 60_000);
+        if (recent.length >= 120)
+            throw new HttpError(429, "too many requests");
+        recent.push(now);
+        this.hits.set(name, recent);
+        const body = await this.raw(req);
+        if (sourceHook) {
+            try {
+                await sourceHook({ headers: req.headers, body });
+            }
+            catch (e) {
+                throw new HttpError(typeof e?.status === "number" ? e.status : 500, typeof e?.status === "number" ? errText(e) : "internal error");
+            }
+            return { id: 0 };
+        }
+        if (!hook)
+            throw new HttpError(404, "not found");
+        if (hook.secret) {
+            const bearer = (req.headers.authorization ?? "").replace(/^Bearer /, "");
+            const sig = String(req.headers["x-hub-signature-256"] ?? req.headers["x-signature"] ?? "").replace(/^sha256=/, "");
+            const expected = crypto.createHmac("sha256", hook.secret).update(body).digest("hex");
+            if (!(bearer && timingSafeEqual(bearer, hook.secret)) && !(sig && timingSafeEqual(sig, expected)))
+                throw new HttpError(401, "bad signature");
+        }
+        let payload;
+        try {
+            payload = JSON.parse(body.toString("utf8"));
+        }
+        catch {
+            payload = { text: body.toString("utf8") };
+        }
+        const e = this.bus.publish(hook.topic, payload, { source: "http", trust: "untrusted" });
+        return { id: e.id };
+    }
+    stream(req, res, pattern) {
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+        res.write(": connected\n\n");
+        const off = this.bus.subscribe("#", (e) => {
+            if (topicMatches(pattern, e.topic))
+                res.write(`data: ${JSON.stringify(e)}\n\n`);
+        }, "http-stream");
+        const ping = setInterval(() => res.write(": ping\n\n"), 20_000);
+        req.on("close", () => {
+            off();
+            clearInterval(ping);
+        });
+    }
+}

package/src/limiter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Bounds how many agent runs talk to the model server at once. Higher priority waits less;
+ * equal priorities are first come, first served.
+ */
+export declare class Limiter {
+    max: number;
+    private active;
+    private seq;
+    private queue;
+    constructor(max: number);
+    get stats(): {
+        active: number;
+        waiting: number;
+        max: number;
+    };
+    acquire(priority?: number): Promise<Slot>;
+    take(priority: number): Promise<void>;
+    free(): void;
+}
+/** One run's place at the model server. A run that only waits for other runs lends its place out with suspend(). */
+export declare class Slot {
+    private limiter;
+    private priority;
+    private held;
+    private done;
+    private waiters;
+    private reacquiring?;
+    constructor(limiter: Limiter, priority: number);
+    /** Give the place up while `fn` runs (a delegated task, sub-agents), then take one again before returning. */
+    suspend<T>(fn: () => Promise<T>): Promise<T>;
+    release(): void;
+}

package/src/limiter.js

@@ -0,0 +1,84 @@
+/**
+ * Bounds how many agent runs talk to the model server at once. Higher priority waits less;
+ * equal priorities are first come, first served.
+ */
+export class Limiter {
+    max;
+    active = 0;
+    seq = 0;
+    queue = [];
+    constructor(max) {
+        this.max = Math.max(1, max);
+    }
+    get stats() {
+        return { active: this.active, waiting: this.queue.length, max: this.max };
+    }
+    async acquire(priority = 0) {
+        await this.take(priority);
+        return new Slot(this, priority);
+    }
+    take(priority) {
+        if (this.active < this.max) {
+            this.active++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.queue.push({ priority, seq: this.seq++, resolve });
+            this.queue.sort((a, b) => b.priority - a.priority || a.seq - b.seq);
+        });
+    }
+    free() {
+        const next = this.queue.shift();
+        if (next)
+            next.resolve();
+        else
+            this.active--;
+    }
+}
+/** One run's place at the model server. A run that only waits for other runs lends its place out with suspend(). */
+export class Slot {
+    limiter;
+    priority;
+    held = true;
+    done = false;
+    waiters = 0;
+    reacquiring;
+    constructor(limiter, priority) {
+        this.limiter = limiter;
+        this.priority = priority;
+    }
+    /** Give the place up while `fn` runs (a delegated task, sub-agents), then take one again before returning. */
+    async suspend(fn) {
+        this.waiters++;
+        if (this.reacquiring)
+            await this.reacquiring;
+        if (this.held && !this.done) {
+            this.held = false;
+            this.limiter.free();
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            this.waiters--;
+            if (this.waiters === 0 && !this.held && !this.done) {
+                // A run that already started goes ahead of runs that have not.
+                this.reacquiring = this.limiter.take(this.priority + 1000).then(() => {
+                    this.held = true;
+                    this.reacquiring = undefined;
+                    if (this.done)
+                        this.release();
+                });
+            }
+            if (this.reacquiring)
+                await this.reacquiring;
+        }
+    }
+    release() {
+        this.done = true;
+        if (!this.held)
+            return;
+        this.held = false;
+        this.limiter.free();
+    }
+}

package/src/login.d.ts

@@ -0,0 +1,21 @@
+import type { PineConfig } from "./config.ts";
+export interface Prompter {
+    text(message: string): Promise<string>;
+    secret(message: string): Promise<string>;
+    say(line: string): void;
+    open(url: string): void;
+}
+/**
+ * Read one line without showing it. The prompt stays on screen and says that the input is hidden,
+ * so a silent cursor is not mistaken for a hang. Works for typing and for pasting.
+ */
+export declare function readSecret(message: string, input?: NodeJS.ReadableStream & {
+    setRawMode?(on: boolean): unknown;
+    isTTY?: boolean;
+}, output?: NodeJS.WritableStream): Promise<string>;
+/**
+ * Sign in to a model provider with pi's own login flow and store the credential in
+ * <home>/auth.json (mode 600). Agents cannot read that file.
+ */
+export declare function login(cfg: PineConfig, provider: string, type?: "api_key" | "oauth", prompter?: Prompter): Promise<string[]>;
+export declare function logout(cfg: PineConfig, provider: string): Promise<void>;

package/src/login.js

@@ -0,0 +1,126 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+/** Providers whose usual way in is a browser sign-in with a subscription. */
+const OAUTH_FIRST = ["anthropic", "openai-codex", "github-copilot"];
+/**
+ * Read one line without showing it. The prompt stays on screen and says that the input is hidden,
+ * so a silent cursor is not mistaken for a hang. Works for typing and for pasting.
+ */
+export function readSecret(message, input = process.stdin, output = process.stdout) {
+    return new Promise((resolve, reject) => {
+        output.write(`${message} (input is hidden; paste or type it, then press enter): `);
+        let value = "";
+        const raw = Boolean(input.isTTY && input.setRawMode);
+        if (raw)
+            input.setRawMode(true);
+        input.resume();
+        const finish = (err) => {
+            input.off("data", onData);
+            if (raw)
+                input.setRawMode(false);
+            input.pause();
+            output.write("\n");
+            if (err)
+                reject(err);
+            else
+                resolve(value.trim());
+        };
+        const onData = (chunk) => {
+            for (const ch of chunk.toString("utf8")) {
+                if (ch === "\r" || ch === "\n")
+                    return finish();
+                if (ch === "\x03")
+                    return finish(new Error("cancelled"));
+                if (ch === "\x7f" || ch === "\b")
+                    value = value.slice(0, -1);
+                else if (ch >= " ")
+                    value += ch;
+            }
+        };
+        input.on("data", onData);
+    });
+}
+const terminalPrompter = () => {
+    // A readline interface per question: one that stays open would redraw the line and wipe a prompt
+    // printed outside it, and would fight the raw-mode reader over the keyboard.
+    const ask = (q) => new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(q, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+    return {
+        text: (m) => ask(`${m} `),
+        secret: (m) => readSecret(m),
+        say: (line) => console.log(line),
+        open: (url) => void spawn("open", [url], { stdio: "ignore", detached: true }).on("error", () => { }),
+        close: () => process.stdin.pause(),
+    };
+};
+async function runtime(cfg) {
+    process.env.PI_CODING_AGENT_DIR = path.join(cfg.dataDir, "pi");
+    process.env.PI_SKIP_VERSION_CHECK = "1";
+    process.env.PI_TELEMETRY = "0";
+    fs.mkdirSync(process.env.PI_CODING_AGENT_DIR, { recursive: true });
+    return ModelRuntime.create({ authPath: path.join(cfg.home, "auth.json"), modelsPath: path.join(cfg.home, "models.json") });
+}
+/**
+ * Sign in to a model provider with pi's own login flow and store the credential in
+ * <home>/auth.json (mode 600). Agents cannot read that file.
+ */
+export async function login(cfg, provider, type, prompter) {
+    const rt = await runtime(cfg);
+    if (!rt.getProvider(provider))
+        throw new Error(`unknown provider "${provider}". Known: ${rt.getProviders().map((p) => p.id).sort().join(", ")}`);
+    const own = prompter ? undefined : terminalPrompter();
+    const p = prompter ?? own;
+    try {
+        const kind = type ?? (OAUTH_FIRST.includes(provider) ? "oauth" : "api_key");
+        await rt.login(provider, kind, {
+            prompt: async (q) => {
+                if (q.type === "secret")
+                    return p.secret(q.message);
+                if (q.type === "select") {
+                    q.options.forEach((o, i) => p.say(`  ${i + 1}) ${o.label}${o.description ? ` - ${o.description}` : ""}`));
+                    const n = Number(await p.text(`${q.message} [1-${q.options.length}]`));
+                    return q.options[Math.max(1, Math.min(q.options.length, n || 1)) - 1].id;
+                }
+                return p.text(q.message);
+            },
+            notify: (e) => {
+                if (e.type === "auth_url") {
+                    p.say(`Open this page to sign in:\n\n  ${e.url}\n${e.instructions ? `\n${e.instructions}\n` : ""}`);
+                    p.open(e.url);
+                }
+                else if (e.type === "device_code") {
+                    p.say(`Go to ${e.verificationUri} and enter the code ${e.userCode}`);
+                    p.open(e.verificationUri);
+                }
+                else if (e.message)
+                    p.say(e.message);
+            },
+        });
+        await rt.settleCredentialWrites?.();
+    }
+    finally {
+        own?.close();
+    }
+    const authFile = path.join(cfg.home, "auth.json");
+    if (fs.existsSync(authFile))
+        fs.chmodSync(authFile, 0o600);
+    const models = [...(await rt.getAvailable())].filter((m) => m.provider === provider).map((m) => `${provider}/${m.id}`);
+    // A pasted key is stored as it is; only the first request shows whether the provider accepts it.
+    const head = (type ?? (OAUTH_FIRST.includes(provider) ? "oauth" : "api_key")) === "oauth" ? `Signed in to ${provider}.` : `Stored the key for ${provider} (it is checked when the first message is sent).`;
+    p.say(`${head} ${models.length} models are available, for example:\n${models.slice(0, 8).map((m) => `  ${m}`).join("\n")}\n\nUse one with "defaults": { "model": "<provider/id>" } in pine.json, or /model in the terminal UI.`);
+    return models;
+}
+export async function logout(cfg, provider) {
+    const rt = await runtime(cfg);
+    await rt.logout(provider);
+    await rt.settleCredentialWrites?.();
+    console.log(`Removed the stored credential for ${provider}.`);
+}