@prestyj/cli 4.12.1 → 4.14.0

package/dist/app-sidecar.js

@@ -15,6 +15,7 @@ import http from "node:http";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
 import { runJsonMode } from "./modes/json-mode.js";
 import { AgentSession } from "./core/agent-session.js";
@@ -34,7 +35,7 @@ import { getNextThinkingLevel, getSupportedThinkingLevels, isThinkingLevelSuppor
 import { PROMPT_COMMANDS } from "./core/prompt-commands.js";
 import { loadCustomCommands } from "./core/custom-commands.js";
 import { discoverProjects, listRecentSessions } from "./core/project-discovery.js";
-import { loadTasksSync, saveTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/tasks-store.js";
+import { loadTasksSync, saveTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/task-store.js";
 import { initLogger, log } from "./core/logger.js";
 import { RADIO_STATIONS, getCurrentStation, playRadio, stopRadio } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
@@ -52,6 +53,7 @@ const ALL_PROVIDERS = [
     "minimax",
     "deepseek",
     "openrouter",
+    "sakana",
 ];
 function appSettingsFile() {
     return path.join(os.homedir(), ".ezcoder", "ezcoder-app.json");
@@ -362,11 +364,28 @@ async function runJsonModeIfRequested() {
     });
     return true;
 }
+// ── Daemon-level HTTP helpers (shared by the session-management routes) ─────
+// The per-session route table has its own local copies; these serve the
+// daemon's own POST /session / DELETE /session routes.
+function daemonReadBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (c) => chunks.push(c));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
+    });
+}
+function daemonJson(res, status, body) {
+    res.writeHead(status, {
+        "content-type": "application/json",
+        "access-control-allow-origin": "*",
+    });
+    res.end(JSON.stringify(body));
+}
 async function main() {
     // Sub-agent JSON-mode dispatch must win before any sidecar/server setup.
     if (await runJsonModeIfRequested())
         return;
-    const cwd = process.env.GG_APP_CWD ?? process.cwd();
     // Default to an ephemeral port (0) so concurrent/orphaned instances never
     // collide on a fixed port. The actual port is reported via the
     // GG_APP_LISTENING handshake and consumed by the shell.
@@ -404,6 +423,119 @@ async function main() {
     await enrichProcessPath();
     const auth = new AuthStorage(paths.authFile);
     await auth.load();
+    // Every window's session lives here as an in-process object, keyed by the id
+    // the daemon hands back from POST /session. The Rust shell routes each proxy
+    // request to its window's session via the `x-gg-session` header (and the
+    // `?session=` query for the SSE /events stream).
+    const sessions = new Map();
+    /** Resolve the target session id: the `x-gg-session` header, else a
+     *  `?session=` query param (used by the SSE /events connection). */
+    function sessionIdFromReq(req, url) {
+        const header = req.headers["x-gg-session"];
+        if (typeof header === "string" && header.length > 0)
+            return header;
+        try {
+            return new URL(url, `http://${host}`).searchParams.get("session");
+        }
+        catch {
+            return null;
+        }
+    }
+    const server = http.createServer((req, res) => {
+        const url = req.url ?? "/";
+        const method = req.method ?? "GET";
+        // CORS preflight — the webview origin differs from 127.0.0.1.
+        if (method === "OPTIONS") {
+            res.writeHead(204, {
+                "access-control-allow-origin": "*",
+                "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
+                "access-control-allow-headers": "content-type, x-gg-session",
+            });
+            res.end();
+            return;
+        }
+        // ── Daemon-level routes (session lifecycle) ──────────────────────────
+        // Create a session for a window: { cwd, sessionPath? } → { sessionId }.
+        if (method === "POST" && url === "/session") {
+            void daemonReadBody(req).then(async (raw) => {
+                let body = {};
+                try {
+                    body = raw ? JSON.parse(raw) : {};
+                }
+                catch {
+                    /* empty/invalid body → defaults below */
+                }
+                const sessionCwd = typeof body.cwd === "string" && body.cwd
+                    ? body.cwd
+                    : (process.env.GG_APP_CWD ?? process.cwd());
+                const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
+                const id = randomUUID();
+                try {
+                    const ctx = await createSession({ auth, paths }, { id, cwd: sessionCwd, sessionPath });
+                    sessions.set(id, ctx);
+                    log("INFO", "app-sidecar", "session created", { id, cwd: sessionCwd });
+                    daemonJson(res, 200, { sessionId: id });
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    log("ERROR", "app-sidecar", "session create failed", { message });
+                    daemonJson(res, 500, { error: message });
+                }
+            });
+            return;
+        }
+        // Dispose a session: DELETE /session/:id.
+        if (method === "DELETE" && url.startsWith("/session/")) {
+            const id = decodeURIComponent(url.slice("/session/".length));
+            const ctx = sessions.get(id);
+            if (ctx) {
+                sessions.delete(id);
+                void ctx.dispose().catch(() => { });
+                log("INFO", "app-sidecar", "session disposed", { id });
+            }
+            daemonJson(res, 200, { ok: true });
+            return;
+        }
+        // ── Per-session delegation ───────────────────────────────────────────
+        const id = sessionIdFromReq(req, url);
+        const ctx = id ? sessions.get(id) : undefined;
+        if (!ctx) {
+            daemonJson(res, 404, { error: "unknown session" });
+            return;
+        }
+        ctx.handle(req, res, url, method);
+    });
+    server.listen(port, host, () => {
+        const addr = server.address();
+        // The Rust shell reads this line to learn the daemon port.
+        process.stdout.write(`GG_APP_LISTENING ${addr.port}\n`);
+        log("INFO", "app-sidecar", "daemon listening", { port: String(addr.port), host });
+    });
+    const shutdown = async () => {
+        // Radio playback is app-wide (one stream across all windows), so it stops
+        // at the daemon level, not per session.
+        stopRadio();
+        await Promise.all([...sessions.values()].map((c) => c.dispose().catch(() => { })));
+        server.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+}
+/**
+ * Build one in-process agent session: its AgentSession, SSE client set, event
+ * bridge, task runner, auth/login bridge, and the full HTTP route table exposed
+ * as a `handle()` method. Many of these live inside one daemon process, fully
+ * isolated (separate AgentSession, cwd, history, model) — only the HTTP server,
+ * logger, PATH, shared auth file, and radio live at the daemon level.
+ */
+async function createSession(deps, opts) {
+    const { auth } = deps;
+    const paths = deps.paths;
+    const cwd = opts.cwd;
+    // Base host for parsing request-URL query params (value is irrelevant to
+    // parsing); the daemon owns the real listen host.
+    const host = "127.0.0.1";
     const saved = loadSavedSettings(paths.settingsFile);
     // Per-project model/thinking prefs win over the shared global settings.json:
     // each window (one project cwd) restores its own selection instead of every
@@ -435,9 +567,9 @@ async function main() {
         for (const c of clients)
             c.res.write(frame);
     }
-    // When the shell respawns this sidecar for a chosen project, it passes the
-    // session file path to resume; empty/unset starts a fresh session.
-    const resumeSessionPath = process.env.GG_APP_SESSION_ID || undefined;
+    // The session file path to resume (passed by the daemon's POST /session);
+    // empty/unset starts a fresh session.
+    const resumeSessionPath = opts.sessionPath;
     let abort = new AbortController();
     const session = new AgentSession({
         provider,
@@ -495,26 +627,33 @@ async function main() {
             tasks: session.listBackgroundProcesses(),
         };
     }
+    // tool_call_end carries no tool name (only the id), so remember each call's
+    // name from tool_call_start to log a useful line on completion. Mirrors the
+    // CLI's logging so the app sidecar's ~/.ezcoder/ezcoder-app-sidecar.log records tool
+    // failures (e.g. repeated invalid-argument errors) instead of leaving the
+    // fatal-abort path with no forensic trail.
+    const toolCallNames = new Map();
     // Forward every relevant bus event to the webview.
     session.eventBus.on("text_delta", (d) => broadcast("text_delta", d));
     session.eventBus.on("thinking_delta", (d) => broadcast("thinking_delta", d));
-    // tool_call_end omits the tool name, so remember it from tool_call_start (keyed
-    // by toolCallId) to detect when the `tasks` tool just mutated the task store.
-    const toolNamesById = new Map();
     session.eventBus.on("tool_call_start", (d) => {
-        if (d?.toolCallId && typeof d.name === "string")
-            toolNamesById.set(d.toolCallId, d.name);
+        toolCallNames.set(d.toolCallId, d.name);
         broadcast("tool_call_start", d);
     });
     session.eventBus.on("tool_call_update", (d) => broadcast("tool_call_update", d));
     session.eventBus.on("tool_call_end", (d) => {
+        const name = toolCallNames.get(d.toolCallId) ?? "unknown";
+        toolCallNames.delete(d.toolCallId);
+        log(d.isError ? "ERROR" : "INFO", "tool", `Tool call ended: ${name}`, {
+            id: d.toolCallId,
+            durationMs: String(d.durationMs),
+            isError: String(d.isError),
+            ...(d.isError ? { result: d.result.slice(0, 500) } : {}),
+        });
         broadcast("tool_call_end", d);
         // The agent can add/done/remove project tasks via the `tasks` tool during a
         // normal chat run. Push the refreshed list so the webview's Tasks modal and
         // footer badge update live instead of going stale until the modal reopens.
-        const name = d?.toolCallId ? toolNamesById.get(d.toolCallId) : undefined;
-        if (d?.toolCallId)
-            toolNamesById.delete(d.toolCallId);
         if (name === "tasks") {
             broadcast("tasks_list", { tasks: loadTasksSync(cwd) });
         }
@@ -526,7 +665,11 @@ async function main() {
     session.eventBus.on("server_tool_call", (d) => broadcast("server_tool_call", d));
     session.eventBus.on("turn_end", (d) => broadcast("turn_end", d));
     session.eventBus.on("agent_done", (d) => broadcast("agent_done", d));
-    session.eventBus.on("error", (d) => broadcast("error", { message: d.error instanceof Error ? d.error.message : String(d.error) }));
+    session.eventBus.on("error", (d) => {
+        const message = d.error instanceof Error ? d.error.message : String(d.error);
+        log("ERROR", "app-sidecar", "agent error", { message });
+        broadcast("error", { message });
+    });
     session.eventBus.on("model_change", (d) => broadcast("model_change", d));
     session.eventBus.on("hook", (d) => broadcast("hook", d));
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
@@ -694,19 +837,8 @@ async function main() {
         });
         res.end(payload);
     }
-    const server = http.createServer((req, res) => {
-        const url = req.url ?? "/";
-        const method = req.method ?? "GET";
-        // CORS preflight — the webview origin differs from 127.0.0.1.
-        if (method === "OPTIONS") {
-            res.writeHead(204, {
-                "access-control-allow-origin": "*",
-                "access-control-allow-methods": "GET, POST, OPTIONS",
-                "access-control-allow-headers": "content-type",
-            });
-            res.end();
-            return;
-        }
+    // OPTIONS/CORS preflight is handled at the daemon level before delegation.
+    function handle(req, res, url, method) {
         if (method === "GET" && url === "/state") {
             const st = session.getState();
             json(res, 200, {
@@ -720,7 +852,7 @@ async function main() {
             });
             return;
         }
-        if (method === "GET" && url === "/events") {
+        if (method === "GET" && (url === "/events" || url.startsWith("/events?"))) {
             res.writeHead(200, {
                 "content-type": "text/event-stream",
                 "cache-control": "no-cache",
@@ -1064,9 +1196,14 @@ async function main() {
             json(res, 200, { tasks: loadTasksSync(cwd) });
             return;
         }
-        // ── Radio ─────────────────────────────────────────────────
-        // Playback runs in THIS sidecar process, which is unique per window, so a
-        // station only plays in the window that started it.
+        // ── Radio (app-wide) ──────────────────────────────────────
+        // Radio is now APP-WIDE: all windows share one daemon process, and the
+        // player lives in `core/radio.ts` module-level singletons (one stream for
+        // the whole app). Any window's /radio reads/controls that single stream —
+        // starting a station in one window replaces whatever was playing, and every
+        // window's footer reflects the same `current`. This intentionally prevents
+        // duplicate audio across windows (the original per-window goal), now for
+        // free. (To restore per-window radio, key playback by sessionId.)
         if (method === "GET" && url === "/radio") {
             json(res, 200, { stations: RADIO_STATIONS, current: getCurrentStation() });
             return;
@@ -1117,6 +1254,83 @@ async function main() {
             });
             return;
         }
+        if (method === "POST" && url === "/tasks/add") {
+            void readBody(req).then((raw) => {
+                let title;
+                let prompt;
+                try {
+                    const body = JSON.parse(raw);
+                    title = (body.title ?? "").trim();
+                    prompt = (body.prompt ?? "").trim();
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!title) {
+                    json(res, 400, { error: "missing task title" });
+                    return;
+                }
+                const tasks = loadTasksSync(cwd);
+                const newTask = {
+                    id: randomUUID(),
+                    title,
+                    prompt: prompt || title,
+                    status: "pending",
+                    createdAt: new Date().toISOString(),
+                };
+                const next = [...tasks, newTask];
+                saveTasksSync(cwd, next);
+                broadcast("tasks_list", { tasks: next });
+                json(res, 200, { tasks: next });
+            });
+            return;
+        }
+        if (method === "POST" && url === "/tasks/update") {
+            void readBody(req).then((raw) => {
+                let id;
+                let status;
+                let title;
+                let prompt;
+                try {
+                    const body = JSON.parse(raw);
+                    id = (body.id ?? "").trim();
+                    status = body.status;
+                    title = body.title;
+                    prompt = body.prompt;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (!id) {
+                    json(res, 400, { error: "missing task id" });
+                    return;
+                }
+                if (status && status !== "pending" && status !== "in-progress" && status !== "done") {
+                    json(res, 400, { error: `invalid status: ${status}` });
+                    return;
+                }
+                const tasks = loadTasksSync(cwd);
+                const task = tasks.find((t) => t.id === id || t.id.startsWith(id));
+                if (!task) {
+                    json(res, 404, { error: `no task found matching id "${id}"` });
+                    return;
+                }
+                const next = tasks.map((t) => t.id === task.id
+                    ? {
+                        ...t,
+                        ...(status ? { status: status } : {}),
+                        ...(typeof title === "string" && title.trim() ? { title: title.trim() } : {}),
+                        ...(typeof prompt === "string" && prompt.trim() ? { prompt: prompt.trim() } : {}),
+                    }
+                    : t);
+                saveTasksSync(cwd, next);
+                broadcast("tasks_list", { tasks: next });
+                json(res, 200, { tasks: next });
+            });
+            return;
+        }
         if (method === "POST" && url === "/tasks/delete") {
             void readBody(req).then((raw) => {
                 let id;
@@ -1133,6 +1347,7 @@ async function main() {
                 }
                 const remaining = loadTasksSync(cwd).filter((t) => t.id !== id && !t.id.startsWith(id));
                 saveTasksSync(cwd, remaining);
+                broadcast("tasks_list", { tasks: remaining });
                 json(res, 200, { tasks: remaining });
             });
             return;
@@ -1705,30 +1920,28 @@ async function main() {
             return;
         }
         json(res, 404, { error: "not found" });
-    });
-    server.listen(port, host, () => {
-        const addr = server.address();
-        // The Rust shell reads this line to learn the port.
-        process.stdout.write(`GG_APP_LISTENING ${addr.port}\n`);
-        log("INFO", "app-sidecar", "listening", { port: String(addr.port), host });
-    });
-    const shutdown = async () => {
+    }
+    async function dispose() {
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);
-        // Kill any playing radio so the stream dies with its window.
-        stopRadio();
         // Stop the Telegram serve loop + dispose its per-chat sessions.
         if (serveController)
             await serveController.stop().catch(() => { });
         for (const c of clients)
             c.res.end();
-        server.close();
         await session.dispose().catch(() => { });
-        process.exit(0);
+    }
+    return {
+        id: opts.id,
+        cwd,
+        sessionPath: opts.sessionPath,
+        session,
+        clients,
+        broadcast,
+        handle,
+        dispose,
     };
-    process.on("SIGINT", () => void shutdown());
-    process.on("SIGTERM", () => void shutdown());
 }
 main().catch((err) => {
     const message = err instanceof Error ? err.message : String(err);