chainlesschain 0.162.142 → 0.162.147

package/src/lib/agent-sandbox.js

@@ -0,0 +1,72 @@
+/** OS-isolated shell execution for the coding agent. */
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+
+export const DEFAULT_SANDBOX_IMAGE = "node:22-bookworm-slim";
+export const _deps = { spawnSync };
+
+export function normalizeAgentSandbox(value, options = {}) {
+  if (!value) return null;
+  const image =
+    typeof value === "string" && value.trim() && value !== "true"
+      ? value.trim()
+      : DEFAULT_SANDBOX_IMAGE;
+  return {
+    engine: "docker",
+    image,
+    cwd: path.resolve(options.cwd || process.cwd()),
+    network: options.network === true,
+  };
+}
+
+export function executeSandboxedShell(command, sandbox, options = {}) {
+  if (!sandbox || sandbox.engine !== "docker") {
+    throw new Error("A supported agent sandbox configuration is required");
+  }
+  const hostCwd = path.resolve(options.cwd || sandbox.cwd);
+  const args = ["run", "--rm", "--init"];
+  if (!sandbox.network) args.push("--network", "none");
+  args.push("--mount", `type=bind,source=${hostCwd},target=/workspace`);
+  args.push("--workdir", "/workspace");
+  if (process.platform !== "win32" && process.getuid && process.getgid) {
+    args.push("--user", `${process.getuid()}:${process.getgid()}`);
+  }
+  const env = options.env || {};
+  for (const key of ["CLAUDECODE", "CC_SESSION_ID", "CLAUDE_CODE_SESSION_ID"]) {
+    if (env[key] != null) args.push("--env", `${key}=${env[key]}`);
+  }
+  args.push(sandbox.image, "sh", "-lc", String(command || ""));
+  const result = _deps.spawnSync("docker", args, {
+    encoding: "utf8",
+    timeout: options.timeout,
+    maxBuffer: options.maxBuffer,
+    windowsHide: true,
+  });
+  if (result.error) {
+    return {
+      stdout: result.stdout || "",
+      stderr:
+        result.error.code === "ENOENT"
+          ? "Docker is not installed"
+          : result.error.message,
+      exitCode: typeof result.status === "number" ? result.status : 1,
+      failedToStart: true,
+    };
+  }
+  return {
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    exitCode: typeof result.status === "number" ? result.status : 1,
+    signal: result.signal || null,
+  };
+}
+
+export function sandboxSummary(sandbox) {
+  if (!sandbox) return null;
+  return {
+    engine: sandbox.engine,
+    image: sandbox.image,
+    network: sandbox.network ? "enabled" : "disabled",
+    workspace: "read-write",
+  };
+}

package/src/lib/background-agent-supervisor.js

@@ -0,0 +1,197 @@
+import { spawn, spawnSync } from "node:child_process";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { randomBytes } from "node:crypto";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getHomeDir } from "./paths.js";
+
+export const _deps = { spawn, spawnSync };
+
+export function backgroundAgentsDir() {
+  const dir =
+    process.env.CC_BACKGROUND_AGENTS_DIR ||
+    join(getHomeDir(), "background-agents");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function createBackgroundAgentId() {
+  return `bg-${Date.now()}-${randomBytes(3).toString("hex")}`;
+}
+
+function safeId(id) {
+  if (!/^bg-[a-zA-Z0-9-]+$/.test(String(id || ""))) {
+    throw new Error(`Invalid background agent id: ${id}`);
+  }
+  return String(id);
+}
+
+export function statePath(id) {
+  return join(backgroundAgentsDir(), `${safeId(id)}.json`);
+}
+
+export function logPath(id) {
+  return join(backgroundAgentsDir(), `${safeId(id)}.log`);
+}
+
+export function writeBackgroundAgentState(state) {
+  const target = statePath(state.id);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2), { mode: 0o600 });
+  renameSync(tmp, target);
+  return state;
+}
+
+export function readBackgroundAgentState(id) {
+  const file = statePath(id);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function isProcessAlive(pid) {
+  if (!Number.isInteger(Number(pid)) || Number(pid) <= 0) return false;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM") return true;
+    return false;
+  }
+}
+
+export function effectiveBackgroundAgentState(state) {
+  if (!state) return null;
+  if (state.status === "running" && !isProcessAlive(state.pid)) {
+    return { ...state, status: "lost", endedAt: state.endedAt || Date.now() };
+  }
+  return state;
+}
+
+export function listBackgroundAgents(options = {}) {
+  return readdirSync(backgroundAgentsDir())
+    .filter((name) => name.endsWith(".json") && !name.includes(".job."))
+    .map((name) => readBackgroundAgentState(name.slice(0, -5)))
+    .filter(Boolean)
+    .map(effectiveBackgroundAgentState)
+    .filter((state) => options.all || state.status === "running")
+    .sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0));
+}
+
+export function launchBackgroundAgent({
+  argv,
+  cwd,
+  sessionId,
+  title,
+  cliEntry,
+}) {
+  const id = createBackgroundAgentId();
+  const dir = backgroundAgentsDir();
+  const jobFile = join(dir, `${id}.job.${process.pid}.json`);
+  const worker = fileURLToPath(
+    new URL("../workers/background-agent-worker.js", import.meta.url),
+  );
+  const job = {
+    id,
+    argv,
+    cwd,
+    sessionId,
+    title: title || "Background agent",
+    cliEntry: cliEntry || process.argv[1],
+    logFile: logPath(id),
+  };
+  writeFileSync(jobFile, JSON.stringify(job), { mode: 0o600 });
+  let child;
+  try {
+    child = _deps.spawn(process.execPath, [worker, jobFile], {
+      cwd,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+  } catch (error) {
+    rmSync(jobFile, { force: true });
+    throw error;
+  }
+  child.unref();
+  const state = {
+    id,
+    sessionId,
+    title: job.title,
+    cwd,
+    pid: child.pid,
+    status: "running",
+    startedAt: Date.now(),
+    endedAt: null,
+    exitCode: null,
+    logFile: job.logFile,
+  };
+  writeBackgroundAgentState(state);
+  return state;
+}
+
+export function readBackgroundAgentLog(id, options = {}) {
+  const file = logPath(id);
+  if (!existsSync(file)) return "";
+  const text = readFileSync(file, "utf8");
+  const lines = text.split(/\r?\n/);
+  const limit = Math.max(1, Number(options.lines) || 100);
+  return lines.slice(-limit).join("\n");
+}
+
+export function stopBackgroundAgent(id) {
+  const state = effectiveBackgroundAgentState(readBackgroundAgentState(id));
+  if (!state) throw new Error(`Background agent not found: ${id}`);
+  if (state.status !== "running") return { ...state, stopped: false };
+  if (process.platform === "win32") {
+    const killed = _deps.spawnSync(
+      "taskkill",
+      ["/PID", String(state.pid), "/T", "/F"],
+      {
+        windowsHide: true,
+        encoding: "utf8",
+      },
+    );
+    if (killed.error || (killed.status !== 0 && isProcessAlive(state.pid))) {
+      throw new Error(
+        `Failed to stop background agent ${id}: ${killed.error?.message || killed.stderr || `taskkill exited ${killed.status}`}`,
+      );
+    }
+  } else {
+    try {
+      process.kill(-Number(state.pid), "SIGTERM");
+    } catch {
+      process.kill(Number(state.pid), "SIGTERM");
+    }
+  }
+  const next = {
+    ...state,
+    status: "stopped",
+    endedAt: Date.now(),
+    stoppedByUser: true,
+  };
+  writeBackgroundAgentState(next);
+  return { ...next, stopped: true };
+}
+
+export function openBackgroundLogFile(id) {
+  const fd = openSync(logPath(id), "a", 0o600);
+  return { fd, close: () => closeSync(fd) };
+}
+
+export function removeJobFile(file) {
+  rmSync(file, { force: true });
+}

package/src/lib/code-review.js

@@ -0,0 +1,72 @@
+/**
+ * Code review utilities (ESM)
+ * Mirrors Claude Code /review behavior
+ * @module lib/code-review
+ */
+
+import { execSync } from "child_process";
+import { logger } from "./logger.js";
+
+/**
+ * Get git diff for review
+ * @param {string} target - Diff target (default: staged changes)
+ * @returns {string} diff output
+ */
+export function getGitDiff(target = "--staged") {
+  try {
+    return execSync(`git diff ${target}`, {
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+    });
+  } catch (err) {
+    logger.error(`Failed to get git diff: ${err.message}`);
+    return "";
+  }
+}
+
+/**
+ * Get list of changed files
+ * @param {string} target - Diff target
+ * @returns {string[]} changed files
+ */
+export function getChangedFiles(target = "--staged") {
+  try {
+    const output = execSync(`git diff ${target} --name-only`, {
+      encoding: "utf8",
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch (err) {
+    logger.error(`Failed to get changed files: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Run code review on current changes
+ * @param {Object} options Review options
+ * @returns {Promise<Object>} review result
+ */
+export async function runCodeReview(options = {}) {
+  const target = options.target || "--staged";
+  const diff = getGitDiff(target);
+  const files = getChangedFiles(target);
+
+  if (files.length === 0) {
+    logger.info("No changed files to review");
+    return { reviewed: false, files: [], issues: [] };
+  }
+
+  logger.info(`Reviewing ${files.length} changed files...`);
+  files.forEach((f) => logger.info(`  - ${f}`));
+
+  return {
+    reviewed: true,
+    files,
+    diffSize: diff.length,
+    // Actual AI review will be handled by agent core
+    message:
+      "Code review request prepared. AI will analyze changes for bugs, security issues, and style problems.",
+  };
+}
+
+export default { getGitDiff, getChangedFiles, runCodeReview };

package/src/lib/ensure-utf8.js

@@ -9,20 +9,38 @@
 
 import { execSync } from "child_process";
 
+// Injectable so tests can assert whether the (expensive) chcp spawn happened
+// without actually spawning cmd.exe. See cli-dev.md `_deps` pattern.
+export const _deps = { execSync };
+
 /**
  * Call this as early as possible in the process entry point.
  */
 export function ensureUtf8() {
   if (process.platform !== "win32") return;
 
-  // Set Windows console codepage to UTF-8
-  try {
-    execSync("chcp 65001", { stdio: "ignore" });
-  } catch (_err) {
-    // Ignore - may fail in non-interactive environments
+  // Setting the Windows console codepage to UTF-8 requires spawning cmd.exe
+  // (`chcp 65001`), which costs ~280ms per invocation — a Windows process
+  // creation, paid on EVERY `cc` run. But the codepage only affects how an
+  // *interactive console* renders bytes; when stdout/stderr are piped or
+  // redirected (JSON output, headless runs, `cc` spawned as a subprocess by the
+  // desktop app / Android / spawnSync test harnesses), the bytes flow through
+  // the pipe as raw UTF-8 regardless of codepage, so the spawn is pure startup
+  // tax. Only pay it when a console is actually attached — the 乱码 fix is
+  // preserved exactly where it matters. Set CC_FORCE_CHCP=1 to restore the
+  // unconditional old behavior if some console edge case needs it.
+  const consoleAttached =
+    Boolean(process.stdout && process.stdout.isTTY) ||
+    Boolean(process.stderr && process.stderr.isTTY);
+  if (consoleAttached || process.env.CC_FORCE_CHCP === "1") {
+    try {
+      _deps.execSync("chcp 65001", { stdio: "ignore" });
+    } catch (_err) {
+      // Ignore - may fail in non-interactive environments
+    }
   }
 
-  // Ensure stdout/stderr use UTF-8 encoding
+  // Ensure stdout/stderr use UTF-8 encoding (cheap; always)
   if (process.stdout.setDefaultEncoding) {
     process.stdout.setDefaultEncoding("utf8");
   }
@@ -30,7 +48,7 @@ export function ensureUtf8() {
     process.stderr.setDefaultEncoding("utf8");
   }
 
-  // Set environment variable so child processes inherit UTF-8
+  // Set environment variable so child processes inherit UTF-8 (always)
   process.env.PYTHONIOENCODING = "utf-8";
   process.env.LANG = "en_US.UTF-8";
 }

package/src/lib/knowledge-exporter.js

@@ -4,6 +4,7 @@
 
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
+import { safeJsonParse } from "./safe-json.js";
 
 /**
  * Ensure the notes table exists
@@ -50,7 +51,7 @@ export function fetchNotes(db, { category, tag, limit } = {}) {
   if (tag) {
     notes = notes.filter((n) => {
       try {
-        const tags = JSON.parse(n.tags || "[]");
+        const tags = safeJsonParse(n.tags, []);
         return tags.includes(tag);
       } catch {
         return false;
@@ -173,7 +174,7 @@ export function generateIndexHtml(
 ) {
   const noteLinks = notes
     .map((n) => {
-      const tags = JSON.parse(n.tags || "[]");
+      const tags = safeJsonParse(n.tags, []);
       const tagsHtml = tags
         .map((t) => `<span class="tag">${escapeHtml(t)}</span>`)
         .join(" ");

package/src/lib/permission-engine.js

@@ -308,7 +308,7 @@ export function getUserPermissions(db, userDid) {
       .prepare("SELECT permissions FROM rbac_roles WHERE name = ?")
       .get(grant.role_name);
     if (role) {
-      const perms = JSON.parse(role.permissions || "[]");
+      const perms = safeJsonParse(role.permissions, []);
       for (const p of perms) allPerms.add(p);
     }
   }

package/src/lib/plugin-security.js

@@ -0,0 +1,128 @@
+import { createHash, createPublicKey, verify } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { loadManagedSettings } from "./settings-loader.cjs";
+
+function stringSet(value) {
+  return Array.isArray(value)
+    ? new Set(
+        value
+          .map((v) =>
+            typeof v === "string" ? v : v?.name || v?.source || v?.url || null,
+          )
+          .map((v) => String(v || "").trim())
+          .filter(Boolean),
+      )
+    : null;
+}
+
+export function enforcePluginPolicy(
+  { name, source = null, action = "install" },
+  managed,
+) {
+  if (!managed) return { allowed: true };
+  const denied = stringSet(managed.deniedPlugins) || new Set();
+  const allowed = stringSet(managed.allowedPlugins);
+  if (denied.has(name)) {
+    throw new Error(`plugin "${name}" is denied by managed settings`);
+  }
+  if (allowed && !allowed.has(name)) {
+    throw new Error(`plugin "${name}" is not in the managed allowlist`);
+  }
+
+  const blockedSources = new Set([
+    ...(stringSet(managed.blockedPluginSources) || []),
+    ...(stringSet(managed.blockedMarketplaces) || []),
+  ]);
+  const allowedSources = stringSet(managed.allowedPluginSources);
+  if (source && blockedSources.has(source)) {
+    throw new Error(`plugin source "${source}" is blocked by managed settings`);
+  }
+  if (action === "install" && allowedSources) {
+    if (!source) {
+      throw new Error(
+        "managed settings require --source for plugin installation",
+      );
+    }
+    if (!allowedSources.has(source)) {
+      throw new Error(
+        `plugin source "${source}" is not in the managed allowlist`,
+      );
+    }
+  }
+  return { allowed: true };
+}
+
+export function verifyPluginManifest({
+  manifestFile,
+  expectedSha256,
+  signatureFile,
+  publicKeyFile,
+  requireSignature = false,
+  trustedKeySha256 = null,
+  requireTrustedKey = false,
+}) {
+  if (!manifestFile) {
+    if (requireSignature) {
+      throw new Error("managed settings require a signed plugin manifest");
+    }
+    return null;
+  }
+  const bytes = readFileSync(manifestFile);
+  const sha256 = createHash("sha256").update(bytes).digest("hex");
+  if (
+    expectedSha256 &&
+    sha256.toLowerCase() !== String(expectedSha256).toLowerCase()
+  ) {
+    throw new Error(
+      `plugin manifest SHA-256 mismatch (expected ${expectedSha256}, got ${sha256})`,
+    );
+  }
+
+  const wantsSignature = requireSignature || signatureFile || publicKeyFile;
+  let signatureVerified = false;
+  if (wantsSignature) {
+    if (!signatureFile || !publicKeyFile) {
+      throw new Error(
+        "plugin signature verification requires --signature and --public-key",
+      );
+    }
+    const signature = readFileSync(signatureFile);
+    const publicKey = readFileSync(publicKeyFile, "utf8");
+    const keyObject = createPublicKey(publicKey);
+    const publicKeySha256 = createHash("sha256")
+      .update(keyObject.export({ type: "spki", format: "der" }))
+      .digest("hex");
+    const trusted = stringSet(trustedKeySha256);
+    if (requireTrustedKey && (!trusted || trusted.size === 0)) {
+      throw new Error(
+        "managed settings require trustedPluginKeySha256 fingerprints",
+      );
+    }
+    if (trusted && !trusted.has(publicKeySha256)) {
+      throw new Error(`plugin signing key is not trusted (${publicKeySha256})`);
+    }
+    signatureVerified = verify(null, bytes, keyObject, signature);
+    if (!signatureVerified) {
+      throw new Error("plugin manifest signature verification failed");
+    }
+  }
+  return {
+    bytes,
+    sha256,
+    signatureVerified,
+    publicKeySha256: signatureVerified
+      ? createHash("sha256")
+          .update(
+            createPublicKey(readFileSync(publicKeyFile, "utf8")).export({
+              type: "spki",
+              format: "der",
+            }),
+          )
+          .digest("hex")
+      : null,
+  };
+}
+
+export function loadPluginManagedPolicy(options = {}) {
+  return loadManagedSettings(options).settings;
+}

package/src/lib/pr-create.js

@@ -0,0 +1,108 @@
+/**
+ * Pull request creation utilities (ESM)
+ * Mirrors Claude Code /pr behavior
+ * @module lib/pr-create
+ */
+
+import { execSync } from "child_process";
+import { logger } from "./logger.js";
+
+/**
+ * Get current git branch
+ * @returns {string} branch name
+ */
+export function getCurrentBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf8",
+    }).trim();
+  } catch {
+    return "main";
+  }
+}
+
+/**
+ * Get remote URL
+ * @returns {string|null}
+ */
+export function getRemoteUrl() {
+  try {
+    return execSync("git remote get-url origin", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract GitHub owner/repo from remote URL
+ * @returns {{owner: string, repo: string}|null}
+ */
+export function parseGitHubRepo() {
+  const url = getRemoteUrl();
+  if (!url) return null;
+
+  // Handle SSH and HTTPS URLs
+  const match = url.match(/github\.com[:/]([^/]+)\/([^/.]+)(\.git)?/);
+  if (!match) return null;
+
+  return { owner: match[1], repo: match[2] };
+}
+
+/**
+ * Prepare pull request
+ * @param {Object} options PR options
+ * @returns {Promise<Object>} PR creation result
+ */
+export async function preparePullRequest(options = {}) {
+  const branch = getCurrentBranch();
+  const repo = parseGitHubRepo();
+
+  // Check for uncommitted changes
+  const status = execSync("git status --porcelain", { encoding: "utf8" });
+  const hasChanges = status.trim().length > 0;
+
+  if (hasChanges && !options.skipStash) {
+    logger.warn(
+      "You have uncommitted changes. Commit or stash before creating PR.",
+    );
+  }
+
+  // Get commit messages for PR body
+  const defaultBase = options.base || "main";
+  const logRange = `${defaultBase}...${branch}`;
+  let commitLog = "";
+  try {
+    commitLog = execSync(`git log ${logRange} --oneline`, { encoding: "utf8" });
+  } catch {
+    commitLog = "";
+  }
+
+  const prUrl = repo
+    ? `https://github.com/${repo.owner}/${repo.repo}/compare/${defaultBase}...${branch}?expand=1`
+    : null;
+
+  logger.info(`Branch: ${branch}`);
+  logger.info(`Base: ${defaultBase}`);
+  if (prUrl) {
+    logger.info(`Open PR in browser: ${prUrl}`);
+  }
+
+  return {
+    prepared: true,
+    branch,
+    base: defaultBase,
+    repo,
+    commitLog,
+    prUrl,
+    hasUncommittedChanges: hasChanges,
+    message:
+      "PR draft prepared. AI will help generate title and body from commits.",
+  };
+}
+
+export default {
+  getCurrentBranch,
+  getRemoteUrl,
+  parseGitHubRepo,
+  preparePullRequest,
+};