@lelouchhe/webagent 0.1.0 → 0.1.2

package/lib/ws-handler.js

@@ -0,0 +1,254 @@
+import { spawn } from "node:child_process";
+import { WebSocket, WebSocketServer } from "ws";
+import { WsMessageSchema, errorMessage } from "./types.js";
+function interruptBashProc(proc) {
+    if (!proc)
+        return;
+    if (typeof proc.pid === "number") {
+        try {
+            process.kill(-proc.pid, "SIGINT");
+            return;
+        }
+        catch {
+            // Fall through to direct child kill when the process is not a group leader.
+        }
+    }
+    proc.kill("SIGINT");
+}
+export function broadcast(wss, event, exclude) {
+    const msg = JSON.stringify(event);
+    for (const client of wss.clients) {
+        if (client.readyState === WebSocket.OPEN && client !== exclude) {
+            try {
+                client.send(msg);
+            }
+            catch { /* client gone mid-send */ }
+        }
+    }
+}
+function send(ws, event) {
+    if (ws.readyState === WebSocket.OPEN) {
+        try {
+            ws.send(JSON.stringify(event));
+        }
+        catch { /* client gone mid-send */ }
+    }
+}
+export function setupWsHandler(deps) {
+    const { wss, store, sessions, titleService, getBridge, limits } = deps;
+    wss.on("connection", (ws) => {
+        console.log(`[ws] client connected (total: ${wss.clients.size})`);
+        const pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN)
+                ws.ping();
+        }, 30_000);
+        ws.on("message", async (raw) => {
+            // Parse & validate
+            let parsed;
+            try {
+                parsed = JSON.parse(raw.toString());
+            }
+            catch {
+                send(ws, { type: "error", message: "Invalid JSON" });
+                return;
+            }
+            const result = WsMessageSchema.safeParse(parsed);
+            if (!result.success) {
+                send(ws, { type: "error", message: `Invalid message: ${result.error.message}` });
+                return;
+            }
+            const msg = result.data;
+            try {
+                const bridge = getBridge();
+                switch (msg.type) {
+                    case "new_session": {
+                        if (!bridge) {
+                            send(ws, { type: "error", message: "Agent not ready yet" });
+                            return;
+                        }
+                        const created = await sessions.createSession(bridge, msg.cwd, msg.inheritFromSessionId);
+                        if (created.configOptions.length) {
+                            send(ws, {
+                                type: "config_option_update",
+                                sessionId: created.sessionId,
+                                configOptions: created.configOptions,
+                            });
+                        }
+                        break;
+                    }
+                    case "resume_session": {
+                        if (!bridge) {
+                            send(ws, { type: "error", message: "Agent not ready yet" });
+                            return;
+                        }
+                        try {
+                            const event = await sessions.resumeSession(bridge, msg.sessionId);
+                            send(ws, event);
+                        }
+                        catch {
+                            send(ws, { type: "session_expired", sessionId: msg.sessionId });
+                        }
+                        break;
+                    }
+                    case "delete_session": {
+                        sessions.deleteSession(msg.sessionId);
+                        broadcast(wss, { type: "session_deleted", sessionId: msg.sessionId });
+                        console.log(`[session] deleted: ${msg.sessionId.slice(0, 8)}…`);
+                        break;
+                    }
+                    case "prompt": {
+                        if (!bridge) {
+                            send(ws, { type: "error", message: "No active bridge" });
+                            return;
+                        }
+                        const images = msg.images;
+                        const userData = {
+                            text: msg.text,
+                            ...(images && { images: images.map((i) => ({ path: i.path, mimeType: i.mimeType })) }),
+                        };
+                        store.saveEvent(msg.sessionId, "user_message", userData);
+                        store.updateSessionLastActive(msg.sessionId);
+                        // Generate title once the session actually gets one; canceled/failed attempts can retry later.
+                        if (!sessions.sessionHasTitle.has(msg.sessionId)) {
+                            titleService.generate(bridge, msg.text, msg.sessionId, (title) => {
+                                broadcast(wss, { type: "session_title_updated", sessionId: msg.sessionId, title });
+                            });
+                        }
+                        // Broadcast to other clients
+                        const userEvent = JSON.stringify({ type: "user_message", sessionId: msg.sessionId, ...userData });
+                        for (const client of wss.clients) {
+                            if (client !== ws && client.readyState === WebSocket.OPEN) {
+                                client.send(userEvent);
+                            }
+                        }
+                        sessions.activePrompts.add(msg.sessionId);
+                        bridge.prompt(msg.sessionId, msg.text, images).catch((err) => {
+                            send(ws, { type: "error", message: errorMessage(err) });
+                        });
+                        break;
+                    }
+                    case "permission_response": {
+                        if (!bridge)
+                            return;
+                        if (msg.denied) {
+                            bridge.denyPermission(msg.requestId);
+                        }
+                        else if (msg.optionId) {
+                            bridge.resolvePermission(msg.requestId, msg.optionId);
+                        }
+                        if (msg.sessionId) {
+                            store.saveEvent(msg.sessionId, "permission_response", {
+                                requestId: msg.requestId,
+                                optionName: msg.optionName || "",
+                                denied: !!msg.denied,
+                            });
+                        }
+                        broadcast(wss, {
+                            type: "permission_resolved",
+                            sessionId: msg.sessionId,
+                            requestId: msg.requestId,
+                            optionName: msg.optionName || "",
+                            denied: !!msg.denied,
+                        });
+                        break;
+                    }
+                    case "cancel": {
+                        interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
+                        if (bridge) {
+                            await titleService.cancel(msg.sessionId, bridge);
+                        }
+                        await bridge?.cancel(msg.sessionId);
+                        break;
+                    }
+                    case "set_config_option": {
+                        if (!bridge) {
+                            send(ws, { type: "error", message: "Agent not ready yet" });
+                            return;
+                        }
+                        try {
+                            const configOptions = await bridge.setConfigOption(msg.sessionId, msg.configId, msg.value);
+                            for (const opt of configOptions) {
+                                store.updateSessionConfig(msg.sessionId, opt.id, opt.currentValue);
+                            }
+                            send(ws, { type: "config_set", configId: msg.configId, value: msg.value });
+                            if (configOptions.length) {
+                                broadcast(wss, { type: "config_option_update", sessionId: msg.sessionId, configOptions }, ws);
+                            }
+                        }
+                        catch (err) {
+                            send(ws, { type: "error", message: `Failed to set ${msg.configId}: ${errorMessage(err)}` });
+                        }
+                        break;
+                    }
+                    case "bash_exec": {
+                        if (sessions.runningBashProcs.has(msg.sessionId)) {
+                            send(ws, { type: "error", message: "A bash command is already running in this session" });
+                            return;
+                        }
+                        const cwd = sessions.getSessionCwd(msg.sessionId);
+                        store.saveEvent(msg.sessionId, "bash_command", { command: msg.command });
+                        // Broadcast to other clients
+                        const bashEvent = JSON.stringify({
+                            type: "bash_command", sessionId: msg.sessionId, command: msg.command,
+                        });
+                        for (const client of wss.clients) {
+                            if (client !== ws && client.readyState === WebSocket.OPEN) {
+                                client.send(bashEvent);
+                            }
+                        }
+                        const child = spawn("bash", ["-c", msg.command], {
+                            cwd,
+                            detached: true,
+                            env: { ...process.env, TERM: "dumb" },
+                            stdio: ["ignore", "pipe", "pipe"],
+                        });
+                        sessions.runningBashProcs.set(msg.sessionId, child);
+                        let output = "";
+                        let outputTruncated = false;
+                        const onData = (stream) => (chunk) => {
+                            const text = chunk.toString();
+                            if (!outputTruncated) {
+                                output += text;
+                                if (output.length > limits.bash_output) {
+                                    output = output.slice(-limits.bash_output);
+                                    outputTruncated = true;
+                                }
+                            }
+                            else {
+                                // Keep only the tail within the limit
+                                output = (output + text).slice(-limits.bash_output);
+                            }
+                            broadcast(wss, { type: "bash_output", sessionId: msg.sessionId, text, stream });
+                        };
+                        child.stdout.on("data", onData("stdout"));
+                        child.stderr.on("data", onData("stderr"));
+                        child.on("close", (code, signal) => {
+                            sessions.runningBashProcs.delete(msg.sessionId);
+                            const stored = outputTruncated ? "[truncated]\n" + output : output;
+                            store.saveEvent(msg.sessionId, "bash_result", { output: stored, code, signal });
+                            broadcast(wss, { type: "bash_done", sessionId: msg.sessionId, code, signal });
+                        });
+                        child.on("error", (err) => {
+                            sessions.runningBashProcs.delete(msg.sessionId);
+                            const errMsg = errorMessage(err);
+                            store.saveEvent(msg.sessionId, "bash_result", { output: errMsg, code: -1, signal: null });
+                            broadcast(wss, { type: "bash_done", sessionId: msg.sessionId, code: -1, signal: null, error: errMsg });
+                        });
+                        break;
+                    }
+                    case "bash_cancel": {
+                        interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                send(ws, { type: "error", message: errorMessage(err) });
+            }
+        });
+        ws.on("close", () => {
+            clearInterval(pingInterval);
+            console.log(`[ws] client disconnected (total: ${wss.clients.size})`);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lelouchhe/webagent",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A terminal-style web UI for ACP-compatible agents",
   "type": "module",
   "license": "MIT",
@@ -25,12 +25,12 @@
   },
   "files": [
     "bin/",
-    "src/",
+    "lib/",
     "dist/",
     "config.toml"
   ],
   "scripts": {
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run build && npx tsc -p tsconfig.build.json",
     "build": "node scripts/build.js",
     "start": "node --experimental-strip-types src/server.ts --config config.toml",
     "test": "node --experimental-strip-types --test test/*.test.ts",
@@ -51,6 +51,7 @@
     "@types/node": "^25.3.3",
     "@types/ws": "^8.18.1",
     "happy-dom": "^20.8.3",
-    "playwright": "^1.58.2"
+    "playwright": "^1.58.2",
+    "typescript": "^5.9.3"
   }
 }

package/dist/js/app.mmjqzu9r.js

@@ -1,10 +0,0 @@
-// Boot entry point — imports all modules and starts the app
-
-import './render.mmjqzu9r.js';    // theme, click-to-collapse listeners
-import './commands.mmjqzu9r.js';  // slash menu listeners
-import './images.mmjqzu9r.js';    // attach/paste listeners
-import './input.mmjqzu9r.js';     // keyboard/send listeners
-import { connect } from './connection.mmjqzu9r.js';
-
-connect();
-if ('serviceWorker' in navigator) navigator.serviceWorker.register('/sw.js');

package/src/bridge.ts

@@ -1,317 +0,0 @@
-import { spawn, ChildProcess } from "node:child_process";
-import { Writable, Readable } from "node:stream";
-import { EventEmitter } from "node:events";
-import * as acp from "@agentclientprotocol/sdk";
-import type { AgentEvent, ConfigOption } from "./types.ts";
-
-export class AgentBridge extends EventEmitter {
-  private proc: ChildProcess | null = null;
-  private conn: acp.ClientSideConnection | null = null;
-  private permissionResolvers = new Map<string, (resp: acp.RequestPermissionResponse) => void>();
-  private permissionRequestSessions = new Map<string, string>();
-  private silentSessions = new Set<string>(); // Sessions that don't emit events
-  private silentBuffers = new Map<string, string>(); // Text buffers for silent sessions
-  readonly agentCmd: string;
-
-  constructor(agentCmd: string) {
-    super();
-    this.agentCmd = agentCmd;
-  }
-
-  async start(): Promise<void> {
-    const [cmd, ...args] = this.agentCmd.split(/\s+/);
-    this.proc = spawn(cmd, args, {
-      stdio: ["pipe", "pipe", "inherit"],
-    });
-
-    if (!this.proc.stdin || !this.proc.stdout) {
-      throw new Error(`Failed to start: ${this.agentCmd}`);
-    }
-
-    const input = Writable.toWeb(this.proc.stdin);
-    const output = Readable.toWeb(this.proc.stdout) as ReadableStream<Uint8Array>;
-    const stream = acp.ndJsonStream(input, output);
-
-    const client: acp.Client = {
-      requestPermission: async (params) => this.handlePermission(params),
-      sessionUpdate: async (params) => this.handleSessionUpdate(params),
-      readTextFile: async (params) => this.handleReadFile(params),
-      writeTextFile: async (params) => this.handleWriteFile(params),
-    };
-
-    this.conn = new acp.ClientSideConnection((_agent) => client, stream);
-
-    const init = await this.conn.initialize({
-      protocolVersion: acp.PROTOCOL_VERSION,
-      clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true },
-        terminal: true,
-      },
-    });
-
-    const agentInfo = init.agentInfo;
-    this.emit("event", {
-      type: "connected",
-      agent: {
-        name: agentInfo?.name ?? "unknown",
-        version: agentInfo?.version ?? "?",
-      },
-      configOptions: [],
-    } satisfies AgentEvent);
-  }
-
-  async newSession(cwd: string, opts?: { silent?: boolean }): Promise<string> {
-    if (!this.conn) throw new Error("Not connected");
-    const session = await this.conn.newSession({ cwd, mcpServers: [] });
-    if (!opts?.silent) {
-      this.emit("event", {
-        type: "session_created",
-        sessionId: session.sessionId,
-        cwd,
-        configOptions: (session as any).configOptions ?? [],
-      } satisfies AgentEvent);
-    }
-    return session.sessionId;
-  }
-
-  async loadSession(sessionId: string, cwd: string): Promise<{ sessionId: string; configOptions: ConfigOption[] }> {
-    if (!this.conn) throw new Error("Not connected");
-    const session = await this.conn.loadSession({ sessionId, cwd, mcpServers: [] });
-    this.emit("event", {
-      type: "session_created",
-      sessionId: session.sessionId,
-      cwd,
-      configOptions: (session as any).configOptions ?? [],
-    } satisfies AgentEvent);
-    return { sessionId: session.sessionId, configOptions: (session as any).configOptions ?? [] };
-  }
-
-  async setConfigOption(sessionId: string, configId: string, value: string): Promise<ConfigOption[]> {
-    if (!this.conn) throw new Error("Not connected");
-    const result = await this.conn.setSessionConfigOption({ sessionId, configId, value });
-    return (result as any).configOptions ?? [];
-  }
-
-  async prompt(
-    sessionId: string,
-    text: string,
-    images?: Array<{ data: string; mimeType: string }>,
-  ): Promise<void> {
-    if (!this.conn) throw new Error("Not connected");
-    try {
-      const promptParts: Array<
-        | { type: "text"; text: string }
-        | { type: "image"; data: string; mimeType: string }
-      > = [];
-      if (images) {
-        for (const img of images) {
-          promptParts.push({ type: "image", data: img.data, mimeType: img.mimeType });
-        }
-      }
-      promptParts.push({ type: "text", text });
-      const result = await this.conn.prompt({
-        sessionId,
-        prompt: promptParts,
-      });
-      this.emit("event", {
-        type: "prompt_done",
-        sessionId,
-        stopReason: result.stopReason ?? "end_turn",
-      } satisfies AgentEvent);
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
-      if (/cancel/i.test(message)) {
-        this.emit("event", {
-          type: "prompt_done",
-          sessionId,
-          stopReason: "cancelled",
-        } satisfies AgentEvent);
-        return;
-      }
-      this.emit("event", { type: "error", sessionId, message } satisfies AgentEvent);
-    }
-  }
-
-  async cancel(sessionId: string): Promise<void> {
-    for (const [requestId, requestSessionId] of this.permissionRequestSessions) {
-      if (requestSessionId === sessionId) {
-        this.denyPermission(requestId);
-      }
-    }
-    await this.conn?.cancel({ sessionId });
-  }
-
-  /** Send a prompt and collect the full text response without emitting events. */
-  async promptForText(sessionId: string, text: string): Promise<string> {
-    if (!this.conn) throw new Error("Not connected");
-    this.silentSessions.add(sessionId);
-    this.silentBuffers.set(sessionId, "");
-    try {
-      await this.conn.prompt({ sessionId, prompt: [{ type: "text", text }] });
-      return this.silentBuffers.get(sessionId) ?? "";
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : (typeof err === "string" ? err : JSON.stringify(err));
-      if (/cancel/i.test(message)) {
-        return "";
-      }
-      throw err;
-    } finally {
-      this.silentSessions.delete(sessionId);
-      this.silentBuffers.delete(sessionId);
-    }
-  }
-
-  resolvePermission(requestId: string, optionId: string): void {
-    const resolve = this.permissionResolvers.get(requestId);
-    if (resolve) {
-      resolve({ outcome: { outcome: "selected", optionId } });
-      this.permissionResolvers.delete(requestId);
-      this.permissionRequestSessions.delete(requestId);
-    }
-  }
-
-  denyPermission(requestId: string): void {
-    const resolve = this.permissionResolvers.get(requestId);
-    if (resolve) {
-      resolve({ outcome: { outcome: "cancelled" } });
-      this.permissionResolvers.delete(requestId);
-      this.permissionRequestSessions.delete(requestId);
-    }
-  }
-
-  async shutdown(): Promise<void> {
-    // Reject all pending permissions
-    for (const [id, resolve] of this.permissionResolvers) {
-      resolve({ outcome: { outcome: "cancelled" } });
-    }
-    this.permissionResolvers.clear();
-    this.permissionRequestSessions.clear();
-
-    if (this.proc && this.proc.exitCode === null) {
-      this.proc.kill();
-      await new Promise<void>((resolve) => {
-        const timer = setTimeout(() => {
-          this.proc?.kill("SIGKILL");
-          resolve();
-        }, 5000);
-        this.proc?.on("exit", () => {
-          clearTimeout(timer);
-          resolve();
-        });
-      });
-    }
-    this.proc = null;
-    this.conn = null;
-  }
-
-  // --- ACP Client callbacks ---
-
-  private handlePermission(params: acp.RequestPermissionRequest): Promise<acp.RequestPermissionResponse> {
-    const requestId = crypto.randomUUID();
-    const title = params.toolCall?.title ?? "Permission requested";
-    const toolCallId = params.toolCall?.toolCallId ?? null;
-
-    return new Promise((resolve) => {
-      // Register resolver BEFORE emitting, so synchronous auto-approve can find it
-      this.permissionResolvers.set(requestId, resolve);
-      this.permissionRequestSessions.set(requestId, params.sessionId);
-      this.emit("event", {
-        type: "permission_request",
-        requestId,
-        sessionId: params.sessionId,
-        title,
-        toolCallId,
-        options: params.options,
-      } satisfies AgentEvent);
-    });
-  }
-
-  private handleSessionUpdate(params: acp.SessionNotification): Promise<void> {
-    const update = params.update;
-    const sessionId = params.sessionId;
-
-    // Silent sessions: only buffer text, don't emit events
-    if (this.silentSessions.has(sessionId)) {
-      if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-        const buf = (this.silentBuffers.get(sessionId) ?? "") + update.content.text;
-        this.silentBuffers.set(sessionId, buf);
-      }
-      return Promise.resolve();
-    }
-
-    switch (update.sessionUpdate) {
-      case "agent_message_chunk":
-        if (update.content.type === "text") {
-          this.emit("event", {
-            type: "message_chunk",
-            sessionId,
-            text: update.content.text,
-          } satisfies AgentEvent);
-        }
-        break;
-
-      case "agent_thought_chunk":
-        if (update.content.type === "text") {
-          this.emit("event", {
-            type: "thought_chunk",
-            sessionId,
-            text: update.content.text,
-          } satisfies AgentEvent);
-        }
-        break;
-
-      case "tool_call":
-        this.emit("event", {
-          type: "tool_call",
-          sessionId,
-          id: update.toolCallId ?? "",
-          title: update.title ?? "",
-          kind: update.kind ?? "unknown",
-          rawInput: update.rawInput,
-        } satisfies AgentEvent);
-        break;
-
-      case "tool_call_update":
-        this.emit("event", {
-          type: "tool_call_update",
-          sessionId,
-          id: update.toolCallId ?? "",
-          status: update.status ?? "",
-          content: update.content,
-        } satisfies AgentEvent);
-        break;
-
-      case "plan":
-        this.emit("event", {
-          type: "plan",
-          sessionId,
-          entries: update.entries ?? [],
-        } satisfies AgentEvent);
-        break;
-
-      case "config_option_update":
-        this.emit("event", {
-          type: "config_option_update",
-          sessionId,
-          configOptions: (update as any).configOptions ?? [],
-        } satisfies AgentEvent);
-        break;
-    }
-
-    return Promise.resolve();
-  }
-
-  private async handleReadFile(params: acp.ReadTextFileRequest): Promise<acp.ReadTextFileResponse> {
-    const { readFile } = await import("node:fs/promises");
-    const content = await readFile(params.path, "utf-8");
-    return { content };
-  }
-
-  private async handleWriteFile(params: acp.WriteTextFileRequest): Promise<acp.WriteTextFileResponse> {
-    const { writeFile, mkdir } = await import("node:fs/promises");
-    const { dirname } = await import("node:path");
-    await mkdir(dirname(params.path), { recursive: true });
-    await writeFile(params.path, params.content);
-    return {};
-  }
-}

package/src/config.ts

@@ -1,65 +0,0 @@
-import { readFileSync } from "node:fs";
-import { parse as parseTOML } from "smol-toml";
-import { z } from "zod";
-
-const ConfigSchema = z.object({
-  port: z.number().int().positive().default(6800),
-  data_dir: z.string().default("data"),
-  default_cwd: z.string().default(process.cwd()),
-  public_dir: z.string().default("dist"),
-  agent_cmd: z.string().default("copilot --acp"),
-
-  limits: z.object({
-    bash_output: z.number().int().positive().default(1_048_576),   // 1 MB
-    image_upload: z.number().int().positive().default(10_485_760), // 10 MB
-    cancel_timeout: z.number().int().nonnegative().default(10_000), // 10s; 0 disables
-  }).default({
-    bash_output: 1_048_576,
-    image_upload: 10_485_760,
-    cancel_timeout: 10_000,
-  }),
-});
-
-export type Config = z.infer<typeof ConfigSchema>;
-
-let _config: Config | null = null;
-
-function parseArgs(): string | null {
-  const idx = process.argv.indexOf("--config");
-  if (idx !== -1 && idx + 1 < process.argv.length) {
-    return process.argv[idx + 1];
-  }
-  return null;
-}
-
-export function loadConfig(): Config {
-  const configPath = parseArgs();
-  let raw: Record<string, unknown> = {};
-
-  if (configPath) {
-    try {
-      const content = readFileSync(configPath, "utf-8");
-      raw = parseTOML(content) as Record<string, unknown>;
-      console.log(`[config] loaded: ${configPath}`);
-    } catch (err) {
-      console.error(`[config] failed to read ${configPath}:`, err);
-      process.exit(1);
-    }
-  } else {
-    console.log("[config] no --config provided, using defaults");
-  }
-
-  const result = ConfigSchema.safeParse(raw);
-  if (!result.success) {
-    console.error("[config] validation error:", result.error.format());
-    process.exit(1);
-  }
-
-  _config = result.data;
-  return _config;
-}
-
-export function getConfig(): Config {
-  if (!_config) throw new Error("Config not loaded. Call loadConfig() first.");
-  return _config;
-}