chainlesschain 0.45.11 → 0.45.19

package/src/lib/background-task-manager.js

@@ -1,305 +1 @@
-/**
- * Background Task Manager — daemon task queue with completion notifications.
- *
- * Tasks run in child_process.fork() for isolation.
- * Queue persisted to .chainlesschain/tasks/queue.jsonl.
- * Completion notifications delivered to REPL callback.
- *
- * Feature-flag gated: BACKGROUND_TASKS
- */
-
-import { fork } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  appendFileSync,
-  readFileSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { createHash } from "node:crypto";
-import { EventEmitter } from "node:events";
-import { getHomeDir } from "./paths.js";
-
-function getTasksDir() {
-  const dir = join(getHomeDir(), "tasks");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function queuePath() {
-  return join(getTasksDir(), "queue.jsonl");
-}
-
-// ── Task Status ─────────────────────────────────────────────────────────
-
-export const TaskStatus = {
-  PENDING: "pending",
-  RUNNING: "running",
-  COMPLETED: "completed",
-  FAILED: "failed",
-  TIMEOUT: "timeout",
-};
-
-// ── BackgroundTaskManager ───────────────────────────────────────────────
-
-export class BackgroundTaskManager extends EventEmitter {
-  /**
-   * @param {object} options
-   * @param {number} [options.maxConcurrent=3] — Max parallel background tasks
-   * @param {number} [options.heartbeatTimeout=60000] — Task heartbeat timeout (ms)
-   */
-  constructor(options = {}) {
-    super();
-    this.maxConcurrent = options.maxConcurrent || 3;
-    this.heartbeatTimeout = options.heartbeatTimeout || 60000;
-    this.tasks = new Map(); // id -> task object
-    this.processes = new Map(); // id -> child process
-    this._checkInterval = null;
-  }
-
-  /**
-   * Create and queue a new background task.
-   * @param {object} spec
-   * @param {string} spec.type — Task type (e.g. "shell", "agent", "script")
-   * @param {string} spec.command — Command or script to execute
-   * @param {string} [spec.cwd] — Working directory
-   * @param {string} [spec.description] — Human-readable description
-   * @returns {object} Created task
-   */
-  create(spec) {
-    if (this._runningCount() >= this.maxConcurrent) {
-      throw new Error(
-        `Max concurrent tasks reached (${this.maxConcurrent}). Wait for a task to finish.`,
-      );
-    }
-
-    const id = `task-${Date.now()}-${createHash("sha256").update(Math.random().toString()).digest("hex").slice(0, 6)}`;
-
-    const task = {
-      id,
-      type: spec.type || "shell",
-      command: spec.command,
-      cwd: spec.cwd || process.cwd(),
-      description: spec.description || spec.command,
-      status: TaskStatus.PENDING,
-      createdAt: Date.now(),
-      startedAt: null,
-      completedAt: null,
-      lastHeartbeat: null,
-      result: null,
-      error: null,
-    };
-
-    this.tasks.set(id, task);
-    this._persistTask(task);
-    return task;
-  }
-
-  /**
-   * Start a pending task (runs in child process).
-   */
-  start(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task) throw new Error(`Task not found: ${taskId}`);
-    if (task.status !== TaskStatus.PENDING)
-      throw new Error(`Task ${taskId} is not pending (status: ${task.status})`);
-
-    task.status = TaskStatus.RUNNING;
-    task.startedAt = Date.now();
-    task.lastHeartbeat = Date.now();
-
-    // Create a wrapper script that executes the command
-    const child = fork(
-      join(import.meta.dirname || ".", "background-task-worker.js"),
-      [task.command, task.cwd, task.type],
-      {
-        cwd: task.cwd,
-        silent: true,
-        env: { ...process.env, CC_TASK_ID: taskId },
-      },
-    );
-
-    this.processes.set(taskId, child);
-
-    child.on("message", (msg) => {
-      if (msg.type === "heartbeat") {
-        task.lastHeartbeat = Date.now();
-      } else if (msg.type === "result") {
-        this._complete(taskId, TaskStatus.COMPLETED, msg.data, null);
-      } else if (msg.type === "error") {
-        this._complete(taskId, TaskStatus.FAILED, null, msg.error);
-      }
-    });
-
-    child.on("exit", (code) => {
-      if (task.status === TaskStatus.RUNNING) {
-        if (code === 0) {
-          this._complete(
-            taskId,
-            TaskStatus.COMPLETED,
-            "Process exited (0)",
-            null,
-          );
-        } else {
-          this._complete(
-            taskId,
-            TaskStatus.FAILED,
-            null,
-            `Process exited with code ${code}`,
-          );
-        }
-      }
-      this.processes.delete(taskId);
-    });
-
-    child.on("error", (err) => {
-      this._complete(taskId, TaskStatus.FAILED, null, err.message);
-      this.processes.delete(taskId);
-    });
-
-    this._persistTask(task);
-    this._ensureHeartbeatChecker();
-    return task;
-  }
-
-  /**
-   * Create and immediately start a task.
-   */
-  run(spec) {
-    const task = this.create(spec);
-    this.start(task.id);
-    return task;
-  }
-
-  /**
-   * Get a task by ID.
-   */
-  get(taskId) {
-    return this.tasks.get(taskId) || null;
-  }
-
-  /**
-   * List all tasks.
-   */
-  list(filter = {}) {
-    let tasks = [...this.tasks.values()];
-    if (filter.status) {
-      tasks = tasks.filter((t) => t.status === filter.status);
-    }
-    return tasks.sort((a, b) => b.createdAt - a.createdAt);
-  }
-
-  /**
-   * Stop a running task.
-   */
-  stop(taskId) {
-    const child = this.processes.get(taskId);
-    if (child) {
-      child.kill("SIGTERM");
-      setTimeout(() => {
-        if (child.exitCode === null) child.kill("SIGKILL");
-      }, 2000);
-    }
-    this._complete(taskId, TaskStatus.FAILED, null, "Stopped by user");
-  }
-
-  /**
-   * Clean up completed/failed tasks older than maxAge.
-   * @param {number} [maxAge=3600000] — Max age in ms (default 1 hour)
-   */
-  cleanup(maxAge = 3600000) {
-    const cutoff = Date.now() - maxAge;
-    let removed = 0;
-    for (const [id, task] of this.tasks) {
-      if (
-        (task.status === TaskStatus.COMPLETED ||
-          task.status === TaskStatus.FAILED ||
-          task.status === TaskStatus.TIMEOUT) &&
-        task.completedAt &&
-        task.completedAt < cutoff
-      ) {
-        this.tasks.delete(id);
-        removed++;
-      }
-    }
-    return removed;
-  }
-
-  /**
-   * Destroy the manager (kill all running tasks, clear intervals).
-   */
-  destroy() {
-    if (this._checkInterval) {
-      clearInterval(this._checkInterval);
-      this._checkInterval = null;
-    }
-    for (const [id] of this.processes) {
-      this.stop(id);
-    }
-    this.tasks.clear();
-    this.processes.clear();
-  }
-
-  // ── Internal ──────────────────────────────────────────────────────
-
-  _complete(taskId, status, result, error) {
-    const task = this.tasks.get(taskId);
-    if (!task) return;
-
-    task.status = status;
-    task.completedAt = Date.now();
-    task.result = result;
-    task.error = error;
-
-    this._persistTask(task);
-    this.emit("task:complete", task);
-  }
-
-  _runningCount() {
-    let count = 0;
-    for (const task of this.tasks.values()) {
-      if (task.status === TaskStatus.RUNNING) count++;
-    }
-    return count;
-  }
-
-  _persistTask(task) {
-    try {
-      const line = JSON.stringify(task) + "\n";
-      appendFileSync(queuePath(), line, "utf-8");
-    } catch (_e) {
-      // Non-critical
-    }
-  }
-
-  _ensureHeartbeatChecker() {
-    if (this._checkInterval) return;
-
-    this._checkInterval = setInterval(
-      () => {
-        const now = Date.now();
-        for (const [id, task] of this.tasks) {
-          if (
-            task.status === TaskStatus.RUNNING &&
-            task.lastHeartbeat &&
-            now - task.lastHeartbeat > this.heartbeatTimeout
-          ) {
-            this._complete(id, TaskStatus.TIMEOUT, null, "Heartbeat timeout");
-            const child = this.processes.get(id);
-            if (child) {
-              child.kill("SIGKILL");
-              this.processes.delete(id);
-            }
-          }
-        }
-      },
-      Math.min(this.heartbeatTimeout / 2, 10000),
-    );
-
-    // Don't keep process alive for the checker
-    if (this._checkInterval.unref) {
-      this._checkInterval.unref();
-    }
-  }
-}
+export { TaskStatus, BackgroundTaskManager } from "../harness/background-task-manager.js";

package/src/lib/background-task-worker.js

@@ -1,50 +1 @@
-/**
- * Background Task Worker — child process that executes a command.
- *
- * Args: [command, cwd, type]
- * Sends messages to parent: { type: "heartbeat"|"result"|"error", ... }
- */
-
-import { execSync } from "node:child_process";
-
-const [command, cwd, type] = process.argv.slice(2);
-
-// Heartbeat every 5 seconds
-const heartbeat = setInterval(() => {
-  if (process.send) process.send({ type: "heartbeat" });
-}, 5000);
-
-try {
-  let result;
-
-  if (type === "shell") {
-    result = execSync(command, {
-      cwd: cwd || process.cwd(),
-      encoding: "utf-8",
-      timeout: 300000, // 5 min max
-      maxBuffer: 10 * 1024 * 1024,
-    });
-  } else {
-    // Default: treat as shell
-    result = execSync(command, {
-      cwd: cwd || process.cwd(),
-      encoding: "utf-8",
-      timeout: 300000,
-      maxBuffer: 10 * 1024 * 1024,
-    });
-  }
-
-  if (process.send) {
-    process.send({ type: "result", data: result || "Done" });
-  }
-} catch (err) {
-  if (process.send) {
-    process.send({
-      type: "error",
-      error: err.stderr || err.message || String(err),
-    });
-  }
-  process.exitCode = 1;
-} finally {
-  clearInterval(heartbeat);
-}
+import "../harness/background-task-worker.js";

package/src/lib/compression-telemetry.js

@@ -0,0 +1,5 @@
+export {
+  recordCompressionMetric,
+  getCompressionTelemetrySummary,
+  resetCompressionTelemetry,
+} from "../harness/compression-telemetry.js";

package/src/lib/feature-flags.js

@@ -1,182 +1,7 @@
-/**
- * Feature Flag System — runtime feature gating for gradual rollout.
- *
- * Flags are stored in .chainlesschain/config.json under "features" key.
- * Each flag can be:
- *   - boolean (true/false)
- *   - number 0-100 (percentage rollout, hashed by machine-id)
- *   - object { enabled, variant, description }
- *
- * Usage:
- *   import { feature, featureVariant, listFeatures } from "./feature-flags.js";
- *   if (feature("CONTEXT_SNIP")) { ... }
- */
-
-import { loadConfig, getConfigValue, saveConfig } from "./config-manager.js";
-import { createHash } from "node:crypto";
-import { hostname } from "node:os";
-
-// ── Flag Registry (source of truth for known flags) ────────────────────
-
-const FLAG_REGISTRY = {
-  BACKGROUND_TASKS: {
-    description: "Enable background task queue with daemon execution",
-    default: false,
-  },
-  WORKTREE_ISOLATION: {
-    description: "Enable git worktree isolation for agent tasks",
-    default: false,
-  },
-  CONTEXT_SNIP: {
-    description: "Enable snipCompact strategy in context compression",
-    default: false,
-  },
-  CONTEXT_COLLAPSE: {
-    description: "Enable contextCollapse strategy in context compression",
-    default: false,
-  },
-  JSONL_SESSION: {
-    description: "Use JSONL append-only format for session persistence",
-    default: false,
-  },
-  PROMPT_COMPRESSOR: {
-    description: "Enable CLI prompt compressor (auto/snip/collapse)",
-    default: true,
-  },
-};
-
-// ── Core API ────────────────────────────────────────────────────────────
-
-/**
- * Check if a feature flag is enabled.
- * @param {string} name - Flag name (e.g. "CONTEXT_SNIP")
- * @returns {boolean}
- */
-export function feature(name) {
-  const value = _resolve(name);
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return _percentageCheck(name, value);
-  if (value && typeof value === "object") return Boolean(value.enabled);
-  return _getDefault(name);
-}
-
-/**
- * Get the variant string for a feature (for A/B style flags).
- * @param {string} name
- * @returns {string|null}
- */
-export function featureVariant(name) {
-  const value = _resolve(name);
-  if (value && typeof value === "object" && value.variant) {
-    return value.variant;
-  }
-  return null;
-}
-
-/**
- * List all known feature flags with their current values.
- * @returns {Array<{name, enabled, description, source, raw}>}
- */
-export function listFeatures() {
-  const config = loadConfig();
-  const features = config.features || {};
-  const result = [];
-
-  for (const [name, meta] of Object.entries(FLAG_REGISTRY)) {
-    const raw = features[name];
-    const enabled = feature(name);
-    const source =
-      raw !== undefined
-        ? "config"
-        : process.env[`CC_FLAG_${name}`] !== undefined
-          ? "env"
-          : "default";
-
-    result.push({
-      name,
-      enabled,
-      description: meta.description,
-      source,
-      raw: raw !== undefined ? raw : meta.default,
-    });
-  }
-
-  // Include unknown flags from config (user-defined)
-  for (const [name, raw] of Object.entries(features)) {
-    if (!FLAG_REGISTRY[name]) {
-      result.push({
-        name,
-        enabled: Boolean(raw),
-        description: "(user-defined)",
-        source: "config",
-        raw,
-      });
-    }
-  }
-
-  return result;
-}
-
-/**
- * Set a feature flag value in config.
- * @param {string} name
- * @param {boolean|number|string} value
- */
-export function setFeature(name, value) {
-  const config = loadConfig();
-  if (!config.features) config.features = {};
-  config.features[name] = value;
-  saveConfig(config);
-}
-
-/**
- * Get the registry entry for a known flag (or null).
- * @param {string} name
- * @returns {{description: string, default: boolean}|null}
- */
-export function getFlagInfo(name) {
-  return FLAG_REGISTRY[name] || null;
-}
-
-// ── Internal helpers ───────────────────────────────���────────────────────
-
-function _resolve(name) {
-  // Priority: env var > config > default
-  const envKey = `CC_FLAG_${name}`;
-  if (process.env[envKey] !== undefined) {
-    const envVal = process.env[envKey];
-    if (envVal === "true" || envVal === "1") return true;
-    if (envVal === "false" || envVal === "0") return false;
-    const num = Number(envVal);
-    if (!isNaN(num)) return num;
-    return envVal;
-  }
-
-  const configVal = getConfigValue(`features.${name}`);
-  if (configVal !== undefined) return configVal;
-
-  return undefined; // let caller fall to default
-}
-
-function _getDefault(name) {
-  const meta = FLAG_REGISTRY[name];
-  return meta ? meta.default : false;
-}
-
-function _percentageCheck(name, percentage) {
-  if (percentage <= 0) return false;
-  if (percentage >= 100) return true;
-  const hash = createHash("md5")
-    .update(`${name}:${_machineId()}`)
-    .digest("hex");
-  const bucket = parseInt(hash.slice(0, 8), 16) % 100;
-  return bucket < percentage;
-}
-
-let _cachedMachineId = null;
-function _machineId() {
-  if (!_cachedMachineId) {
-    _cachedMachineId = hostname() || "unknown";
-  }
-  return _cachedMachineId;
-}
+export {
+  feature,
+  featureVariant,
+  listFeatures,
+  setFeature,
+  getFlagInfo,
+} from "../harness/feature-flags.js";

package/src/lib/interaction-adapter.js

@@ -101,18 +101,15 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
    * @param {object} [extra] - choices, default, etc.
    * @returns {Promise<string|boolean>}
    */
-  _ask(questionType, question, extra = {}) {
+  _request(message, options = {}) {
     return new Promise((resolve, reject) => {
       const requestId = this._requestId();
       this._pending.set(requestId, { resolve, reject });
 
       this._sendWs({
-        type: "question",
+        ...message,
         sessionId: this.sessionId,
         requestId,
-        questionType,
-        question,
-        ...extra,
       });
 
       // Timeout after 5 minutes
@@ -123,11 +120,20 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
             reject(new Error("Question timed out"));
           }
         },
-        5 * 60 * 1000,
+        options.timeoutMs || 5 * 60 * 1000,
       );
     });
   }
 
+  _ask(questionType, question, extra = {}) {
+    return this._request({
+      type: "question",
+      questionType,
+      question,
+      ...extra,
+    });
+  }
+
   async askInput(question, options = {}) {
     return this._ask("input", question, { default: options.default || "" });
   }
@@ -157,6 +163,26 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     }
   }
 
+  async requestHostTool(toolName, args = {}, extra = {}) {
+    return this._request(
+      {
+        type: "host-tool-call",
+        toolName,
+        args,
+        ...extra,
+      },
+      { timeoutMs: extra.timeoutMs || 60 * 1000 },
+    );
+  }
+
+  resolveHostTool(requestId, payload) {
+    const pending = this._pending.get(requestId);
+    if (pending) {
+      this._pending.delete(requestId);
+      pending.resolve(payload);
+    }
+  }
+
   emit(eventType, data) {
     this._sendWs({
       type: eventType,