chainlesschain 0.45.11 → 0.45.19

package/src/runtime/agent-runtime.js

@@ -0,0 +1,417 @@
+import chalk from "chalk";
+import { execSync } from "child_process";
+import path from "path";
+import {
+  RuntimeEventEmitter,
+  RUNTIME_EVENTS,
+  createRuntimeEvent,
+} from "./runtime-events.js";
+import { createRuntimeContext } from "./runtime-context.js";
+import { createAgentTurnRecord } from "./contracts/agent-turn.js";
+import { logger } from "../lib/logger.js";
+import { bootstrap } from "./bootstrap.js";
+import { startAgentRepl } from "../gateways/repl/agent-repl.js";
+import { startChatRepl } from "../gateways/repl/chat-repl.js";
+import { ChainlessChainWSServer } from "../gateways/ws/ws-server.js";
+import { WSSessionManager } from "../gateways/ws/ws-session-gateway.js";
+import { createWebUIServer } from "../gateways/ui/web-ui-server.js";
+import {
+  findProjectRoot,
+  loadProjectConfig,
+} from "../lib/project-detector.js";
+import { loadConfig } from "../lib/config-manager.js";
+
+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.
+  }
+}
+
+export class AgentRuntime {
+  constructor({ kind, policy, config = null, deps = {} } = {}) {
+    this.kind = kind;
+    this.policy = policy;
+    this.config = config;
+    this.context = createRuntimeContext({ kind, policy, config });
+    this.events = deps.events || new RuntimeEventEmitter();
+    this.deps = {
+      startAgentRepl: deps.startAgentRepl || startAgentRepl,
+      startChatRepl: deps.startChatRepl || startChatRepl,
+      bootstrap: deps.bootstrap || bootstrap,
+      createServer:
+        deps.createServer ||
+        ((options) => new ChainlessChainWSServer(options)),
+      createSessionManager:
+        deps.createSessionManager ||
+        ((options) => new WSSessionManager(options)),
+      createWebServer:
+        deps.createWebServer || ((options) => createWebUIServer(options)),
+      findProjectRoot: deps.findProjectRoot || findProjectRoot,
+      loadProjectConfig: deps.loadProjectConfig || loadProjectConfig,
+      loadConfig: deps.loadConfig || loadConfig,
+      openBrowser: deps.openBrowser || openBrowser,
+      runTurn: deps.runTurn || null,
+      logger: deps.logger || logger,
+    };
+  }
+
+  on(eventName, listener) {
+    this.events.on(eventName, listener);
+    return this;
+  }
+
+  emit(eventName, payload) {
+    const event = createRuntimeEvent(eventName, payload, {
+      kind: this.kind,
+      sessionId: this.policy?.sessionId || null,
+    });
+    this.events.emit(eventName, event);
+  }
+
+  async resumeSession(sessionId) {
+    const nextSessionId = sessionId || this.policy.sessionId;
+    if (!nextSessionId) {
+      throw new Error("resumeSession requires a sessionId.");
+    }
+
+    this.policy = {
+      ...this.policy,
+      sessionId: nextSessionId,
+    };
+    this.context = createRuntimeContext({
+      kind: this.kind,
+      policy: this.policy,
+      config: this.config,
+    });
+
+    this.emit(RUNTIME_EVENTS.SESSION_RESUME, {
+      kind: this.kind,
+      sessionId: nextSessionId,
+    });
+
+    if (this.kind === "chat") {
+      return this.startChatSession();
+    }
+    if (this.kind === "agent") {
+      return this.startAgentSession();
+    }
+
+    throw new Error(`resumeSession is not supported for runtime kind "${this.kind}".`);
+  }
+
+  async runTurn(input, meta = {}) {
+    if (typeof this.deps.runTurn !== "function") {
+      throw new Error(`runTurn is not configured for runtime kind "${this.kind}".`);
+    }
+
+    const startedAt = Date.now();
+    this.emit(RUNTIME_EVENTS.TURN_START, createAgentTurnRecord({
+      kind: this.kind,
+      input,
+      meta,
+      sessionId: this.policy.sessionId || null,
+      startedAt,
+    }));
+
+    const result = await this.deps.runTurn({
+      input,
+      meta,
+      kind: this.kind,
+      policy: this.policy,
+      context: this.context,
+    });
+
+    this.emit(RUNTIME_EVENTS.TURN_END, createAgentTurnRecord({
+      kind: this.kind,
+      input,
+      meta,
+      result,
+      sessionId: this.policy.sessionId || null,
+      startedAt,
+      endedAt: Date.now(),
+    }));
+
+    return result;
+  }
+
+  async startAgentSession() {
+    this.emit(RUNTIME_EVENTS.RUNTIME_START, {
+      kind: this.kind,
+      policy: this.policy,
+    });
+    this.emit(RUNTIME_EVENTS.SESSION_START, {
+      kind: this.kind,
+      sessionId: this.policy.sessionId || null,
+    });
+    return this.deps.startAgentRepl(this.policy);
+  }
+
+  async startChatSession() {
+    this.emit(RUNTIME_EVENTS.RUNTIME_START, {
+      kind: this.kind,
+      policy: this.policy,
+    });
+    this.emit(RUNTIME_EVENTS.SESSION_START, {
+      kind: this.kind,
+      sessionId: this.policy.sessionId || null,
+    });
+    return this.deps.startChatRepl(this.policy);
+  }
+
+  async startServer() {
+    const { logger: runtimeLogger } = this.deps;
+    const {
+      port,
+      maxConnections,
+      timeout,
+      token,
+      allowRemote,
+      project,
+    } = this.policy;
+    let { host } = this.policy;
+
+    if (Number.isNaN(port) || port < 1 || port > 65535) {
+      throw new Error("Invalid port number. Must be between 1 and 65535.");
+    }
+
+    if (allowRemote) {
+      if (!token) {
+        throw new Error("--allow-remote requires --token for security.");
+      }
+      host = "0.0.0.0";
+    }
+
+    let db = null;
+    try {
+      const ctx = await this.deps.bootstrap({ skipDb: false });
+      db = ctx.db?.getDb?.() || null;
+    } catch (_err) {
+      runtimeLogger.log(
+        chalk.yellow(
+          "  Warning: Database not available, sessions will be in-memory only",
+        ),
+      );
+    }
+
+    const sessionManager = this.deps.createSessionManager({
+      db,
+      defaultProjectRoot: project,
+    });
+
+    const server = this.deps.createServer({
+      port,
+      host,
+      token,
+      maxConnections,
+      timeout,
+      sessionManager,
+    });
+
+    server.on("connection", ({ clientId, ip }) => {
+      runtimeLogger.log(chalk.green(`  + Client connected: ${clientId} (${ip})`));
+    });
+
+    server.on("disconnection", ({ clientId, reason }) => {
+      const extra = reason ? ` (${reason})` : "";
+      runtimeLogger.log(
+        chalk.yellow(`  - Client disconnected: ${clientId}${extra}`),
+      );
+    });
+
+    server.on("command:start", ({ id, command }) => {
+      runtimeLogger.log(chalk.cyan(`  > [${id}] ${command}`));
+    });
+
+    server.on("command:end", ({ id, exitCode }) => {
+      const color = exitCode === 0 ? chalk.green : chalk.red;
+      runtimeLogger.log(color(`  < [${id}] exit ${exitCode}`));
+    });
+
+    server.on("session:create", ({ sessionId, type }) => {
+      runtimeLogger.log(
+        chalk.green(`  + Session created: ${sessionId} (${type})`),
+      );
+    });
+
+    server.on("session:close", ({ sessionId }) => {
+      runtimeLogger.log(chalk.yellow(`  - Session closed: ${sessionId}`));
+    });
+
+    const shutdownHandler = async () => {
+      runtimeLogger.log(
+        "\n" + chalk.yellow("Shutting down WebSocket server..."),
+      );
+      await server.stop();
+      process.exit(0);
+    };
+
+    process.on("SIGINT", shutdownHandler);
+    process.on("SIGTERM", shutdownHandler);
+
+    await server.start();
+
+    this.emit(RUNTIME_EVENTS.RUNTIME_START, {
+      kind: this.kind,
+      policy: { ...this.policy, host },
+    });
+    this.emit(RUNTIME_EVENTS.SERVER_START, {
+      host,
+      port,
+      project,
+    });
+
+    runtimeLogger.log("");
+    runtimeLogger.log(chalk.bold("  ChainlessChain WebSocket Server"));
+    runtimeLogger.log("");
+    runtimeLogger.log(`  Address:  ${chalk.cyan(`ws://${host}:${port}`)}`);
+    runtimeLogger.log(
+      `  Auth:     ${token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
+    );
+    runtimeLogger.log(`  Sessions: ${chalk.green("enabled")}`);
+    runtimeLogger.log(`  Project:  ${project}`);
+    runtimeLogger.log(`  Max conn: ${maxConnections}`);
+    runtimeLogger.log(`  Timeout:  ${timeout}ms`);
+    runtimeLogger.log("");
+    runtimeLogger.log(chalk.dim("  Press Ctrl+C to stop"));
+    runtimeLogger.log("");
+
+    return server;
+  }
+
+  async startUiServer() {
+    const { logger: runtimeLogger } = this.deps;
+    const httpPort = this.policy.port;
+    const wsPort = this.policy.wsPort;
+    const host = this.policy.host;
+
+    if (Number.isNaN(httpPort) || httpPort < 1 || httpPort > 65535) {
+      throw new Error("Invalid --port. Must be between 1 and 65535.");
+    }
+    if (Number.isNaN(wsPort) || wsPort < 1 || wsPort > 65535) {
+      throw new Error("Invalid --ws-port. Must be between 1 and 65535.");
+    }
+
+    const projectRoot = this.deps.findProjectRoot(process.cwd());
+    const projectConfig = projectRoot
+      ? this.deps.loadProjectConfig(projectRoot)
+      : null;
+    const projectName =
+      projectConfig?.name ||
+      (projectRoot ? path.basename(projectRoot) : null);
+    const mode = projectRoot ? "project" : "global";
+
+    let db = null;
+    try {
+      const ctx = await this.deps.bootstrap({ skipDb: false });
+      db = ctx.db?.getDb?.() || null;
+    } catch (_err) {
+      runtimeLogger.log(
+        chalk.yellow(
+          "  Warning: Database not available, sessions will be in-memory only",
+        ),
+      );
+    }
+
+    const appConfig = this.deps.loadConfig();
+    const sessionManager = this.deps.createSessionManager({
+      db,
+      defaultProjectRoot: projectRoot || process.cwd(),
+      config: appConfig,
+    });
+
+    const wsServer = this.deps.createServer({
+      port: wsPort,
+      host,
+      token: this.policy.token,
+      maxConnections: 20,
+      timeout: 60000,
+      sessionManager,
+    });
+    await wsServer.start();
+
+    const httpServer = this.deps.createWebServer({
+      wsPort,
+      wsToken: this.policy.token,
+      wsHost: host === "0.0.0.0" ? "127.0.0.1" : host,
+      projectRoot,
+      projectName,
+      mode,
+      staticDir: this.policy.webPanelDir,
+    });
+
+    await new Promise((resolve, reject) => {
+      httpServer.listen(httpPort, host, () => resolve());
+      httpServer.on("error", reject);
+    });
+
+    const uiUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${httpPort}`;
+
+    this.emit(RUNTIME_EVENTS.RUNTIME_START, {
+      kind: this.kind,
+      policy: this.policy,
+    });
+    this.emit(RUNTIME_EVENTS.SERVER_START, {
+      host,
+      port: httpPort,
+      wsPort,
+      mode,
+      projectRoot,
+    });
+
+    runtimeLogger.log("");
+    runtimeLogger.log(chalk.bold("  ChainlessChain 管理面板"));
+    runtimeLogger.log("");
+    if (mode === "project") {
+      runtimeLogger.log(
+        `  Mode:     ${chalk.cyan("project")}  ${chalk.dim(projectRoot)}`,
+      );
+      if (projectName) {
+        runtimeLogger.log(`  Project:  ${chalk.green(projectName)}`);
+      }
+    } else {
+      runtimeLogger.log(`  Mode:     ${chalk.cyan("global")}`);
+    }
+    runtimeLogger.log(`  UI:       ${chalk.cyan(uiUrl)}`);
+    runtimeLogger.log(`  WS:       ${chalk.dim(`ws://${host}:${wsPort}`)}`);
+    runtimeLogger.log(
+      `  Auth:     ${this.policy.token ? chalk.green("enabled") : chalk.yellow("disabled")}`,
+    );
+    runtimeLogger.log("");
+    runtimeLogger.log(chalk.dim("  Press Ctrl+C to stop"));
+    runtimeLogger.log("");
+
+    if (this.policy.open) {
+      this.deps.openBrowser(uiUrl);
+    }
+
+    const shutdown = async () => {
+      runtimeLogger.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);
+
+    return {
+      wsServer,
+      httpServer,
+      uiUrl,
+      mode,
+      projectRoot,
+      projectName,
+    };
+  }
+}

package/src/runtime/contracts/agent-turn.js

@@ -0,0 +1,11 @@
+export function createAgentTurnRecord(turn = {}) {
+  return {
+    kind: turn.kind || null,
+    sessionId: turn.sessionId || null,
+    input: turn.input,
+    meta: turn.meta || {},
+    result: turn.result,
+    startedAt: turn.startedAt || null,
+    endedAt: turn.endedAt || null,
+  };
+}

package/src/runtime/contracts/session-record.js

@@ -0,0 +1,31 @@
+import { createWorktreeRecord } from "./worktree-record.js";
+
+export function createSessionRecord(session = {}, extras = {}) {
+  const history = Array.isArray(extras.history)
+    ? extras.history
+    : Array.isArray(session.messages)
+      ? session.messages.filter((item) => item.role !== "system")
+      : [];
+
+  return {
+    id: session.id || extras.sessionId || null,
+    type: session.type || extras.sessionType || null,
+    provider: session.provider || extras.provider || null,
+    model: session.model || extras.model || null,
+    projectRoot: session.projectRoot || extras.projectRoot || null,
+    baseProjectRoot: session.baseProjectRoot || extras.baseProjectRoot || null,
+    worktreeIsolation:
+      session.worktreeIsolation === true || extras.worktreeIsolation === true,
+    worktree:
+      session.worktree || extras.worktree
+        ? createWorktreeRecord(session.worktree || extras.worktree, {
+            requested:
+              session.worktreeIsolation === true ||
+              extras.worktreeIsolation === true,
+          })
+        : null,
+    messageCount: extras.messageCount ?? history.length,
+    history,
+    status: extras.status || null,
+  };
+}

package/src/runtime/contracts/task-record.js

@@ -0,0 +1,18 @@
+export function createTaskRecord(task = {}, meta = {}) {
+  return {
+    id: task.id || null,
+    status: task.status || null,
+    type: task.type || null,
+    description: task.description || null,
+    ownerNodeId: task.ownerNodeId || null,
+    createdAt: task.createdAt || null,
+    startedAt: task.startedAt || null,
+    completedAt: task.completedAt || null,
+    result: task.result ?? null,
+    error: task.error ?? null,
+    recoveredFromRestart: Boolean(task.recoveredFromRestart),
+    recoverySourceStatus: task.recoverySourceStatus || null,
+    outputSummary: task.outputSummary || null,
+    meta,
+  };
+}

package/src/runtime/contracts/telemetry-record.js

@@ -0,0 +1,23 @@
+export function createTelemetryRecord(metric = {}, meta = {}) {
+  return {
+    kind: metric.kind || "telemetry",
+    provider: metric.provider || null,
+    model: metric.model || null,
+    source: metric.source || null,
+    strategy: metric.strategy || null,
+    variant: metric.variant || metric.abVariant || null,
+    savedTokens:
+      typeof metric.savedTokens === "number"
+        ? metric.savedTokens
+        : typeof metric.saved === "number"
+          ? metric.saved
+          : null,
+    originalTokens:
+      typeof metric.originalTokens === "number" ? metric.originalTokens : null,
+    compressedTokens:
+      typeof metric.compressedTokens === "number" ? metric.compressedTokens : null,
+    ratio: typeof metric.ratio === "number" ? metric.ratio : null,
+    timestamp: metric.timestamp || Date.now(),
+    meta,
+  };
+}

package/src/runtime/contracts/worktree-record.js

@@ -0,0 +1,14 @@
+export function createWorktreeRecord(worktree = {}, meta = {}) {
+  return {
+    branch: worktree.branch || null,
+    path: worktree.path || worktree.worktreePath || null,
+    baseBranch: worktree.baseBranch || null,
+    hasChanges: typeof worktree.hasChanges === "boolean" ? worktree.hasChanges : null,
+    summary: worktree.summary || null,
+    conflicts: Array.isArray(worktree.conflicts) ? worktree.conflicts : [],
+    previewEntrypoints: Array.isArray(worktree.previewEntrypoints)
+      ? worktree.previewEntrypoints
+      : [],
+    meta,
+  };
+}

package/src/runtime/index.js

@@ -0,0 +1,13 @@
+export { AgentRuntime } from "./agent-runtime.js";
+export { createAgentRuntimeFactory } from "./runtime-factory.js";
+export { createRuntimeContext } from "./runtime-context.js";
+export {
+  RuntimeEventEmitter,
+  RUNTIME_EVENTS,
+  createRuntimeEvent,
+} from "./runtime-events.js";
+export { createAgentTurnRecord } from "./contracts/agent-turn.js";
+export { createSessionRecord } from "./contracts/session-record.js";
+export { createTaskRecord } from "./contracts/task-record.js";
+export { createWorktreeRecord } from "./contracts/worktree-record.js";
+export { createTelemetryRecord } from "./contracts/telemetry-record.js";

package/src/runtime/policies/agent-policy.js

@@ -0,0 +1,45 @@
+export function resolveAgentPolicy({
+  config = null,
+  overrides = {},
+  defaults = {},
+} = {}) {
+  const llm = config?.llm || {};
+
+  return {
+    model: overrides.model || llm.model || defaults.model || "qwen2:7b",
+    provider:
+      overrides.provider || llm.provider || defaults.provider || "ollama",
+    baseUrl:
+      overrides.baseUrl !== undefined
+        ? overrides.baseUrl
+        : llm.baseUrl || defaults.baseUrl,
+    apiKey:
+      overrides.apiKey !== undefined
+        ? overrides.apiKey
+        : llm.apiKey || defaults.apiKey || null,
+    sessionId: overrides.sessionId || null,
+  };
+}
+
+export function resolveServerPolicy(overrides = {}) {
+  return {
+    port: overrides.port,
+    host: overrides.host,
+    token: overrides.token || null,
+    maxConnections: overrides.maxConnections,
+    timeout: overrides.timeout,
+    allowRemote: Boolean(overrides.allowRemote),
+    project: overrides.project || process.cwd(),
+  };
+}
+
+export function resolveUiPolicy(overrides = {}) {
+  return {
+    port: overrides.port,
+    wsPort: overrides.wsPort,
+    host: overrides.host,
+    open: overrides.open !== false,
+    token: overrides.token || null,
+    webPanelDir: overrides.webPanelDir || null,
+  };
+}

package/src/runtime/runtime-context.js

@@ -0,0 +1,14 @@
+export function createRuntimeContext({
+  kind,
+  policy,
+  config = null,
+  cwd = process.cwd(),
+} = {}) {
+  return {
+    kind,
+    policy,
+    config,
+    cwd,
+    createdAt: Date.now(),
+  };
+}

package/src/runtime/runtime-events.js

@@ -0,0 +1,37 @@
+import { EventEmitter } from "node:events";
+
+export const RUNTIME_EVENTS = {
+  RUNTIME_START: "runtime:start",
+  RUNTIME_STOP: "runtime:stop",
+  SESSION_START: "session:start",
+  SESSION_RESUME: "session:resume",
+  SESSION_END: "session:end",
+  SESSION_MESSAGE: "session:message",
+  TURN_START: "turn:start",
+  TURN_END: "turn:end",
+  TASK_CREATED: "task:created",
+  TASK_COMPLETED: "task:completed",
+  TASK_NOTIFICATION: "task:notification",
+  WORKTREE_DIFF_READY: "worktree:diff:ready",
+  WORKTREE_MERGED: "worktree:merge:completed",
+  COMPRESSION_APPLIED: "compression:applied",
+  COMPRESSION_SUMMARY: "compression:summary",
+  SERVER_START: "server:start",
+  SERVER_STOP: "server:stop",
+  ERROR: "runtime:error",
+};
+
+export function createRuntimeEvent(type, payload = {}, context = {}) {
+  return {
+    type,
+    toolDescriptor: payload.toolDescriptor || context.toolDescriptor || null,
+    toolTelemetryRecord:
+      payload.toolTelemetryRecord || context.toolTelemetryRecord || null,
+    kind: context.kind || payload.kind || null,
+    sessionId: context.sessionId || payload.sessionId || null,
+    timestamp: context.timestamp || Date.now(),
+    payload,
+  };
+}
+
+export class RuntimeEventEmitter extends EventEmitter {}

package/src/runtime/runtime-factory.js

@@ -0,0 +1,50 @@
+import { loadConfig } from "../lib/config-manager.js";
+import { AgentRuntime } from "./agent-runtime.js";
+import {
+  resolveAgentPolicy,
+  resolveServerPolicy,
+  resolveUiPolicy,
+} from "./policies/agent-policy.js";
+
+export function createAgentRuntimeFactory({
+  config = loadConfig(),
+  deps = {},
+} = {}) {
+  return {
+    createAgentRuntime(overrides = {}) {
+      return new AgentRuntime({
+        kind: "agent",
+        policy: resolveAgentPolicy({ config, overrides }),
+        config,
+        deps,
+      });
+    },
+
+    createChatRuntime(overrides = {}) {
+      return new AgentRuntime({
+        kind: "chat",
+        policy: resolveAgentPolicy({ config, overrides }),
+        config,
+        deps,
+      });
+    },
+
+    createServerRuntime(overrides = {}) {
+      return new AgentRuntime({
+        kind: "server",
+        policy: resolveServerPolicy(overrides),
+        config,
+        deps,
+      });
+    },
+
+    createUiRuntime(overrides = {}) {
+      return new AgentRuntime({
+        kind: "ui",
+        policy: resolveUiPolicy(overrides),
+        config,
+        deps,
+      });
+    },
+  };
+}