@lelouchhe/webagent 0.1.0 → 0.1.2

package/src/title-service.ts

@@ -1,81 +0,0 @@
-import type { AgentBridge } from "./bridge.ts";
-import type { SessionManager } from "./session-manager.ts";
-import type { Store } from "./store.ts";
-
-const TITLE_MODEL = "claude-haiku-4.5";
-
-export class TitleService {
-  private titleSessionId: string | null = null;
-  private activeSourceSessions = new Set<string>();
-  private cancelledSourceSessions = new Set<string>();
-  private defaultCwd: string;
-
-  private store: Store;
-  private sessions: SessionManager;
-
-  constructor(store: Store, sessions: SessionManager, defaultCwd: string) {
-    this.store = store;
-    this.sessions = sessions;
-    this.defaultCwd = defaultCwd;
-  }
-
-  /** Generate a title for the session (non-blocking, fire-and-forget). */
-  generate(bridge: AgentBridge, userMessage: string, sessionId: string, onTitle?: (title: string) => void): void {
-    if (this.sessions.sessionHasTitle.has(sessionId) || this.activeSourceSessions.has(sessionId)) return;
-    this._generate(bridge, userMessage, sessionId).then((title) => {
-      if (title && onTitle) onTitle(title);
-    }).catch((err) => {
-      console.error(`[title] generation failed:`, err);
-    });
-  }
-
-  private async _generate(
-    bridge: AgentBridge,
-    userMessage: string,
-    sessionId: string,
-  ): Promise<void> {
-    this.activeSourceSessions.add(sessionId);
-    const tsId = await this.ensureTitleSession(bridge);
-    if (!tsId) {
-      this.activeSourceSessions.delete(sessionId);
-      this.cancelledSourceSessions.delete(sessionId);
-      return;
-    }
-
-    try {
-      const prompt = `Generate a short title (max 30 chars, no quotes) for a chat that starts with this message. Reply with ONLY the title, nothing else:\n\n${userMessage.slice(0, 500)}`;
-      const title = await bridge.promptForText(tsId, prompt);
-      if (!title || this.cancelledSourceSessions.has(sessionId)) return;
-
-      const cleaned = title.replace(/^["']|["']$/g, "").trim().slice(0, 30);
-      if (!cleaned) return;
-
-      this.store.updateSessionTitle(sessionId, cleaned);
-      this.sessions.sessionHasTitle.add(sessionId);
-      return cleaned;
-    } finally {
-      this.activeSourceSessions.delete(sessionId);
-      this.cancelledSourceSessions.delete(sessionId);
-    }
-  }
-
-  async cancel(sessionId: string, bridge: AgentBridge): Promise<void> {
-    this.cancelledSourceSessions.add(sessionId);
-    if (!this.titleSessionId || !this.activeSourceSessions.has(sessionId)) return;
-    await bridge.cancel(this.titleSessionId);
-  }
-
-  /** Ensure the dedicated title session exists. Returns session ID or null. */
-  private async ensureTitleSession(bridge: AgentBridge): Promise<string | null> {
-    if (this.titleSessionId) return this.titleSessionId;
-    try {
-      const id = await bridge.newSession(this.defaultCwd, { silent: true });
-      this.sessions.liveSessions.add(id);
-      await bridge.setConfigOption(id, "model", TITLE_MODEL).catch(() => []);
-      this.titleSessionId = id;
-      return id;
-    } catch {
-      return null;
-    }
-  }
-}

package/src/types.ts

@@ -1,81 +0,0 @@
-import { z } from "zod/v4";
-import type * as acp from "@agentclientprotocol/sdk";
-
-// --- Config option (subset of ACP SessionConfigOption we care about) ---
-
-export interface ConfigOption {
-  type: "select";
-  id: string;
-  name: string;
-  category?: string | null;
-  currentValue: string;
-  options: Array<{ value: string; name: string }>;
-}
-
-// --- Agent events (server → client) ---
-
-export type AgentEvent =
-  | { type: "connected"; agent: { name: string; version: string }; configOptions: ConfigOption[]; cancelTimeout?: number }
-  | { type: "session_created"; sessionId: string; cwd?: string; title?: string | null; configOptions: ConfigOption[]; busyKind?: "agent" | "bash" }
-  | { type: "config_option_update"; sessionId: string; configOptions: ConfigOption[] }
-  | { type: "message_chunk"; sessionId: string; text: string }
-  | { type: "thought_chunk"; sessionId: string; text: string }
-  | { type: "tool_call"; sessionId: string; id: string; title: string; kind: string; rawInput?: unknown }
-  | { type: "tool_call_update"; sessionId: string; id: string; status: string; content?: unknown[] }
-  | { type: "plan"; sessionId: string; entries: unknown[] }
-  | { type: "permission_request"; requestId: string; sessionId: string; title: string; toolCallId?: string | null; options: acp.PermissionOption[] }
-  | { type: "prompt_done"; sessionId: string; stopReason: string }
-  | { type: "session_deleted"; sessionId: string }
-  | { type: "session_title_updated"; sessionId: string; title: string }
-  | { type: "session_expired"; sessionId: string }
-  | { type: "error"; message: string; sessionId?: string };
-
-// --- Inbound WS messages (client → server) ---
-
-const ImageSchema = z.object({
-  data: z.string(),
-  mimeType: z.string(),
-  path: z.string().optional(),
-});
-
-export const WsMessageSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("new_session"),
-    cwd: z.string().optional(),
-    inheritFromSessionId: z.string().optional(),
-  }),
-  z.object({ type: z.literal("resume_session"), sessionId: z.string() }),
-  z.object({ type: z.literal("delete_session"), sessionId: z.string() }),
-  z.object({
-    type: z.literal("prompt"),
-    sessionId: z.string(),
-    text: z.string(),
-    images: z.array(ImageSchema).optional(),
-  }),
-  z.object({
-    type: z.literal("permission_response"),
-    sessionId: z.string().optional(),
-    requestId: z.string(),
-    optionId: z.string().optional(),
-    optionName: z.string().optional(),
-    denied: z.boolean().optional(),
-  }),
-  z.object({ type: z.literal("cancel"), sessionId: z.string() }),
-  z.object({ type: z.literal("set_config_option"), sessionId: z.string(), configId: z.string(), value: z.string() }),
-  z.object({ type: z.literal("bash_exec"), sessionId: z.string(), command: z.string() }),
-  z.object({ type: z.literal("bash_cancel"), sessionId: z.string() }),
-]);
-
-export type WsMessage = z.infer<typeof WsMessageSchema>;
-
-// --- Utility ---
-
-export function errorMessage(err: unknown): string {
-  if (err instanceof Error) return err.message;
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}

package/src/ws-handler.ts

@@ -1,264 +0,0 @@
-import { spawn } from "node:child_process";
-import { WebSocket, WebSocketServer } from "ws";
-import { WsMessageSchema, errorMessage } from "./types.ts";
-import type { AgentEvent } from "./types.ts";
-import type { AgentBridge } from "./bridge.ts";
-import type { Store } from "./store.ts";
-import type { SessionManager } from "./session-manager.ts";
-import type { TitleService } from "./title-service.ts";
-import type { Config } from "./config.ts";
-
-interface WsHandlerDeps {
-  wss: WebSocketServer;
-  store: Store;
-  sessions: SessionManager;
-  titleService: TitleService;
-  getBridge: () => AgentBridge | null;
-  limits: Config["limits"];
-}
-
-function interruptBashProc(proc: ReturnType<SessionManager["runningBashProcs"]["get"]>): void {
-  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: WebSocketServer, event: AgentEvent, exclude?: WebSocket): void {
-  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: WebSocket, event: AgentEvent): void {
-  if (ws.readyState === WebSocket.OPEN) {
-    try { ws.send(JSON.stringify(event)); } catch { /* client gone mid-send */ }
-  }
-}
-
-export function setupWsHandler(deps: WsHandlerDeps): void {
-  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: unknown;
-      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: unknown) => {
-              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,
-            } as any);
-            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 } as any);
-              if (configOptions.length) {
-                broadcast(wss, { type: "config_option_update", sessionId: msg.sessionId, configOptions }, ws);
-              }
-            } catch (err: unknown) {
-              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: string) => (chunk: Buffer) => {
-              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 } as any);
-            };
-            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 } as any);
-            });
-
-            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 } as any);
-            });
-            break;
-          }
-
-          case "bash_cancel": {
-            interruptBashProc(sessions.runningBashProcs.get(msg.sessionId));
-            break;
-          }
-        }
-      } catch (err: unknown) {
-        send(ws, { type: "error", message: errorMessage(err) });
-      }
-    });
-
-    ws.on("close", () => {
-      clearInterval(pingInterval);
-      console.log(`[ws] client disconnected (total: ${wss.clients.size})`);
-    });
-  });
-}