@lelouchhe/webagent 0.1.7 → 0.1.10

package/lib/event-handler.js

@@ -1,95 +0,0 @@
-import { broadcast } from "./ws-handler.js";
-export function handleAgentEvent(event, sessions, store, wss, bridge, config, pushService) {
-    if ("sessionId" in event && event.sessionId && sessions.restoringSessions.has(event.sessionId))
-        return;
-    switch (event.type) {
-        case "connected":
-            event.cancelTimeout = config.cancelTimeout;
-            break;
-        case "session_created":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
-        case "config_option_update":
-            if (event.configOptions?.length)
-                sessions.cachedConfigOptions = event.configOptions;
-            for (const opt of event.configOptions ?? []) {
-                store.updateSessionConfig(event.sessionId, opt.id, opt.currentValue);
-            }
-            break;
-        case "message_chunk":
-            sessions.flushThinkingBuffer(event.sessionId);
-            sessions.appendAssistant(event.sessionId, event.text);
-            break;
-        case "thought_chunk":
-            sessions.flushAssistantBuffer(event.sessionId);
-            sessions.appendThinking(event.sessionId, event.text);
-            break;
-        case "tool_call":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { id: event.id, title: event.title, kind: event.kind, rawInput: event.rawInput });
-            break;
-        case "tool_call_update":
-            store.saveEvent(event.sessionId, event.type, { id: event.id, status: event.status, content: event.content });
-            break;
-        case "plan":
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { entries: event.entries });
-            break;
-        case "permission_request": {
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, {
-                requestId: event.requestId, title: event.title, options: event.options,
-            });
-            // Auto-approve permissions in autopilot mode (allow_once only to avoid persisting across mode switches)
-            const mode = store.getSession(event.sessionId)?.mode ?? "";
-            if (mode.includes("#autopilot")) {
-                const opt = event.options.find((o) => o.kind === "allow_once");
-                if (opt) {
-                    bridge.resolvePermission(event.requestId, opt.optionId);
-                    const optionName = opt.label ?? opt.optionId;
-                    store.saveEvent(event.sessionId, "permission_response", {
-                        requestId: event.requestId, optionName, denied: false,
-                    });
-                    broadcast(wss, {
-                        type: "permission_resolved",
-                        sessionId: event.sessionId,
-                        requestId: event.requestId,
-                        optionName,
-                        denied: false,
-                    });
-                    return;
-                }
-            }
-            break;
-        }
-        case "prompt_done":
-            sessions.activePrompts.delete(event.sessionId);
-            sessions.flushBuffers(event.sessionId);
-            store.saveEvent(event.sessionId, event.type, { stopReason: event.stopReason });
-            break;
-        case "error":
-            if (event.sessionId) {
-                sessions.activePrompts.delete(event.sessionId);
-            }
-            break;
-    }
-    broadcast(wss, event);
-    // Push notification check (after broadcast so WS clients get the event first)
-    if (pushService && "sessionId" in event && event.sessionId) {
-        const session = store.getSession(event.sessionId);
-        const eventData = {};
-        if (event.type === "permission_request") {
-            eventData.description = event.title;
-        }
-        if (pushService.maybeNotify(event.sessionId, session?.title ?? null, event.type, eventData)) {
-            const notification = pushService.formatNotification(event.sessionId, session?.title ?? null, event.type, eventData);
-            pushService.sendToAll(notification).catch((err) => {
-                console.error("[push] failed to send:", err);
-            });
-        }
-    }
-}

package/lib/push-service.js

@@ -1,112 +0,0 @@
-import webpush from "web-push";
-import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-const VAPID_FILE = "vapid.json";
-export class PushService {
-    store;
-    vapidKeys;
-    clientVisibility = new Map(); // clientId → visible
-    constructor(store, dataDir, vapidSubject) {
-        this.store = store;
-        this.vapidKeys = this.loadOrGenerateKeys(dataDir);
-        webpush.setVapidDetails(vapidSubject, this.vapidKeys.publicKey, this.vapidKeys.privateKey);
-    }
-    // ---------------------------------------------------------------------------
-    // VAPID keys
-    // ---------------------------------------------------------------------------
-    loadOrGenerateKeys(dataDir) {
-        const filePath = join(dataDir, VAPID_FILE);
-        if (existsSync(filePath)) {
-            chmodSync(filePath, 0o600);
-            const keys = JSON.parse(readFileSync(filePath, "utf8"));
-            console.log("[push] loaded VAPID keys");
-            return keys;
-        }
-        const keys = webpush.generateVAPIDKeys();
-        writeFileSync(filePath, JSON.stringify(keys, null, 2) + "\n", { mode: 0o600 });
-        console.log("[push] generated new VAPID keys");
-        return keys;
-    }
-    getPublicKey() {
-        return this.vapidKeys.publicKey;
-    }
-    // ---------------------------------------------------------------------------
-    // Notification formatting
-    // ---------------------------------------------------------------------------
-    formatNotification(sessionId, sessionTitle, eventType, eventData) {
-        const title = sessionTitle ? `WebAgent · ${sessionTitle}` : "WebAgent";
-        let body;
-        switch (eventType) {
-            case "permission_request":
-                body = `⚿ ${eventData.description ?? "Permission requested"}`;
-                break;
-            case "prompt_done":
-                body = "✓ Task complete";
-                break;
-            case "bash_done": {
-                const cmd = eventData.command ?? "command";
-                const code = eventData.exitCode ?? "?";
-                body = `$ ${cmd} — exit ${code}`;
-                break;
-            }
-            default:
-                body = eventType;
-        }
-        return { title, body, data: { sessionId } };
-    }
-    // ---------------------------------------------------------------------------
-    // Client visibility tracking
-    // ---------------------------------------------------------------------------
-    setClientVisibility(clientId, visible) {
-        this.clientVisibility.set(clientId, visible);
-    }
-    removeClient(clientId) {
-        this.clientVisibility.delete(clientId);
-    }
-    hasVisibleClient() {
-        for (const visible of this.clientVisibility.values()) {
-            if (visible)
-                return true;
-        }
-        return false;
-    }
-    // ---------------------------------------------------------------------------
-    // High-level: decide whether to push, and if so, send
-    // ---------------------------------------------------------------------------
-    static NOTIFIABLE = new Set(["permission_request", "prompt_done", "bash_done"]);
-    /**
-     * Check if this event should trigger a push notification.
-     * Returns true if a notification was queued (caller should then call sendToAll).
-     */
-    maybeNotify(sessionId, sessionTitle, eventType, eventData) {
-        if (!PushService.NOTIFIABLE.has(eventType))
-            return false;
-        if (this.hasVisibleClient())
-            return false;
-        return true;
-    }
-    // ---------------------------------------------------------------------------
-    // Send push to all subscriptions
-    // ---------------------------------------------------------------------------
-    async sendToAll(notification) {
-        const subs = this.store.getAllSubscriptions();
-        if (subs.length === 0)
-            return;
-        const payload = JSON.stringify(notification);
-        const results = await Promise.allSettled(subs.map((sub) => webpush.sendNotification({ endpoint: sub.endpoint, keys: { auth: sub.auth, p256dh: sub.p256dh } }, payload)));
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            if (result.status === "rejected") {
-                const err = result.reason;
-                if (err.statusCode === 410) {
-                    // Subscription expired — clean up
-                    this.store.removeSubscription(subs[i].endpoint);
-                    console.log(`[push] removed expired subscription: ${subs[i].endpoint}`);
-                }
-                else {
-                    console.error(`[push] send failed for ${subs[i].endpoint}:`, result.reason);
-                }
-            }
-        }
-    }
-}

package/lib/routes.js

@@ -1,202 +0,0 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join, extname } from "node:path";
-const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
-const MIME = {
-    ".html": "text/html",
-    ".js": "application/javascript",
-    ".css": "text/css",
-    ".json": "application/json",
-    ".svg": "image/svg+xml",
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-};
-export function createRequestHandler(store, publicDir, dataDir, limits, pushService) {
-    return async (req, res) => {
-        const url = req.url ?? "/";
-        // --- API routes ---
-        if (url.startsWith("/api/")) {
-            res.setHeader("Content-Type", "application/json");
-            // GET /api/sessions
-            if (url === "/api/sessions" && req.method === "GET") {
-                res.end(JSON.stringify(store.listSessions()));
-                return;
-            }
-            // GET /api/sessions/:id/events?thinking=0|1
-            const eventsMatch = url.match(/^\/api\/sessions\/([^/]+)\/events(\?.*)?$/);
-            if (eventsMatch && req.method === "GET") {
-                const sessionId = decodeURIComponent(eventsMatch[1]);
-                const params = new URLSearchParams(eventsMatch[2]?.slice(1) ?? "");
-                const excludeThinking = params.get("thinking") === "0";
-                const afterSeqRaw = params.get("after_seq");
-                const afterSeq = afterSeqRaw != null ? Number(afterSeqRaw) : undefined;
-                const session = store.getSession(sessionId);
-                if (!session) {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: "Session not found" }));
-                    return;
-                }
-                const events = store.getEvents(sessionId, { excludeThinking, afterSeq });
-                res.end(JSON.stringify(events));
-                return;
-            }
-            // POST /api/images/:sessionId
-            const imgMatch = url.match(/^\/api\/images\/([^/]+)$/);
-            if (imgMatch && req.method === "POST") {
-                const sessionId = decodeURIComponent(imgMatch[1]);
-                if (!SAFE_ID.test(sessionId)) {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Invalid session ID" }));
-                    return;
-                }
-                // Enforce upload size limit
-                const contentLength = parseInt(req.headers["content-length"] ?? "0", 10);
-                if (contentLength > limits.image_upload) {
-                    res.writeHead(413);
-                    res.end(JSON.stringify({ error: "Upload too large" }));
-                    return;
-                }
-                const chunks = [];
-                let totalSize = 0;
-                for await (const chunk of req) {
-                    totalSize += chunk.length;
-                    if (totalSize > limits.image_upload) {
-                        res.writeHead(413);
-                        res.end(JSON.stringify({ error: "Upload too large" }));
-                        return;
-                    }
-                    chunks.push(chunk);
-                }
-                let body;
-                try {
-                    body = JSON.parse(Buffer.concat(chunks).toString());
-                }
-                catch {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Invalid JSON" }));
-                    return;
-                }
-                const { data, mimeType } = body;
-                const ext = mimeType.split("/")[1]?.replace("jpeg", "jpg") ?? "png";
-                const seq = Date.now();
-                const relPath = `images/${sessionId}/${seq}.${ext}`;
-                const absPath = join(dataDir, relPath);
-                await mkdir(join(dataDir, "images", sessionId), { recursive: true });
-                await writeFile(absPath, Buffer.from(data, "base64"));
-                const imgUrl = `/data/${relPath}`;
-                res.end(JSON.stringify({ path: relPath, url: imgUrl }));
-                return;
-            }
-            // --- Push notification routes ---
-            // GET /api/push/vapid-key
-            if (url === "/api/push/vapid-key" && req.method === "GET") {
-                if (!pushService) {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: "Push not configured" }));
-                    return;
-                }
-                res.end(JSON.stringify({ publicKey: pushService.getPublicKey() }));
-                return;
-            }
-            // POST /api/push/subscribe
-            if (url === "/api/push/subscribe" && req.method === "POST") {
-                if (!pushService) {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: "Push not configured" }));
-                    return;
-                }
-                const chunks = [];
-                for await (const chunk of req)
-                    chunks.push(chunk);
-                let body;
-                try {
-                    body = JSON.parse(Buffer.concat(chunks).toString());
-                }
-                catch {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Invalid JSON" }));
-                    return;
-                }
-                if (!body.endpoint || !body.keys?.auth || !body.keys?.p256dh) {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Missing endpoint or keys (auth, p256dh)" }));
-                    return;
-                }
-                store.saveSubscription(body.endpoint, body.keys.auth, body.keys.p256dh);
-                res.writeHead(201);
-                res.end(JSON.stringify({ ok: true }));
-                return;
-            }
-            // POST /api/push/unsubscribe
-            if (url === "/api/push/unsubscribe" && req.method === "POST") {
-                if (!pushService) {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: "Push not configured" }));
-                    return;
-                }
-                const chunks = [];
-                for await (const chunk of req)
-                    chunks.push(chunk);
-                let body;
-                try {
-                    body = JSON.parse(Buffer.concat(chunks).toString());
-                }
-                catch {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: "Invalid JSON" }));
-                    return;
-                }
-                if (body.endpoint) {
-                    store.removeSubscription(body.endpoint);
-                }
-                res.end(JSON.stringify({ ok: true }));
-                return;
-            }
-            res.writeHead(404);
-            res.end(JSON.stringify({ error: "Not found" }));
-            return;
-        }
-        // --- Serve uploaded images: /data/images/... ---
-        if (url.startsWith("/data/images/")) {
-            const filePath = join(dataDir, url.slice(6)); // strip "/data/"
-            if (!filePath.startsWith(join(dataDir, "images"))) {
-                res.writeHead(403);
-                res.end("Forbidden");
-                return;
-            }
-            try {
-                const data = await readFile(filePath);
-                const ext = extname(filePath);
-                res.writeHead(200, {
-                    "Content-Type": MIME[ext] ?? "application/octet-stream",
-                    "Cache-Control": "public, max-age=31536000, immutable",
-                });
-                res.end(data);
-            }
-            catch {
-                res.writeHead(404);
-                res.end("Not found");
-            }
-            return;
-        }
-        // --- Static files ---
-        const filePath = join(publicDir, url === "/" ? "/index.html" : url);
-        if (!filePath.startsWith(publicDir)) {
-            res.writeHead(403);
-            res.end("Forbidden");
-            return;
-        }
-        try {
-            const data = await readFile(filePath);
-            const ext = extname(filePath);
-            res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
-            res.end(data);
-        }
-        catch {
-            res.writeHead(404);
-            res.end("Not found");
-        }
-    };
-}

package/lib/server.js

@@ -1,70 +0,0 @@
-import { createServer } from "node:http";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { WebSocketServer } from "ws";
-import { loadConfig } from "./config.js";
-import { AgentBridge } from "./bridge.js";
-import { Store } from "./store.js";
-import { SessionManager } from "./session-manager.js";
-import { TitleService } from "./title-service.js";
-import { createRequestHandler } from "./routes.js";
-import { setupWsHandler, broadcast } from "./ws-handler.js";
-import { handleAgentEvent } from "./event-handler.js";
-import { PushService } from "./push-service.js";
-const config = loadConfig();
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const PUBLIC_DIR = join(__dirname, "..", config.public_dir);
-// --- Core dependencies ---
-const store = new Store(config.data_dir);
-console.log(`[store] using ${config.data_dir}/`);
-const sessions = new SessionManager(store, config.default_cwd, config.data_dir);
-const titleService = new TitleService(store, sessions, config.default_cwd);
-const pushService = new PushService(store, config.data_dir, config.push.vapid_subject);
-console.log(`[push] VAPID public key ready`);
-let bridge = null;
-// --- HTTP + WebSocket servers ---
-const server = createServer(createRequestHandler(store, PUBLIC_DIR, config.data_dir, config.limits, pushService));
-const wss = new WebSocketServer({ server });
-setupWsHandler({
-    wss,
-    store,
-    sessions,
-    titleService,
-    getBridge: () => bridge,
-    limits: config.limits,
-    pushService,
-});
-async function initBridge() {
-    const b = new AgentBridge(config.agent_cmd);
-    b.on("event", (event) => {
-        handleAgentEvent(event, sessions, store, wss, b, { cancelTimeout: config.limits.cancel_timeout }, pushService);
-    });
-    await b.start();
-    bridge = b;
-    return b;
-}
-// --- Graceful shutdown ---
-async function shutdown() {
-    console.log("\n[server] shutting down...");
-    sessions.killAllBashProcs();
-    wss.close();
-    await bridge?.shutdown();
-    store.close();
-    server.close();
-    process.exit(0);
-}
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-// --- Start ---
-server.listen(config.port, "0.0.0.0", async () => {
-    console.log(`[server] listening on http://localhost:${config.port}`);
-    console.log(`[bridge] starting: ${config.agent_cmd}...`);
-    try {
-        await initBridge();
-        console.log(`[bridge] ready`);
-        sessions.hydrate();
-    }
-    catch (err) {
-        console.error(`[bridge] failed to start:`, err);
-    }
-});

package/lib/session-manager.js

@@ -1,199 +0,0 @@
-import { rm } from "node:fs/promises";
-import { stat } from "node:fs/promises";
-import { join } from "node:path";
-/** Known config option IDs that we persist per-session. */
-const PERSISTED_CONFIG_IDS = ["model", "mode", "reasoning_effort"];
-/**
- * Centralizes all session-related state that was previously scattered
- * across module-level variables in server.ts.
- */
-export class SessionManager {
-    liveSessions = new Set();
-    restoringSessions = new Set();
-    sessionHasTitle = new Set();
-    assistantBuffers = new Map();
-    thinkingBuffers = new Map();
-    activePrompts = new Set();
-    runningBashProcs = new Map();
-    cachedConfigOptions = [];
-    store;
-    defaultCwd;
-    dataDir;
-    constructor(store, defaultCwd, dataDir) {
-        this.store = store;
-        this.defaultCwd = defaultCwd;
-        this.dataDir = dataDir;
-    }
-    /** Populate sessionHasTitle from existing DB sessions on startup. */
-    hydrate() {
-        for (const s of this.store.listSessions()) {
-            if (s.title)
-                this.sessionHasTitle.add(s.id);
-        }
-    }
-    /** Create a new session in both bridge and store, inheriting the source session's config. */
-    async createSession(bridge, cwd, inheritFromSessionId) {
-        const sessionCwd = cwd ?? this.defaultCwd;
-        try {
-            const info = await stat(sessionCwd);
-            if (!info.isDirectory())
-                throw new Error("not a directory");
-        }
-        catch {
-            throw new Error(`Directory does not exist: ${sessionCwd}`);
-        }
-        const sourceSession = inheritFromSessionId
-            ? this.store.getSession(inheritFromSessionId)
-            : null;
-        const sessionId = await bridge.newSession(sessionCwd);
-        this.liveSessions.add(sessionId);
-        this.store.createSession(sessionId, sessionCwd);
-        // Inherit config options from source session
-        if (sourceSession) {
-            const inherited = [
-                { configId: "model", value: sourceSession.model },
-                { configId: "reasoning_effort", value: sourceSession.reasoning_effort },
-            ];
-            for (const { configId, value } of inherited) {
-                if (!value)
-                    continue;
-                try {
-                    await bridge.setConfigOption(sessionId, configId, value);
-                    this.store.updateSessionConfig(sessionId, configId, value);
-                }
-                catch {
-                    // Option may no longer be available; ignore
-                }
-            }
-        }
-        const session = this.store.getSession(sessionId);
-        return {
-            sessionId,
-            configOptions: session ? this.buildConfigOptions(session) : [],
-        };
-    }
-    /** Resume a session — returns event to send to the requesting client. */
-    async resumeSession(bridge, sessionId) {
-        const session = this.store.getSession(sessionId);
-        if (!session)
-            throw new Error("Session not found");
-        if (this.liveSessions.has(sessionId)) {
-            // Session already live — build configOptions with stored overrides
-            const configOptions = this.buildConfigOptions(session);
-            return {
-                type: "session_created",
-                sessionId,
-                cwd: session.cwd,
-                title: session.title,
-                configOptions,
-                busyKind: this.getBusyKind(sessionId) ?? undefined,
-            };
-        }
-        // Restore via ACP
-        this.restoringSessions.add(sessionId);
-        try {
-            const restored = await bridge.loadSession(sessionId, session.cwd);
-            this.liveSessions.add(sessionId);
-            if (session.title)
-                this.sessionHasTitle.add(sessionId);
-            const configOptions = this.applyStoredConfig(restored.configOptions, session);
-            console.log(`[session] restored: ${sessionId.slice(0, 8)}…`);
-            return {
-                type: "session_created",
-                sessionId,
-                cwd: session.cwd,
-                title: session.title,
-                configOptions,
-                busyKind: this.getBusyKind(sessionId) ?? undefined,
-            };
-        }
-        catch (err) {
-            console.error(`[session] restore failed:`, err);
-            throw err;
-        }
-        finally {
-            this.restoringSessions.delete(sessionId);
-        }
-    }
-    /** Build configOptions from cache, overriding currentValue with stored session values. */
-    buildConfigOptions(session) {
-        return this.applyStoredConfig(this.cachedConfigOptions, session);
-    }
-    /** Override currentValue in configOptions with stored session values. */
-    applyStoredConfig(configOptions, session) {
-        if (!configOptions.length)
-            return this.cachedConfigOptions;
-        const stored = {
-            model: session.model,
-            mode: session.mode,
-            reasoning_effort: session.reasoning_effort,
-        };
-        return configOptions.map((opt) => {
-            const override = stored[opt.id];
-            if (override)
-                return { ...opt, currentValue: override };
-            return opt;
-        });
-    }
-    /** Delete a session from store and clean up all state (including images). */
-    deleteSession(sessionId) {
-        this.store.deleteSession(sessionId);
-        this.liveSessions.delete(sessionId);
-        this.sessionHasTitle.delete(sessionId);
-        this.assistantBuffers.delete(sessionId);
-        this.thinkingBuffers.delete(sessionId);
-        this.activePrompts.delete(sessionId);
-        this.runningBashProcs.delete(sessionId);
-        // Remove uploaded images for this session
-        rm(join(this.dataDir, "images", sessionId), { recursive: true, force: true }).catch(() => { });
-    }
-    /** Flush assistant/thinking buffers to store. */
-    flushBuffers(sessionId) {
-        this.flushAssistantBuffer(sessionId);
-        this.flushThinkingBuffer(sessionId);
-    }
-    /** Flush only the assistant message buffer to store. */
-    flushAssistantBuffer(sessionId) {
-        const assistant = this.assistantBuffers.get(sessionId);
-        if (assistant) {
-            this.store.saveEvent(sessionId, "assistant_message", { text: assistant });
-            this.assistantBuffers.delete(sessionId);
-        }
-    }
-    /** Flush only the thinking buffer to store. */
-    flushThinkingBuffer(sessionId) {
-        const thinking = this.thinkingBuffers.get(sessionId);
-        if (thinking) {
-            this.store.saveEvent(sessionId, "thinking", { text: thinking });
-            this.thinkingBuffers.delete(sessionId);
-        }
-    }
-    /** Append to assistant message buffer. */
-    appendAssistant(sessionId, text) {
-        const buf = (this.assistantBuffers.get(sessionId) ?? "") + text;
-        this.assistantBuffers.set(sessionId, buf);
-    }
-    /** Append to thinking buffer. */
-    appendThinking(sessionId, text) {
-        const buf = (this.thinkingBuffers.get(sessionId) ?? "") + text;
-        this.thinkingBuffers.set(sessionId, buf);
-    }
-    /** Get CWD for a session (falls back to default). */
-    getSessionCwd(sessionId) {
-        return this.store.getSession(sessionId)?.cwd ?? this.defaultCwd;
-    }
-    getBusyKind(sessionId) {
-        if (this.runningBashProcs.has(sessionId))
-            return "bash";
-        if (this.activePrompts.has(sessionId))
-            return "agent";
-        return null;
-    }
-    /** Kill all running bash processes (for shutdown). */
-    killAllBashProcs() {
-        const forceSignal = process.platform === "win32" ? undefined : "SIGKILL";
-        for (const [, proc] of this.runningBashProcs)
-            proc.kill(forceSignal);
-        this.runningBashProcs.clear();
-    }
-}