pipane 0.1.0

package/dist/server/server/rest-api.js

@@ -0,0 +1,289 @@
+/**
+ * REST API endpoints for pipane.
+ *
+ * Stateless handlers that read session data from JSONL files on disk.
+ */
+import { existsSync, readFileSync, readdirSync, watchFile } from "node:fs";
+import { unlink } from "node:fs/promises";
+import path from "node:path";
+import { buildSessionContext, parseSessionEntries } from "@mariozechner/pi-coding-agent";
+import { SessionIndex } from "./session-index.js";
+import { LocalSettingsStore } from "./local-settings.js";
+let localSettingsStore;
+let sessionIndex;
+let localSettingsWatcherStarted = false;
+function startLocalSettingsWatcher(onLocalSettingsReloaded) {
+    if (localSettingsWatcherStarted)
+        return;
+    localSettingsWatcherStarted = true;
+    let debounceTimer = null;
+    watchFile(localSettingsStore.path, { interval: 500 }, () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            const changed = localSettingsStore.reloadFromDiskIfValid();
+            if (!changed)
+                return;
+            await sessionIndex.invalidateAll();
+            onLocalSettingsReloaded?.();
+        }, 150);
+    });
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    const raw = Buffer.concat(chunks).toString();
+    return JSON.parse(raw || "{}");
+}
+export function registerRestApi(app, options = {}) {
+    const traceStore = options.traceStore;
+    localSettingsStore = options.localSettingsStore ?? new LocalSettingsStore();
+    sessionIndex = new SessionIndex({
+        cwdDisplayFormatter: (cwd) => localSettingsStore.formatCwdTitle(cwd),
+    });
+    startLocalSettingsWatcher(options.onLocalSettingsReloaded);
+    app.post("/api/debug/load-trace/event", async (req, res) => {
+        try {
+            if (!traceStore) {
+                res.status(404).json({ error: "Tracing disabled" });
+                return;
+            }
+            const chunks = [];
+            for await (const chunk of req)
+                chunks.push(chunk);
+            const body = JSON.parse(Buffer.concat(chunks).toString() || "{}");
+            const traceId = String(body.traceId || req.headers["x-pi-trace-id"] || "");
+            if (!traceId) {
+                res.status(400).json({ error: "Missing traceId" });
+                return;
+            }
+            traceStore.record(traceId, {
+                ts: new Date().toISOString(),
+                source: "frontend",
+                kind: body.durationMs != null ? "span" : "instant",
+                name: String(body.name || "frontend_event"),
+                durationMs: typeof body.durationMs === "number" ? body.durationMs : undefined,
+                attrs: body.attrs && typeof body.attrs === "object" ? body.attrs : undefined,
+            });
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/debug/load-trace/latest", (_req, res) => {
+        if (!traceStore) {
+            res.status(404).json({ error: "Tracing disabled" });
+            return;
+        }
+        res.json({ traces: traceStore.getLatest() });
+    });
+    app.get("/api/debug/load-trace/:traceId", (req, res) => {
+        if (!traceStore) {
+            res.status(404).json({ error: "Tracing disabled" });
+            return;
+        }
+        const trace = traceStore.get(req.params.traceId);
+        if (!trace) {
+            res.status(404).json({ error: "Trace not found" });
+            return;
+        }
+        res.json(trace);
+    });
+    app.get("/api/sessions", async (_req, res) => {
+        try {
+            res.json(await sessionIndex.listSessions());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/settings/local", (_req, res) => {
+        try {
+            res.json(localSettingsStore.read());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post("/api/settings/local/validate", async (req, res) => {
+        try {
+            const body = await readJsonBody(req);
+            if (typeof body.content !== "string") {
+                res.status(400).json({ error: "Missing 'content' string" });
+                return;
+            }
+            res.json(localSettingsStore.validate(body.content));
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.patch("/api/settings/local", async (req, res) => {
+        try {
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object") {
+                res.status(400).json({ error: "Request body must be a JSON object" });
+                return;
+            }
+            const result = localSettingsStore.patch(body);
+            if (!result.valid) {
+                res.status(400).json(result);
+                return;
+            }
+            await sessionIndex.invalidateAll();
+            options.onLocalSettingsReloaded?.();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.put("/api/settings/local", async (req, res) => {
+        try {
+            const body = await readJsonBody(req);
+            if (typeof body.content !== "string") {
+                res.status(400).json({ error: "Missing 'content' string" });
+                return;
+            }
+            const result = localSettingsStore.save(body.content);
+            if (!result.valid) {
+                res.status(400).json(result);
+                return;
+            }
+            await sessionIndex.invalidateAll();
+            options.onLocalSettingsReloaded?.();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete("/api/sessions", async (req, res) => {
+        try {
+            const chunks = [];
+            for await (const chunk of req)
+                chunks.push(chunk);
+            const body = JSON.parse(Buffer.concat(chunks).toString());
+            const { path: sessionPath } = body;
+            if (!sessionPath || typeof sessionPath !== "string") {
+                res.status(400).json({ error: "Missing session path" });
+                return;
+            }
+            if (!sessionPath.endsWith(".jsonl") || !existsSync(sessionPath)) {
+                res.status(404).json({ error: "Session not found" });
+                return;
+            }
+            await unlink(sessionPath);
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/sessions/messages", (req, res) => {
+        try {
+            const sessionPath = req.query.path;
+            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+                res.status(400).json({ error: "Missing or invalid session path" });
+                return;
+            }
+            if (!existsSync(sessionPath)) {
+                res.status(404).json({ error: "Session file not found" });
+                return;
+            }
+            const content = readFileSync(sessionPath, "utf8");
+            const entries = parseSessionEntries(content);
+            const context = buildSessionContext(entries);
+            res.json({
+                messages: context.messages,
+                model: context.model,
+                thinkingLevel: context.thinkingLevel,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/sessions/fork-messages", (req, res) => {
+        try {
+            const sessionPath = req.query.path;
+            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+                res.status(400).json({ error: "Missing or invalid session path" });
+                return;
+            }
+            if (!existsSync(sessionPath)) {
+                res.status(404).json({ error: "Session file not found" });
+                return;
+            }
+            const content = readFileSync(sessionPath, "utf8");
+            const entries = parseSessionEntries(content);
+            const messages = [];
+            for (const entry of entries) {
+                if (entry.type !== "message")
+                    continue;
+                const msg = entry.message;
+                if (!msg || msg.role !== "user")
+                    continue;
+                let text = "";
+                if (typeof msg.content === "string") {
+                    text = msg.content;
+                }
+                else if (Array.isArray(msg.content)) {
+                    text = msg.content
+                        .filter((c) => c.type === "text")
+                        .map((c) => c.text)
+                        .join("");
+                }
+                if (text && entry.id) {
+                    messages.push({ entryId: entry.id, text });
+                }
+            }
+            res.json({ messages });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/sessions/raw", (req, res) => {
+        try {
+            const sessionPath = req.query.path;
+            if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+                res.status(400).json({ error: "Missing or invalid session path" });
+                return;
+            }
+            if (!existsSync(sessionPath)) {
+                res.status(404).json({ error: "Session file not found" });
+                return;
+            }
+            const content = readFileSync(sessionPath, "utf8");
+            res.type("text/plain").send(content);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/browse", (req, res) => {
+        try {
+            const requestedPath = req.query.path || process.env.HOME || "/";
+            const resolved = path.resolve(requestedPath.replace(/^~/, process.env.HOME || "/"));
+            if (!existsSync(resolved)) {
+                res.status(404).json({ error: "Path not found" });
+                return;
+            }
+            const entries = readdirSync(resolved, { withFileTypes: true });
+            const dirs = entries
+                .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+                .map((e) => ({
+                name: e.name,
+                path: path.join(resolved, e.name),
+            }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            res.json({ path: resolved, dirs });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+}

package/dist/server/server/server.js

@@ -0,0 +1,355 @@
+/**
+ * pipane backend server.
+ *
+ * Architecture: sessions are either "detached" (read from JSONL on disk)
+ * or "attached" (a pi RPC process is running a turn for them).
+ *
+ * A CWD-aware pool of pi RPC processes is maintained. When a user sends
+ * a message, a process matching the session's project directory is acquired,
+ * switched to that session, and runs one turn. After the turn completes,
+ * the process is released back to the pool.
+ *
+ * Session lifecycle is managed by SessionLifecycle (single source of truth
+ * for session→process mappings and status). Process spawning and pooling
+ * is handled by ProcessPool. The WsHandler routes WebSocket commands to
+ * these modules.
+ */
+import express from "express";
+import { createServer } from "node:http";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { hostname } from "node:os";
+import { randomBytes } from "node:crypto";
+import { existsSync, watch } from "node:fs";
+import { WebSocketServer, WebSocket } from "ws";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { resolvePiLaunch } from "./pi-launch.js";
+import { checkCommandAvailable, makePiNotFoundMessage } from "./pi-runtime.js";
+import { registerRestApi } from "./rest-api.js";
+import { SessionLifecycle } from "./session-lifecycle.js";
+import { ProcessPool } from "./process-pool.js";
+import { WsHandler } from "./ws-handler.js";
+import { LoadTraceStore } from "./load-trace-store.js";
+import { LocalSettingsStore } from "./local-settings.js";
+const DEFAULT_PORT = process.env.NODE_ENV === "production" ? "8222" : "18111";
+const PORT = parseInt(process.env.PORT || DEFAULT_PORT, 10);
+const PI_CWD = process.env.PI_CWD || process.cwd();
+// Quiet mode: only show URLs unless --verbose or PIPANE_VERBOSE=1
+const VERBOSE = process.argv.includes("--verbose") || process.env.PIPANE_VERBOSE === "1";
+if (!VERBOSE) {
+    const origLog = console.log;
+    const origError = console.error;
+    const origWarn = console.warn;
+    // Suppress all console output; we'll use _log for the few lines we want
+    console.log = () => { };
+    console.error = () => { };
+    console.warn = () => { };
+    globalThis._pipaneLog = origLog;
+}
+else {
+    globalThis._pipaneLog = console.log;
+}
+/** Always prints, even in quiet mode */
+function log(...args) {
+    globalThis._pipaneLog(...args);
+}
+const PI_CLI = process.env.PI_CLI;
+const PI_LAUNCH = resolvePiLaunch(PI_CLI);
+const PI_AVAILABLE = checkCommandAvailable(PI_LAUNCH.command);
+const PI_MAX_PROCESSES = parseInt(process.env.PI_MAX_PROCESSES || "24", 10);
+const PI_PREWARM_COUNT = parseInt(process.env.PI_PREWARM_COUNT || "2", 10);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const AUTH_COOKIE_NAME = "pipane_auth";
+const AUTH_TOKEN = process.env.PIPANE_AUTH_TOKEN || randomBytes(24).toString("base64url");
+const PUBLIC_HOSTNAME = process.env.PI_PUBLIC_HOSTNAME || hostname();
+const AUTH_URL = `http://${PUBLIC_HOSTNAME}:${PORT}/auth?token=${encodeURIComponent(AUTH_TOKEN)}`;
+function parseCookies(header) {
+    const out = {};
+    if (!header)
+        return out;
+    for (const part of header.split(";")) {
+        const idx = part.indexOf("=");
+        if (idx <= 0)
+            continue;
+        const k = part.slice(0, idx).trim();
+        const v = part.slice(idx + 1).trim();
+        out[k] = decodeURIComponent(v);
+    }
+    return out;
+}
+function isLocalAddress(addr) {
+    if (!addr)
+        return false;
+    return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
+}
+function isLocalRequest(req) {
+    if (process.env.PIPANE_DISABLE_LOCAL_BYPASS === "1")
+        return false;
+    return isLocalAddress(req.socket.remoteAddress);
+}
+function setAuthCookie(res) {
+    const secure = process.env.PIPANE_SECURE_COOKIE === "1" ? "; Secure" : "";
+    const maxAgeSeconds = 60 * 60 * 24 * 30;
+    res.setHeader("Set-Cookie", `${AUTH_COOKIE_NAME}=${encodeURIComponent(AUTH_TOKEN)}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${maxAgeSeconds}${secure}`);
+}
+function isAuthorizedRequest(req) {
+    if (isLocalRequest(req))
+        return true;
+    const cookies = parseCookies(req.headers.cookie);
+    return cookies[AUTH_COOKIE_NAME] === AUTH_TOKEN;
+}
+// ============================================================================
+// Express + HTTP server
+// ============================================================================
+const app = express();
+const server = createServer(app);
+const wss = new WebSocketServer({ server, path: "/ws" });
+// ── WebSocket keep-alive via ping/pong ────────────────────────────────
+// Ping all connected clients every 30s. If a client doesn't respond with
+// a pong within the interval, the connection is considered dead and terminated.
+// This prevents silent disconnects (e.g. from network changes, sleep, etc.)
+// from leaving zombie connections on the server side, and ensures the client's
+// onclose handler fires so auto-reconnect kicks in.
+const WS_PING_INTERVAL = 30_000;
+const wsAliveMap = new WeakMap();
+wss.on("connection", (ws) => {
+    wsAliveMap.set(ws, true);
+    ws.on("pong", () => { wsAliveMap.set(ws, true); });
+});
+const pingInterval = setInterval(() => {
+    for (const ws of wss.clients) {
+        if (wsAliveMap.get(ws) === false) {
+            // Didn't respond to last ping — terminate
+            ws.terminate();
+            continue;
+        }
+        wsAliveMap.set(ws, false);
+        ws.ping();
+    }
+}, WS_PING_INTERVAL);
+wss.on("close", () => { clearInterval(pingInterval); });
+app.get("/auth", (req, res) => {
+    const token = typeof req.query.token === "string" ? req.query.token : undefined;
+    if (isLocalRequest(req) || token === AUTH_TOKEN) {
+        setAuthCookie(res);
+        res.redirect("/");
+        return;
+    }
+    res.status(401).type("html").send("<h3>Unauthorized</h3><p>Invalid auth token.</p>");
+});
+app.use((req, res, next) => {
+    if (isAuthorizedRequest(req)) {
+        if (isLocalRequest(req)) {
+            setAuthCookie(res);
+        }
+        next();
+        return;
+    }
+    res.status(401).type("html").send("<h3>Unauthorized</h3><p>Open the one-time auth URL shown in the pipane terminal.</p>");
+});
+const traceStore = new LoadTraceStore();
+const localSettingsStore = new LocalSettingsStore();
+app.use((req, res, next) => {
+    const traceId = typeof req.headers["x-pi-trace-id"] === "string" ? req.headers["x-pi-trace-id"] : "";
+    if (!traceId) {
+        next();
+        return;
+    }
+    const start = performance.now();
+    res.on("finish", () => {
+        traceStore.record(traceId, {
+            ts: new Date().toISOString(),
+            source: "backend",
+            kind: "span",
+            name: `http ${req.method} ${req.path}`,
+            durationMs: Number((performance.now() - start).toFixed(2)),
+            attrs: {
+                statusCode: res.statusCode,
+            },
+        });
+    });
+    next();
+});
+// Serve static files in production
+const clientDist = path.resolve(__dirname, "../../client");
+app.use(express.static(clientDist));
+// Register REST endpoints
+registerRestApi(app, {
+    traceStore,
+    localSettingsStore,
+    onLocalSettingsReloaded: () => {
+        wss.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(JSON.stringify({
+                    type: "sessions_changed",
+                    file: "__local_settings__",
+                }));
+            }
+        });
+    },
+});
+// ============================================================================
+// Core modules
+// ============================================================================
+const lifecycle = new SessionLifecycle();
+// Resolve canvas extension path relative to project root
+const canvasExtension = path.resolve(__dirname, "../../../extensions/canvas.ts");
+const pool = new ProcessPool({
+    command: PI_LAUNCH.command,
+    baseArgs: () => {
+        const args = [...PI_LAUNCH.baseArgs, "--mode", "rpc"];
+        if (localSettingsStore.canvasEnabled) {
+            args.push("-e", canvasExtension);
+        }
+        return args;
+    },
+}, {
+    maxProcesses: PI_MAX_PROCESSES,
+    prewarmCount: PI_PREWARM_COUNT,
+    onProcessExit: (proc) => {
+        // If the process was attached to a session, handle the crash
+        const sessionPath = lifecycle.getAttachedSessionForProcess(proc);
+        if (sessionPath) {
+            console.log(`[pool] pi#${proc.id} crashed while attached to ${path.basename(sessionPath)} — marking done`);
+            lifecycle.crash(sessionPath);
+        }
+        // Replenish the pool for the default cwd
+        if (PI_AVAILABLE) {
+            pool.prewarm(PI_CWD);
+        }
+    },
+});
+const wsHandler = new WsHandler({
+    lifecycle,
+    pool,
+    defaultCwd: PI_CWD,
+    piLaunch: PI_LAUNCH,
+    ensurePool: () => {
+        if (wsHandler.isPiAvailable) {
+            pool.prewarm(PI_CWD);
+        }
+    },
+    isRequestAuthorized: (req) => isAuthorizedRequest(req),
+    traceStore,
+});
+// Register WS handler
+wsHandler.register(wss);
+// ============================================================================
+// Debug endpoints
+// ============================================================================
+app.get("/api/debug/pool", (_req, res) => {
+    try {
+        res.json(wsHandler.getDebugState());
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+app.get("/debug/pool", (_req, res) => {
+    res.type("html").send(`<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>pipane pool debug</title>
+  <style>
+    body { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; margin: 16px; }
+    table { border-collapse: collapse; width: 100%; margin-top: 12px; }
+    th, td { border: 1px solid #ddd; padding: 6px 8px; font-size: 12px; text-align: left; }
+    th { background: #f6f6f6; }
+    .ok { color: #0a7d22; }
+    .bad { color: #b42318; }
+  </style>
+</head>
+<body>
+  <h3>pipane pool debug</h3>
+  <div id="meta">loading…</div>
+  <table>
+    <thead>
+      <tr>
+        <th>proc</th><th>pid</th><th>alive</th><th>cwd</th><th>busy</th><th>attachedSession</th><th>pendingRequests</th><th>exitCode</th>
+      </tr>
+    </thead>
+    <tbody id="rows"></tbody>
+  </table>
+  <pre id="raw"></pre>
+<script>
+async function tick(){
+  const r = await fetch('/api/debug/pool');
+  const d = await r.json();
+  document.getElementById('meta').textContent =
+    'now=' + d.now + ' total=' + d.totalProcesses + ' attached=' + d.attachedSessionCount + ' wsOpen=' + d.connectedWsOpen;
+  const rows = (d.processes || []).map(p =>
+    '<tr><td>' + p.id + '</td><td>' + (p.pid ?? '') + '</td><td class="' + (p.alive ? 'ok':'bad') + '">' + p.alive + '</td><td>' + (p.cwd || '') + '</td><td>' + p.busy + '</td><td>' + (p.attachedSession ?? '') + '</td><td>' + p.pendingRequests + '</td><td>' + (p.exitCode ?? '') + '</td></tr>'
+  ).join('');
+  document.getElementById('rows').innerHTML = rows;
+  document.getElementById('raw').textContent = JSON.stringify({ sessionStatuses: d.sessionStatuses }, null, 2);
+}
+setInterval(tick, 1000); tick();
+</script>
+</body>
+</html>`);
+});
+// ============================================================================
+// Sessions Directory Watcher
+// ============================================================================
+const SESSIONS_DIR = path.join(getAgentDir(), "sessions");
+function startSessionsWatcher() {
+    if (!existsSync(SESSIONS_DIR)) {
+        console.log(`Sessions dir does not exist yet: ${SESSIONS_DIR}`);
+        return null;
+    }
+    let debounceTimer = null;
+    let lastChangedFile = null;
+    const watcher = watch(SESSIONS_DIR, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith(".jsonl"))
+            return;
+        lastChangedFile = filename;
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            const fullPath = path.join(SESSIONS_DIR, lastChangedFile);
+            // Notify the message cache — it will re-read from disk if changed
+            // and push session_messages to the subscribed client if needed.
+            wsHandler.notifySessionFileChanged(fullPath);
+            // Also notify all WS clients about the file change (for sidebar refresh)
+            wss.clients.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(JSON.stringify({
+                        type: "sessions_changed",
+                        file: fullPath,
+                    }));
+                }
+            });
+        }, 300);
+    });
+    console.log(`Watching sessions directory: ${SESSIONS_DIR}`);
+    return watcher;
+}
+startSessionsWatcher();
+// ============================================================================
+// Startup
+// ============================================================================
+if (PI_AVAILABLE) {
+    console.log(`[pool] Pre-warming process pool for ${PI_CWD}...`);
+    pool.prewarm(PI_CWD);
+}
+else {
+    console.log(`[pi] ${makePiNotFoundMessage(PI_LAUNCH.command)}`);
+}
+server.listen(PORT, () => {
+    log("");
+    log("        _                        ");
+    log("  _ __ (_)_ __   __ _ _ __   ___ ");
+    log(" | '_ \\| | '_ \\ / _` | '_ \\ / _ \\");
+    log(" | |_) | | |_) | (_| | | | |  __/");
+    log(" | .__/|_| .__/ \\__,_|_| |_|\\___|");
+    log(" |_|     |_|                      ");
+    log("");
+    log(`  Local:  http://localhost:${PORT}`);
+    log(`  Remote: ${AUTH_URL}`);
+    if (!process.env.PIPANE_AUTH_TOKEN) {
+        log(`\n  Auth token is random and changes on restart.`);
+        log(`  Set PIPANE_AUTH_TOKEN to use a fixed token.`);
+    }
+    log("");
+});

package/dist/server/server/session-cwd.js

@@ -0,0 +1,33 @@
+/**
+ * Resolve the cwd for a session by reading the JSONL header.
+ * Caches results since a session's cwd never changes.
+ */
+import { existsSync, readFileSync } from "node:fs";
+const cwdCache = new Map();
+/**
+ * Read the cwd from a session JSONL file's header.
+ * Returns the cwd or undefined if the file doesn't exist or has no valid header.
+ */
+export function getSessionCwd(sessionPath) {
+    const cached = cwdCache.get(sessionPath);
+    if (cached !== undefined)
+        return cached;
+    try {
+        if (!existsSync(sessionPath))
+            return undefined;
+        const content = readFileSync(sessionPath, "utf8");
+        const firstNewline = content.indexOf("\n");
+        const firstLine = firstNewline === -1 ? content : content.slice(0, firstNewline);
+        if (!firstLine.trim())
+            return undefined;
+        const header = JSON.parse(firstLine);
+        if (header.type === "session" && typeof header.cwd === "string") {
+            cwdCache.set(sessionPath, header.cwd);
+            return header.cwd;
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return undefined;
+}