chainlesschain 0.45.11 → 0.45.19

package/src/gateways/repl/chat-repl.js

@@ -0,0 +1 @@
+export { startChatRepl } from "../../repl/chat-repl.js";

package/src/gateways/ui/web-ui-server.js

@@ -0,0 +1 @@
+export { createWebUIServer } from "../../lib/web-ui-server.js";

package/src/gateways/ws/action-protocol.js

@@ -0,0 +1,83 @@
+export function handleSlashCommand(server, id, ws, message) {
+  const { sessionId, command } = message;
+  const handler = server.sessionHandlers.get(sessionId);
+
+  if (!handler) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_NOT_FOUND",
+      message: `No active session handler for: ${sessionId}`,
+    });
+    return;
+  }
+
+  handler.handleSlashCommand(command, id);
+}
+
+export async function handleOrchestrate(server, id, ws, message) {
+  const {
+    task,
+    cwd,
+    agents = 3,
+    ci = "npm test",
+    noCi = false,
+    strategy,
+  } = message;
+
+  if (!task || typeof task !== "string") {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "INVALID_TASK",
+      message: "task field required",
+    });
+    return;
+  }
+
+  try {
+    const { Orchestrator, TASK_SOURCE } = await import("../../lib/orchestrator.js");
+
+    const orch = new Orchestrator({
+      cwd: cwd || server.projectRoot || process.cwd(),
+      maxParallel: Math.min(parseInt(agents, 10) || 3, 10),
+      ciCommand: ci,
+      agents: strategy ? { strategy } : undefined,
+      verbose: false,
+    });
+
+    const wsNotifier = orch.notifier.addWebSocketChannel({
+      send: (data) => server._send(ws, data),
+      requestId: id,
+    });
+
+    orch.on("agent:output", (ev) => wsNotifier.sendAgentOutput(ev));
+    orch.on("task:added", (t) => wsNotifier.sendStatus(t));
+    orch.on("task:decomposing", (t) => wsNotifier.sendStatus(t));
+    orch.on("ci:checking", ({ task: t }) => wsNotifier.sendStatus(t));
+    orch.on("task:retrying", ({ task: t }) => wsNotifier.sendStatus(t));
+
+    const result = await orch.addTask(task, {
+      source: TASK_SOURCE.CLI,
+      cwd: cwd || server.projectRoot || process.cwd(),
+      runCI: !noCi,
+      notify: true,
+    });
+
+    server._send(ws, {
+      id,
+      type: "orchestrate:done",
+      taskId: result.id,
+      status: result.status,
+      retries: result.retries,
+      subtasks: result.subtasks?.length || 0,
+    });
+  } catch (err) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "ORCHESTRATE_FAILED",
+      message: err.message,
+    });
+  }
+}

package/src/gateways/ws/message-dispatcher.js

@@ -0,0 +1,73 @@
+export function createWsMessageDispatcher(server) {
+  return {
+    async dispatch(clientId, ws, message) {
+      const { id, type } = message;
+
+      if (!id) {
+        server._send(ws, {
+          type: "error",
+          code: "MISSING_ID",
+          message: 'Message must include an "id" field',
+        });
+        return;
+      }
+
+      const client = server.clients.get(clientId);
+      if (server.token && !client.authenticated && type !== "auth") {
+        server._send(ws, {
+          id,
+          type: "error",
+          code: "AUTH_REQUIRED",
+          message: "Authentication required. Send an auth message first.",
+        });
+        return;
+      }
+
+      const routes = {
+        auth: () => server._handleAuth(clientId, ws, message),
+        ping: () =>
+          server._send(ws, { id, type: "pong", serverTime: Date.now() }),
+        execute: () => server._executeCommand(id, ws, message.command, false),
+        stream: () => server._executeCommand(id, ws, message.command, true),
+        cancel: () => server._cancelRequest(id, ws),
+        "session-create": () => server._handleSessionCreate(id, ws, message),
+        "session-resume": () => server._handleSessionResume(id, ws, message),
+        "session-message": () => server._handleSessionMessage(id, ws, message),
+        "session-policy-update": () =>
+          server._handleSessionPolicyUpdate(id, ws, message),
+        "session-list": () => server._handleSessionList(id, ws),
+        "session-close": () => server._handleSessionClose(id, ws, message),
+        "slash-command": () => server._handleSlashCommand(id, ws, message),
+        "session-answer": () => server._handleSessionAnswer(id, ws, message),
+        "host-tool-result": () => server._handleHostToolResult(id, ws, message),
+        orchestrate: () => server._handleOrchestrate(id, ws, message),
+        "tasks-list": () => server._handleTasksList(id, ws),
+        "tasks-stop": () => server._handleTasksStop(id, ws, message),
+        "tasks-detail": () => server._handleTaskDetail(id, ws, message),
+        "tasks-history": () => server._handleTaskHistory(id, ws, message),
+        "worktree-diff": () => server._handleWorktreeDiff(id, ws, message),
+        "worktree-merge": () => server._handleWorktreeMerge(id, ws, message),
+        "worktree-merge-preview": () =>
+          server._handleWorktreeMergePreview(id, ws, message),
+        "worktree-automation-apply": () =>
+          server._handleWorktreeAutomationApply(id, ws, message),
+        "worktree-list": () => server._handleWorktreeList(id, ws),
+        "compression-stats": () =>
+          server._handleCompressionStats(id, ws, message),
+      };
+
+      const handler = routes[type];
+      if (!handler) {
+        server._send(ws, {
+          id,
+          type: "error",
+          code: "UNKNOWN_TYPE",
+          message: `Unknown message type: ${type}`,
+        });
+        return;
+      }
+
+      return handler();
+    },
+  };
+}

package/src/gateways/ws/session-protocol.js

@@ -0,0 +1,396 @@
+import {
+  RUNTIME_EVENTS,
+  createRuntimeEvent,
+} from "../../runtime/runtime-events.js";
+import { createSessionRecord } from "../../runtime/contracts/session-record.js";
+
+async function ensureSessionHandler(server, ws, session) {
+  if (server.sessionHandlers.has(session.id)) {
+    return server.sessionHandlers.get(session.id);
+  }
+
+  const { WebSocketInteractionAdapter } =
+    await import("../../lib/interaction-adapter.js");
+  session.interaction = new WebSocketInteractionAdapter(ws, session.id);
+
+  let handler;
+  if (session.type === "chat") {
+    const { WSChatHandler } = await import("../../lib/ws-chat-handler.js");
+    handler = new WSChatHandler({
+      session,
+      interaction: session.interaction,
+    });
+  } else {
+    const { WSAgentHandler } = await import("../../lib/ws-agent-handler.js");
+    handler = new WSAgentHandler({
+      session,
+      interaction: session.interaction,
+      db: server.sessionManager.db,
+    });
+  }
+
+  server.sessionHandlers.set(session.id, handler);
+  return handler;
+}
+
+export async function handleSessionCreate(server, id, ws, message) {
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured on this server",
+    });
+    return;
+  }
+
+  const {
+    sessionType,
+    provider,
+    model,
+    apiKey,
+    baseUrl,
+    projectRoot,
+    hostManagedToolPolicy,
+    worktreeIsolation,
+  } = message;
+
+  try {
+    const { sessionId } = server.sessionManager.createSession({
+      type: sessionType || "agent",
+      provider,
+      model,
+      apiKey,
+      baseUrl,
+      projectRoot,
+      hostManagedToolPolicy,
+      worktreeIsolation,
+    });
+
+    const session = server.sessionManager.getSession(sessionId);
+    const record = createSessionRecord(session, {
+      sessionId,
+      sessionType: sessionType || "agent",
+      provider,
+      model,
+      projectRoot: projectRoot || null,
+      baseProjectRoot: session?.baseProjectRoot || projectRoot || null,
+      worktreeIsolation: worktreeIsolation === true,
+      worktree: session?.worktree || null,
+      status: "created",
+    });
+
+    try {
+      await ensureSessionHandler(server, ws, session);
+    } catch (_err) {
+      // Session exists even if handler bootstrapping fails.
+    }
+
+    server.emit("session:create", { sessionId, type: sessionType || "agent" });
+    server.emit(
+      RUNTIME_EVENTS.SESSION_START,
+      createRuntimeEvent(
+        RUNTIME_EVENTS.SESSION_START,
+        {
+          sessionId,
+          sessionType: sessionType || "agent",
+          provider,
+          model,
+          projectRoot: projectRoot || null,
+          record,
+        },
+        { kind: "server", sessionId },
+      ),
+    );
+
+    server._send(ws, {
+      id,
+      type: "session-created",
+      sessionId,
+      sessionType: sessionType || "agent",
+      record,
+    });
+  } catch (err) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_CREATE_FAILED",
+      message: err.message,
+    });
+  }
+}
+
+export async function handleSessionResume(server, id, ws, message) {
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured",
+    });
+    return;
+  }
+
+  const { sessionId } = message;
+  const session = server.sessionManager.resumeSession(sessionId);
+
+  if (!session) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_NOT_FOUND",
+      message: `Session not found: ${sessionId}`,
+    });
+    return;
+  }
+
+  if (!server.sessionHandlers.has(sessionId)) {
+    try {
+      await ensureSessionHandler(server, ws, session);
+    } catch (_err) {
+      // Session resumed without live handler.
+    }
+  }
+
+  const history = (session.messages || []).filter((m) => m.role !== "system");
+  const record = createSessionRecord(session, {
+    history,
+    messageCount: history.length,
+    status: "resumed",
+  });
+
+  server.emit(
+    RUNTIME_EVENTS.SESSION_RESUME,
+    createRuntimeEvent(
+      RUNTIME_EVENTS.SESSION_RESUME,
+      {
+        sessionId: session.id,
+        historyCount: history.length,
+        sessionType: session.type || null,
+        record,
+      },
+      { kind: "server", sessionId: session.id },
+    ),
+  );
+
+  server._send(ws, {
+    id,
+    type: "session-resumed",
+    sessionId: session.id,
+    history,
+    record,
+  });
+}
+
+export function handleSessionMessage(server, id, ws, message) {
+  const { sessionId, content } = message;
+  const handler = server.sessionHandlers.get(sessionId);
+
+  if (!handler) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_NOT_FOUND",
+      message: `No active session handler for: ${sessionId}`,
+    });
+    return;
+  }
+
+  server.emit(
+    RUNTIME_EVENTS.SESSION_MESSAGE,
+    createRuntimeEvent(
+      RUNTIME_EVENTS.SESSION_MESSAGE,
+      {
+        sessionId,
+        messageId: id,
+        content,
+      },
+      { kind: "server", sessionId },
+    ),
+  );
+
+  handler
+    .handleMessage(content, id)
+    .then(() => {
+      if (server.sessionManager) {
+        try {
+          server.sessionManager.persistMessages(sessionId);
+        } catch (_err) {
+          // Non-critical.
+        }
+      }
+    })
+    .catch((err) => {
+      server._send(ws, {
+        id,
+        type: "error",
+        code: "MESSAGE_FAILED",
+        message: err.message,
+      });
+    });
+}
+
+export function handleSessionPolicyUpdate(server, id, ws, message) {
+  const { sessionId, hostManagedToolPolicy } = message;
+
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured",
+    });
+    return;
+  }
+
+  const session = server.sessionManager.updateSessionPolicy
+    ? server.sessionManager.updateSessionPolicy(
+        sessionId,
+        hostManagedToolPolicy,
+      )
+    : null;
+
+  if (!session) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_NOT_FOUND",
+      message: `Session not found: ${sessionId}`,
+    });
+    return;
+  }
+
+  server._send(ws, {
+    id,
+    type: "session-policy-updated",
+    success: true,
+    sessionId,
+  });
+}
+
+export function handleSessionList(server, id, ws) {
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured",
+    });
+    return;
+  }
+
+  const sessions = server.sessionManager.listSessions().map((session) => ({
+    ...session,
+    record: createSessionRecord(session, {
+      sessionId: session.id,
+      sessionType: session.type || null,
+      status: session.status || "listed",
+      history: Array.isArray(session.messages)
+        ? session.messages.filter((item) => item.role !== "system")
+        : [],
+    }),
+  }));
+  server._send(ws, {
+    id,
+    type: "session-list-result",
+    sessions,
+  });
+}
+
+export function handleSessionClose(server, id, ws, message) {
+  const { sessionId } = message;
+
+  const handler = server.sessionHandlers.get(sessionId);
+  if (handler && handler.destroy) {
+    handler.destroy();
+  }
+  server.sessionHandlers.delete(sessionId);
+
+  if (server.sessionManager) {
+    try {
+      server.sessionManager.closeSession(sessionId);
+    } catch (_err) {
+      // Non-critical.
+    }
+  }
+
+  server.emit("session:close", { sessionId });
+  server.emit(
+    RUNTIME_EVENTS.SESSION_END,
+    createRuntimeEvent(
+      RUNTIME_EVENTS.SESSION_END,
+      {
+        sessionId,
+        record: createSessionRecord(
+          { id: sessionId, type: null },
+          { sessionId, status: "closed", history: [], messageCount: 0 },
+        ),
+      },
+      { kind: "server", sessionId },
+    ),
+  );
+
+  server._send(ws, {
+    id,
+    type: "result",
+    success: true,
+    sessionId,
+  });
+}
+
+export function handleSessionAnswer(server, id, ws, message) {
+  const { sessionId, requestId, answer } = message;
+
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured",
+    });
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (session && session.interaction && session.interaction.resolveAnswer) {
+    session.interaction.resolveAnswer(requestId, answer);
+  }
+
+  server._send(ws, { id, type: "result", success: true });
+}
+
+export function handleHostToolResult(server, id, ws, message) {
+  const { sessionId, requestId, success, result, error, toolName } = message;
+
+  if (!server.sessionManager) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "NO_SESSION_SUPPORT",
+      message: "Session support not configured",
+    });
+    return;
+  }
+
+  const session = server.sessionManager.getSession(sessionId);
+  if (!session || !session.interaction) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "SESSION_NOT_FOUND",
+      message: `Session not found: ${sessionId}`,
+    });
+    return;
+  }
+
+  if (typeof session.interaction.resolveHostTool === "function") {
+    session.interaction.resolveHostTool(requestId, {
+      success: success !== false,
+      result,
+      error: error || null,
+      toolName: toolName || null,
+    });
+  }
+
+  server._send(ws, { id, type: "result", success: true });
+}

package/src/gateways/ws/task-protocol.js

@@ -0,0 +1,55 @@
+export async function handleTaskDetail(server, id, ws, message) {
+  try {
+    await server._ensureTaskManager();
+    if (!message.taskId) {
+      server._send(ws, {
+        id,
+        type: "error",
+        code: "NO_TASK",
+        message: "taskId required",
+      });
+      return;
+    }
+    const task = server._taskManager.getDetails(message.taskId);
+    server._send(ws, { id, type: "tasks-detail", task });
+  } catch (err) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "TASK_DETAIL_FAILED",
+      message: err.message,
+    });
+  }
+}
+
+export async function handleTaskHistory(server, id, ws, message) {
+  try {
+    await server._ensureTaskManager();
+    if (!message.taskId) {
+      server._send(ws, {
+        id,
+        type: "error",
+        code: "NO_TASK",
+        message: "taskId required",
+      });
+      return;
+    }
+    const history = server._taskManager.getHistory(message.taskId, {
+      limit: message.limit,
+      offset: message.offset,
+    });
+    server._send(ws, {
+      id,
+      type: "tasks-history",
+      taskId: message.taskId,
+      history,
+    });
+  } catch (err) {
+    server._send(ws, {
+      id,
+      type: "error",
+      code: "TASK_HISTORY_FAILED",
+      message: err.message,
+    });
+  }
+}