chainlesschain 0.45.12 → 0.45.20

package/src/lib/ws-session-manager.js

@@ -20,6 +20,8 @@ import {
 } from "./session-manager.js";
 import { buildSystemPrompt } from "./agent-core.js";
 import { SubAgentRegistry } from "./sub-agent-registry.js";
+import { createWorktree, removeWorktree } from "./worktree-isolator.js";
+import { isGitRepo } from "./git-integration.js";
 
 /**
  * @typedef {object} Session
@@ -32,7 +34,11 @@ import { SubAgentRegistry } from "./sub-agent-registry.js";
  * @property {string|null} apiKey
  * @property {string|null} baseUrl
  * @property {string} projectRoot
+ * @property {string} baseProjectRoot
  * @property {string|null} rulesContent
+ * @property {object|null} hostManagedToolPolicy
+ * @property {boolean} worktreeIsolation
+ * @property {object|null} worktree
  * @property {PlanModeManager} planManager
  * @property {CLIContextEngineering|null} contextEngine
  * @property {CLIPermanentMemory|null} permanentMemory
@@ -78,12 +84,13 @@ export class WSSessionManager {
    * @param {string} [options.model]
    * @param {string} [options.apiKey]
    * @param {string} [options.baseUrl]
+   * @param {object} [options.hostManagedToolPolicy]
    * @returns {{ sessionId: string }}
    */
   createSession(options = {}) {
     const sessionId = this._generateId();
     const type = options.type || "agent";
-    const projectRoot = options.projectRoot || this.defaultProjectRoot;
+    const baseProjectRoot = options.projectRoot || this.defaultProjectRoot;
     const cfgLlm = this.config?.llm || {};
     const provider = options.provider || cfgLlm.provider || "ollama";
     const model =
@@ -93,6 +100,16 @@ export class WSSessionManager {
     const baseUrl =
       options.baseUrl || cfgLlm.baseUrl || "http://localhost:11434";
     const apiKey = options.apiKey || cfgLlm.apiKey || null;
+    const worktreeIsolationRequested = options.worktreeIsolation === true;
+    const isolatedWorkspace = this._prepareSessionWorkspace(
+      baseProjectRoot,
+      sessionId,
+      {
+        worktreeIsolation: worktreeIsolationRequested,
+      },
+    );
+    const projectRoot = isolatedWorkspace.projectRoot;
+    const worktree = isolatedWorkspace.worktree;
 
     // Project context (rules.md, persona) is now loaded by buildSystemPrompt()
 
@@ -151,8 +168,12 @@ export class WSSessionManager {
       model,
       apiKey,
       baseUrl,
+      hostManagedToolPolicy: options.hostManagedToolPolicy || null,
       projectRoot,
+      baseProjectRoot,
       rulesContent: null,
+      worktreeIsolation: worktreeIsolationRequested,
+      worktree,
       planManager,
       contextEngine,
       permanentMemory,
@@ -226,8 +247,12 @@ export class WSSessionManager {
         model: dbSession.model || null,
         apiKey: null,
         baseUrl: "http://localhost:11434",
+        hostManagedToolPolicy: null,
         projectRoot: this.defaultProjectRoot,
+        baseProjectRoot: this.defaultProjectRoot,
         rulesContent: null,
+        worktreeIsolation: false,
+        worktree: null,
         planManager,
         contextEngine,
         permanentMemory,
@@ -284,6 +309,16 @@ export class WSSessionManager {
       session.planManager.removeAllListeners();
     }
 
+    if (session.worktree?.path && session.baseProjectRoot) {
+      try {
+        removeWorktree(session.baseProjectRoot, session.worktree.path, {
+          deleteBranch: true,
+        });
+      } catch (_err) {
+        // Best-effort cleanup.
+      }
+    }
+
     this.sessions.delete(sessionId);
   }
 
@@ -304,6 +339,9 @@ export class WSSessionManager {
         provider: session.provider,
         model: session.model,
         messageCount: session.messages.length,
+        baseProjectRoot: session.baseProjectRoot,
+        worktreeIsolation: session.worktreeIsolation === true,
+        worktree: session.worktree || null,
         createdAt: session.createdAt,
         lastActivity: session.lastActivity,
       });
@@ -346,6 +384,22 @@ export class WSSessionManager {
     return this.sessions.get(sessionId) || null;
   }
 
+  /**
+   * Update host-managed tool policy for an active session.
+   *
+   * @param {string} sessionId
+   * @param {object|null} hostManagedToolPolicy
+   * @returns {Session|null}
+   */
+  updateSessionPolicy(sessionId, hostManagedToolPolicy) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+
+    session.hostManagedToolPolicy = hostManagedToolPolicy || null;
+    session.lastActivity = new Date().toISOString();
+    return session;
+  }
+
   /**
    * Persist current messages for a session.
    */
@@ -361,4 +415,31 @@ export class WSSessionManager {
 
     session.lastActivity = new Date().toISOString();
   }
+
+  _prepareSessionWorkspace(projectRoot, sessionId, options = {}) {
+    if (options.worktreeIsolation !== true) {
+      return {
+        projectRoot,
+        worktree: null,
+      };
+    }
+
+    if (!isGitRepo(projectRoot)) {
+      throw new Error(
+        `Worktree isolation requires a git repository: ${projectRoot}`,
+      );
+    }
+
+    const branchName = `coding-agent/${sessionId}`;
+    const worktree = createWorktree(projectRoot, branchName);
+
+    return {
+      projectRoot: worktree.path,
+      worktree: {
+        branch: worktree.branch,
+        path: worktree.path,
+        baseProjectRoot: projectRoot,
+      },
+    };
+  }
 }

package/src/repl/agent-repl.js

@@ -48,6 +48,7 @@ import { CLIPermanentMemory } from "../lib/permanent-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
 import { PromptCompressor } from "../lib/prompt-compressor.js";
 import { feature } from "../lib/feature-flags.js";
+import { recordCompressionMetric } from "../lib/compression-telemetry.js";
 import {
   AGENT_TOOLS,
   buildSystemPrompt,
@@ -426,6 +427,11 @@ export async function startAgentRepl(options = {}) {
           await _compressor.compress(messages);
         messages.length = 0;
         messages.push(...compacted);
+        recordCompressionMetric(stats, {
+          source: "manual-compact",
+          provider,
+          model,
+        });
         logger.info(
           `Compacted: ${stats.originalMessages} → ${stats.compressedMessages} messages, saved ${stats.saved} tokens (${stats.strategy})`,
         );
@@ -1126,6 +1132,11 @@ export async function startAgentRepl(options = {}) {
             await _compressor.compress(messages);
           messages.length = 0;
           messages.push(...compacted);
+          recordCompressionMetric(stats, {
+            source: "auto-compact",
+            provider,
+            model: activeModel,
+          });
           if (stats.saved > 0) {
             logger.verbose(
               `Auto-compacted: ${stats.strategy} (saved ${stats.saved} tokens)`,

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