@pmndrs/pine 0.0.0-stage → 0.1.0

package/src/dev/claude-model.js

@@ -0,0 +1,174 @@
+// Development model server: an OpenAI-compatible /v1/chat/completions endpoint whose answers come
+// from `claude -p`. It lets pine (and pi) run against a capable model before a local one is set
+// up. Each request starts one `claude` process, so it is slow and uses your Claude plan; do not
+// point a production daemon at it.
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+const RULES = `You are standing in for a language model behind an OpenAI-style chat completions API. An agent harness sends you its system prompt, the tools it offers and the conversation so far. Your only job is to write the next assistant message.
+
+You have no tools of your own in this role. The tools listed in <tools> belong to the harness: you ask for them in your reply, the harness runs them and sends the conversation back with the results in <tool_result> blocks.
+
+Reply with exactly one JSON object and nothing else (no prose before or after, no code fence):
+
+{"text": "<what the assistant says, may be empty>", "tool_calls": [{"name": "<tool name>", "arguments": { ... }}]}
+
+- "arguments" must match the tool's parameter schema.
+- Every tool in <tools> is available. Use them the way the harness system prompt expects: act, do not ask for permission to use a tool the role is meant to use.
+- Several calls in one reply are fine. Never state the outcome of a call before you have seen its <tool_result>.
+- When the task is done or needs no tool, put the answer in "text" and use "tool_calls": [].
+
+Play the role the harness system prompt defines.`;
+/** The model's reply is one JSON object; tolerate a code fence or stray text around it. */
+export function parseReply(raw) {
+    const start = raw.indexOf("{");
+    const end = raw.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+        try {
+            const o = JSON.parse(raw.slice(start, end + 1));
+            if (o && typeof o === "object" && ("text" in o || "tool_calls" in o)) {
+                return { text: String(o.text ?? ""), tool_calls: Array.isArray(o.tool_calls) ? o.tool_calls.filter((c) => c && typeof c.name === "string") : [] };
+            }
+        }
+        catch {
+            // fall through: treat the whole reply as text
+        }
+    }
+    return { text: raw.trim(), tool_calls: [] };
+}
+const textOf = (content) => typeof content === "string" ? content : Array.isArray(content) ? content.map((p) => (p.type === "text" ? p.text : `[${p.type} omitted]`)).join("") : "";
+export function buildPrompt(body) {
+    const messages = body.messages ?? [];
+    const system = messages.filter((m) => m.role === "system" || m.role === "developer").map((m) => textOf(m.content)).join("\n\n");
+    const tools = (body.tools ?? []).map((t) => ({ name: t.function?.name ?? t.name, description: t.function?.description ?? t.description, parameters: t.function?.parameters ?? t.parameters }));
+    const turns = messages
+        .filter((m) => m.role !== "system" && m.role !== "developer")
+        .map((m) => {
+        if (m.role === "tool")
+            return `<tool_result id="${m.tool_call_id ?? ""}">\n${textOf(m.content)}\n</tool_result>`;
+        if (m.role === "assistant") {
+            const calls = (m.tool_calls ?? []).map((c) => `<tool_call id="${c.id}" name="${c.function?.name}">${c.function?.arguments ?? "{}"}</tool_call>`).join("\n");
+            return `<assistant>\n${[textOf(m.content), calls].filter(Boolean).join("\n")}\n</assistant>`;
+        }
+        return `<user>\n${textOf(m.content)}\n</user>`;
+    });
+    return `<harness_system_prompt>\n${system}\n</harness_system_prompt>\n\n<tools>\n${JSON.stringify(tools, null, 1)}\n</tools>\n\n<conversation>\n${turns.join("\n")}\n</conversation>\n\nWrite the next assistant message now, as the single JSON object described in your instructions.`;
+}
+export async function startClaudeModel(opts = {}) {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pine-claude-model-"));
+    const max = opts.concurrency ?? 3;
+    const log = opts.log ?? (() => { });
+    let active = 0;
+    const queue = [];
+    const stats = { requests: 0, failures: 0 };
+    const take = () => (active < max ? (active++, Promise.resolve()) : new Promise((r) => queue.push(r)));
+    const give = () => {
+        const next = queue.shift();
+        if (next)
+            next();
+        else
+            active--;
+    };
+    const ask = (prompt, model, signal) => new Promise((resolve, reject) => {
+        const child = spawn(opts.claudePath ?? "claude", ["-p", "--model", model, "--output-format", "json", "--tools", "", "--strict-mcp-config", "--no-session-persistence", "--setting-sources", "", "--disable-slash-commands", "--system-prompt", RULES], { cwd, stdio: ["pipe", "pipe", "pipe"] });
+        let out = "";
+        let err = "";
+        child.stdout.on("data", (d) => (out += d));
+        child.stderr.on("data", (d) => (err += d));
+        const onAbort = () => child.kill("SIGKILL");
+        signal.addEventListener("abort", onAbort, { once: true });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted)
+                return reject(new Error("aborted"));
+            try {
+                const json = JSON.parse(out);
+                if (json.is_error)
+                    throw new Error(String(json.result ?? "claude reported an error"));
+                resolve(parseReply(String(json.result ?? "")));
+            }
+            catch (e) {
+                reject(new Error(`claude -p failed (exit ${code}): ${e.message} ${err.slice(0, 300)}`));
+            }
+        });
+        child.stdin.end(prompt);
+    });
+    const server = http.createServer(async (req, res) => {
+        if (req.method === "GET") {
+            res.writeHead(200, { "content-type": "application/json" });
+            return res.end(JSON.stringify({ object: "list", data: ["haiku", "sonnet", "opus"].map((id) => ({ id: `claude-${id}`, object: "model" })) }));
+        }
+        let raw = "";
+        for await (const c of req)
+            raw += c;
+        let body;
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            res.writeHead(400, { "content-type": "application/json" });
+            return res.end(JSON.stringify({ error: { message: "invalid JSON" } }));
+        }
+        const abort = new AbortController();
+        res.on("close", () => !res.writableEnded && abort.abort());
+        const model = /^(claude-)?(haiku|sonnet|opus|fable)$/.test(String(body.model)) ? String(body.model).replace(/^claude-/, "") : (opts.model ?? "haiku");
+        const prompt = buildPrompt(body);
+        stats.requests++;
+        const t0 = Date.now();
+        await take();
+        let answer;
+        try {
+            answer = await ask(prompt, model, abort.signal);
+        }
+        catch (e) {
+            stats.failures++;
+            give();
+            if (abort.signal.aborted)
+                return;
+            log(`request failed: ${e.message}`);
+            res.writeHead(500, { "content-type": "application/json" });
+            return res.end(JSON.stringify({ error: { message: e.message, type: "server_error" } }));
+        }
+        give();
+        const calls = answer.tool_calls
+            .map((c, i) => ({ index: i, id: `call_${stats.requests}_${i}`, type: "function", function: { name: c.name, arguments: typeof c.arguments === "string" ? c.arguments : JSON.stringify(c.arguments ?? {}) } }));
+        log(`${model} ${Date.now() - t0} ms: ${calls.length ? calls.map((c) => c.function.name).join(", ") : `text (${answer.text.length} chars)`}`);
+        const usage = { prompt_tokens: Math.ceil(prompt.length / 4), completion_tokens: Math.ceil((answer.text.length + JSON.stringify(calls).length) / 4), total_tokens: 0 };
+        usage.total_tokens = usage.prompt_tokens + usage.completion_tokens;
+        const id = `chatcmpl-claude-${stats.requests}`;
+        const base = { id, created: Math.floor(Date.now() / 1000), model: body.model };
+        const finish = calls.length ? "tool_calls" : "stop";
+        if (!body.stream) {
+            res.writeHead(200, { "content-type": "application/json" });
+            return res.end(JSON.stringify({ ...base, object: "chat.completion", choices: [{ index: 0, message: { role: "assistant", content: answer.text, ...(calls.length ? { tool_calls: calls.map(({ index: _i, ...c }) => c) } : {}) }, finish_reason: finish }], usage }));
+        }
+        const chunk = (delta, finish_reason = null, extra = {}) => res.write(`data: ${JSON.stringify({ ...base, object: "chat.completion.chunk", choices: [{ index: 0, delta, finish_reason }], ...extra })}\n\n`);
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+        chunk({ role: "assistant", content: "" });
+        for (let i = 0; i < answer.text.length; i += 80)
+            chunk({ content: answer.text.slice(i, i + 80) });
+        for (const c of calls)
+            chunk({ tool_calls: [c] });
+        chunk({}, finish, { usage });
+        res.write("data: [DONE]\n\n");
+        res.end();
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", (e) => reject(e.code === "EADDRINUSE" ? new Error(`port ${opts.port} is already in use; pick another with --port and set the same port in models.json`) : e));
+        server.listen(opts.port ?? 0, opts.host ?? "127.0.0.1", resolve);
+    });
+    const port = server.address().port;
+    return {
+        port,
+        baseUrl: `http://127.0.0.1:${port}/v1`,
+        stats,
+        close: () => new Promise((r) => {
+            server.closeAllConnections?.();
+            server.close(() => r());
+            fs.rmSync(cwd, { recursive: true, force: true });
+        }),
+    };
+}

package/src/env-file.d.ts

@@ -0,0 +1,4 @@
+/** Set entries in .env, replacing ones of the same name. The file stays readable by its owner only. */
+export declare function setEnv(home: string, entries: Record<string, string>): void;
+/** Take entries out of .env again. */
+export declare function unsetEnv(home: string, names: string[]): void;

package/src/env-file.js

@@ -0,0 +1,40 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseEnv } from "node:util";
+// pine's .env file holds the secrets the configuration refers to as ${NAME}. A secret that reaches
+// pine through a tool call (a broker's password, say) is put here, not into pine.json or an
+// agent.json, so that the configuration files never hold one.
+const fileOf = (home) => path.join(home, ".env");
+/** How a value is written so that it reads back exactly as it is. */
+function quoted(value) {
+    if (/[\r\n]/.test(value))
+        throw new Error("a secret cannot contain a line break");
+    for (const form of [value, `'${value}'`, `"${value}"`, `\`${value}\``])
+        if (parseEnv(`X=${form}`).X === value)
+            return form;
+    throw new Error("this value cannot be stored in the .env file (it mixes every kind of quote)");
+}
+/** Set entries in .env, replacing ones of the same name. The file stays readable by its owner only. */
+export function setEnv(home, entries) {
+    const names = Object.keys(entries);
+    if (!names.length)
+        return;
+    for (const name of names)
+        if (!/^[A-Z][A-Z0-9_]*$/.test(name))
+            throw new Error(`"${name}" is not a usable name for an .env entry`);
+    const lines = Object.entries(entries).map(([name, value]) => `${name}=${quoted(value)}`);
+    const kept = fs.existsSync(fileOf(home)) ? fs.readFileSync(fileOf(home), "utf8").split("\n").filter((line) => !names.some((name) => line.startsWith(`${name}=`))) : [];
+    while (kept.length && !kept.at(-1).trim())
+        kept.pop();
+    fs.writeFileSync(fileOf(home), `${[...kept, ...lines].join("\n")}\n`, { mode: 0o600 });
+    fs.chmodSync(fileOf(home), 0o600);
+}
+/** Take entries out of .env again. */
+export function unsetEnv(home, names) {
+    if (!names.length || !fs.existsSync(fileOf(home)))
+        return;
+    const lines = fs.readFileSync(fileOf(home), "utf8").split("\n");
+    const kept = lines.filter((line) => !names.some((name) => line.startsWith(`${name}=`)));
+    if (kept.length !== lines.length)
+        fs.writeFileSync(fileOf(home), kept.join("\n"), { mode: 0o600 });
+}

package/src/http.d.ts

@@ -0,0 +1,46 @@
+import type { AgentManager } from "./agents.ts";
+import { type PineConfig } from "./config.ts";
+import { type Approvals } from "./security.ts";
+import type { Bus, State, TaskStore } from "./store.ts";
+import type { SourceHost } from "./sources.ts";
+import { type Logger } from "./util.ts";
+/**
+ * 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 declare class HttpServer {
+    private cfg;
+    private bus;
+    private state;
+    private tasks;
+    private manager;
+    private approvals;
+    private log;
+    private token;
+    private server?;
+    private hits;
+    port: number;
+    private sources?;
+    constructor(deps: {
+        cfg: PineConfig;
+        bus: Bus;
+        state: State;
+        tasks: TaskStore;
+        manager: AgentManager;
+        approvals: Approvals;
+        sources?: SourceHost;
+        log: Logger;
+        token: string;
+    });
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handle;
+    /** DNS rebinding and cross-site requests: only accept a loopback (or configured) Host, never an Origin. */
+    private guardBrowser;
+    private raw;
+    private json;
+    /** A webhook: outside content by definition, so the event is untrusted whatever it says. */
+    private hook;
+    private stream;
+}