chainlesschain 0.45.12 → 0.45.20

package/src/commands/chat.js

@@ -3,9 +3,7 @@
  * chainlesschain chat [--model] [--provider] [--agent]
  */
 
-import { startChatRepl } from "../repl/chat-repl.js";
-import { startAgentRepl } from "../repl/agent-repl.js";
-import { loadConfig } from "../lib/config-manager.js";
+import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 
 export function registerChatCommand(program) {
   program
@@ -24,19 +22,19 @@ export function registerChatCommand(program) {
     )
     .option("--session <id>", "Resume a previous session (agent mode)")
     .action(async (options) => {
-      const config = loadConfig();
-      const replOptions = {
-        model: options.model || config.llm?.model || "qwen2:7b",
-        provider: options.provider || config.llm?.provider || "ollama",
-        baseUrl: options.baseUrl || config.llm?.baseUrl,
-        apiKey: options.apiKey || config.llm?.apiKey,
+      const factory = createAgentRuntimeFactory();
+      const runtimeOptions = {
+        model: options.model,
+        provider: options.provider,
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
         sessionId: options.session,
       };
 
       if (options.agent) {
-        await startAgentRepl(replOptions);
+        await factory.createAgentRuntime(runtimeOptions).startAgentSession();
       } else {
-        await startChatRepl(replOptions);
+        await factory.createChatRuntime(runtimeOptions).startChatSession();
       }
     });
 }

package/src/commands/serve.js

@@ -3,11 +3,8 @@
  * chainlesschain serve [--port] [--host] [--token] [--max-connections] [--timeout] [--allow-remote] [--project]
  */
 
-import chalk from "chalk";
 import { logger } from "../lib/logger.js";
-import { ChainlessChainWSServer } from "../lib/ws-server.js";
-import { WSSessionManager } from "../lib/ws-session-manager.js";
-import { bootstrap } from "../runtime/bootstrap.js";
+import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 
 export function registerServeCommand(program) {
   program
@@ -31,109 +28,17 @@ export function registerServeCommand(program) {
     )
     .option("--project <path>", "Default project root for sessions")
     .action(async (opts) => {
-      const port = parseInt(opts.port, 10);
-      const maxConnections = parseInt(opts.maxConnections, 10);
-      const timeout = parseInt(opts.timeout, 10);
-      let host = opts.host;
-
-      // Validation
-      if (isNaN(port) || port < 1 || port > 65535) {
-        logger.error("Invalid port number. Must be between 1 and 65535.");
-        process.exit(1);
-      }
-
-      if (opts.allowRemote) {
-        if (!opts.token) {
-          logger.error("--allow-remote requires --token for security.");
-          process.exit(1);
-        }
-        host = "0.0.0.0";
-      }
-
-      // Bootstrap headless runtime for DB access
-      let db = null;
-      try {
-        const ctx = await bootstrap({ skipDb: false });
-        db = ctx.db?.getDb?.() || null;
-      } catch (_err) {
-        logger.log(
-          chalk.yellow(
-            "  Warning: Database not available, sessions will be in-memory only",
-          ),
-        );
-      }
-
-      // Create session manager
-      const sessionManager = new WSSessionManager({
-        db,
-        defaultProjectRoot: opts.project || process.cwd(),
-      });
-
-      const server = new ChainlessChainWSServer({
-        port,
-        host,
-        token: opts.token || null,
-        maxConnections,
-        timeout,
-        sessionManager,
-      });
-
-      // Event logging
-      server.on("connection", ({ clientId, ip }) => {
-        logger.log(chalk.green(`  + Client connected: ${clientId} (${ip})`));
-      });
-
-      server.on("disconnection", ({ clientId, reason }) => {
-        const extra = reason ? ` (${reason})` : "";
-        logger.log(
-          chalk.yellow(`  - Client disconnected: ${clientId}${extra}`),
-        );
-      });
-
-      server.on("command:start", ({ id, command }) => {
-        logger.log(chalk.cyan(`  > [${id}] ${command}`));
-      });
-
-      server.on("command:end", ({ id, exitCode }) => {
-        const color = exitCode === 0 ? chalk.green : chalk.red;
-        logger.log(color(`  < [${id}] exit ${exitCode}`));
-      });
-
-      server.on("session:create", ({ sessionId, type }) => {
-        logger.log(chalk.green(`  + Session created: ${sessionId} (${type})`));
-      });
-
-      server.on("session:close", ({ sessionId }) => {
-        logger.log(chalk.yellow(`  - Session closed: ${sessionId}`));
-      });
-
-      // Graceful shutdown
-      const shutdown = async () => {
-        logger.log("\n" + chalk.yellow("Shutting down WebSocket server..."));
-        await server.stop();
-        process.exit(0);
-      };
-
-      process.on("SIGINT", shutdown);
-      process.on("SIGTERM", shutdown);
-
       try {
-        await server.start();
-
-        logger.log("");
-        logger.log(chalk.bold("  ChainlessChain WebSocket Server"));
-        logger.log("");
-        logger.log(`  Address:  ${chalk.cyan(`ws://${host}:${port}`)}`);
-        logger.log(
-          `  Auth:     ${opts.token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
-        );
-        logger.log(`  Sessions: ${chalk.green("enabled")}`);
-        logger.log(`  Project:  ${opts.project || process.cwd()}`);
-        logger.log(`  Max conn: ${maxConnections}`);
-        logger.log(`  Timeout:  ${timeout}ms`);
-        logger.log("");
-        logger.log(chalk.dim("  Press Ctrl+C to stop"));
-        logger.log("");
+        const runtime = createAgentRuntimeFactory().createServerRuntime({
+          port: parseInt(opts.port, 10),
+          host: opts.host,
+          token: opts.token,
+          maxConnections: parseInt(opts.maxConnections, 10),
+          timeout: parseInt(opts.timeout, 10),
+          allowRemote: opts.allowRemote,
+          project: opts.project,
+        });
+        await runtime.startServer();
       } catch (err) {
         logger.error(`Failed to start server: ${err.message}`);
         process.exit(1);

package/src/commands/session.js

@@ -18,6 +18,10 @@ import {
   rebuildMessages,
   sessionExists,
   readEvents,
+  migrateLegacySessions,
+  migrateLegacySessionsBatch,
+  validateJsonlSession,
+  validateAllJsonlSessions,
 } from "../lib/jsonl-session-store.js";
 import { feature } from "../lib/feature-flags.js";
 
@@ -301,4 +305,101 @@ export function registerSessionCommand(program) {
         process.exit(1);
       }
     });
+
+  session
+    .command("migrate")
+    .description("Migrate legacy JSON session files to JSONL")
+    .argument("[source]", "Directory containing legacy .json session files")
+    .option("--dry-run", "Show what would migrate without writing files")
+    .option("--force", "Overwrite existing JSONL sessions")
+    .option("--no-archive", "Do not keep .migrated.json backups")
+    .option("--sample-size <n>", "Validate N migrated sessions after migration", "3")
+    .option("--retry-failures", "Retry failed migrations once")
+    .option("--json", "Output as JSON")
+    .action(async (source, options) => {
+      try {
+        const report = migrateLegacySessionsBatch(source, {
+          dryRun: options.dryRun,
+          force: options.force,
+          archive: options.archive,
+          sampleSize: parseInt(options.sampleSize, 10) || 3,
+          retryFailures: options.retryFailures,
+        });
+        const results = report.results || migrateLegacySessions(source, options);
+
+        if (options.json) {
+          console.log(JSON.stringify(report, null, 2));
+          return;
+        }
+
+        if (results.length === 0) {
+          logger.info("No legacy JSON session files found.");
+          return;
+        }
+
+        for (const result of results) {
+          if (result.skipped) {
+            logger.log(
+              `${chalk.yellow("skip")} ${result.file} -> ${result.sessionId} (${result.reason})`,
+            );
+            continue;
+          }
+          logger.log(
+            `${chalk.green(options.dryRun ? "plan" : "migrated")} ${result.file} -> ${result.sessionId} (${result.messageCount} messages)`,
+          );
+        }
+
+        logger.log(
+          chalk.gray(
+            `summary: scanned ${report.summary.scanned}, migrated ${report.summary.migrated}, skipped ${report.summary.skipped}, failed ${report.summary.failed}, retries ${report.summary.retries}`,
+          ),
+        );
+
+        if (report.sampledValidation?.length) {
+          for (const item of report.sampledValidation) {
+            const label = item.valid && item.matchesExpectedMessages
+              ? chalk.green("sample-ok")
+              : chalk.red("sample-fail");
+            logger.log(
+              `${label} ${item.sessionId} (${item.messageCount}/${item.expectedMessageCount} messages)`,
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  session
+    .command("validate")
+    .description("Validate JSONL session files")
+    .argument("[id]", "Session ID to validate")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const result = id
+          ? validateJsonlSession(id)
+          : validateAllJsonlSessions();
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        const results = Array.isArray(result) ? result : [result];
+        for (const item of results) {
+          const label = item.valid ? chalk.green("valid") : chalk.red("invalid");
+          logger.log(
+            `${label} ${item.sessionId} (${item.eventCount} events, ${item.messageCount || 0} messages, malformed: ${item.malformedLines})`,
+          );
+          if (!item.valid && item.reason) {
+            logger.log(`  ${chalk.gray(item.reason)}`);
+          }
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/ui.js

@@ -1,39 +1,5 @@
-/**
- * ui command — start a local web management UI
- * chainlesschain ui [--port] [--ws-port] [--host] [--no-open] [--token]
- *
- * Project mode  (run from a dir with .chainlesschain/): project-scoped chat UI
- * Global mode   (run from any other dir):               global management panel
- */
-
-import { execSync } from "child_process";
-import path from "path";
-import chalk from "chalk";
 import { logger } from "../lib/logger.js";
-import { ChainlessChainWSServer } from "../lib/ws-server.js";
-import { WSSessionManager } from "../lib/ws-session-manager.js";
-import { createWebUIServer } from "../lib/web-ui-server.js";
-import { bootstrap } from "../runtime/bootstrap.js";
-import { findProjectRoot, loadProjectConfig } from "../lib/project-detector.js";
-import { loadConfig } from "../lib/config-manager.js";
-
-/**
- * Open a URL in the system default browser (cross-platform).
- */
-function openBrowser(url) {
-  try {
-    const platform = process.platform;
-    if (platform === "win32") {
-      execSync(`start "" "${url}"`, { stdio: "ignore" });
-    } else if (platform === "darwin") {
-      execSync(`open "${url}"`, { stdio: "ignore" });
-    } else {
-      execSync(`xdg-open "${url}"`, { stdio: "ignore" });
-    }
-  } catch (_err) {
-    // Non-critical — user can open manually
-  }
-}
+import { createAgentRuntimeFactory } from "../runtime/runtime-factory.js";
 
 export function registerUiCommand(program) {
   program
@@ -52,126 +18,19 @@ export function registerUiCommand(program) {
       "Path to built web-panel dist/ directory (auto-detected by default)",
     )
     .action(async (opts) => {
-      const httpPort = parseInt(opts.port, 10);
-      const wsPort = parseInt(opts.wsPort, 10);
-      const host = opts.host;
-
-      if (isNaN(httpPort) || httpPort < 1 || httpPort > 65535) {
-        logger.error("Invalid --port. Must be between 1 and 65535.");
-        process.exit(1);
-      }
-      if (isNaN(wsPort) || wsPort < 1 || wsPort > 65535) {
-        logger.error("Invalid --ws-port. Must be between 1 and 65535.");
-        process.exit(1);
-      }
-
-      // ── Detect project context ────────────────────────────────────────────
-      const projectRoot = findProjectRoot(process.cwd());
-      const projectConfig = projectRoot ? loadProjectConfig(projectRoot) : null;
-      const projectName =
-        projectConfig?.name ||
-        (projectRoot ? path.basename(projectRoot) : null);
-      const mode = projectRoot ? "project" : "global";
-
-      // ── Bootstrap headless runtime ────────────────────────────────────────
-      let db = null;
-      try {
-        const ctx = await bootstrap({ skipDb: false });
-        db = ctx.db?.getDb?.() || null;
-      } catch (_err) {
-        logger.log(
-          chalk.yellow(
-            "  Warning: Database not available, sessions will be in-memory only",
-          ),
-        );
-      }
-
-      // ── Start WebSocket server ────────────────────────────────────────────
-      const appConfig = loadConfig();
-      const sessionManager = new WSSessionManager({
-        db,
-        defaultProjectRoot: projectRoot || process.cwd(),
-        config: appConfig,
-      });
-
-      const wsServer = new ChainlessChainWSServer({
-        port: wsPort,
-        host,
-        token: opts.token || null,
-        maxConnections: 20,
-        timeout: 60000,
-        sessionManager,
-      });
-
-      try {
-        await wsServer.start();
-      } catch (err) {
-        logger.error(`Failed to start WebSocket server: ${err.message}`);
-        process.exit(1);
-      }
-
-      // ── Start HTTP server ─────────────────────────────────────────────────
-      const httpServer = createWebUIServer({
-        wsPort,
-        wsToken: opts.token || null,
-        wsHost: host === "0.0.0.0" ? "127.0.0.1" : host,
-        projectRoot,
-        projectName,
-        mode,
-        staticDir: opts.webPanelDir || null,
-      });
-
       try {
-        await new Promise((resolve, reject) => {
-          httpServer.listen(httpPort, host, () => resolve());
-          httpServer.on("error", reject);
+        const runtime = createAgentRuntimeFactory().createUiRuntime({
+          port: parseInt(opts.port, 10),
+          wsPort: parseInt(opts.wsPort, 10),
+          host: opts.host,
+          open: opts.open,
+          token: opts.token || null,
+          webPanelDir: opts.webPanelDir || null,
         });
+        await runtime.startUiServer();
       } catch (err) {
-        logger.error(`Failed to start HTTP server: ${err.message}`);
+        logger.error(`Failed to start UI server: ${err.message}`);
         process.exit(1);
       }
-
-      // ── Print startup info ────────────────────────────────────────────────
-      const uiUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${httpPort}`;
-
-      logger.log("");
-      logger.log(chalk.bold("  ChainlessChain 管理面板"));
-      logger.log("");
-      if (mode === "project") {
-        logger.log(
-          `  Mode:     ${chalk.cyan("project")}  ${chalk.dim(projectRoot)}`,
-        );
-        if (projectName) {
-          logger.log(`  Project:  ${chalk.green(projectName)}`);
-        }
-      } else {
-        logger.log(`  Mode:     ${chalk.cyan("global")}`);
-      }
-      logger.log(`  UI:       ${chalk.cyan(uiUrl)}`);
-      logger.log(`  WS:       ${chalk.dim(`ws://${host}:${wsPort}`)}`);
-      logger.log(
-        `  Auth:     ${opts.token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
-      );
-      logger.log("");
-      logger.log(chalk.dim("  Press Ctrl+C to stop"));
-      logger.log("");
-
-      // ── Open browser ──────────────────────────────────────────────────────
-      if (opts.open !== false) {
-        openBrowser(uiUrl);
-      }
-
-      // ── Graceful shutdown ─────────────────────────────────────────────────
-      const shutdown = async () => {
-        logger.log("\n" + chalk.yellow("Shutting down UI server..."));
-        await Promise.all([
-          new Promise((resolve) => httpServer.close(resolve)),
-          wsServer.stop(),
-        ]);
-        process.exit(0);
-      };
-
-      process.on("SIGINT", shutdown);
-      process.on("SIGTERM", shutdown);
     });
 }

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

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

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();
+    },
+  };
+}