chainlesschain 0.162.142 → 0.162.147

package/src/lib/publish-workspace.js

@@ -0,0 +1,107 @@
+/**
+ * Publish workspace packages to npm (ESM)
+ * Mirrors Claude Code /publish behavior
+ * @module lib/publish-workspace
+ */
+
+import { execSync } from "child_process";
+import { logger } from "./logger.js";
+import path from "path";
+import fs from "fs";
+
+/**
+ * Get all workspace packages
+ * @returns {Array<{name: string, path: string, version: string}>}
+ */
+export function getWorkspacePackages() {
+  try {
+    const rootPkg = JSON.parse(fs.readFileSync("package.json", "utf8"));
+    const packages = [];
+
+    // Handle workspaces config
+    const workspaces = rootPkg.workspaces?.packages || rootPkg.workspaces || [];
+    for (const pattern of workspaces) {
+      // Simple glob handling for basic patterns
+      const dir = pattern.replace(/\*+/g, "");
+      if (fs.existsSync(dir)) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const pkgPath = path.join(dir, entry.name);
+            const pkgFile = path.join(pkgPath, "package.json");
+            if (fs.existsSync(pkgFile)) {
+              const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf8"));
+              if (pkg.name && !pkg.private) {
+                packages.push({
+                  name: pkg.name,
+                  path: pkgPath,
+                  version: pkg.version,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return packages;
+  } catch (err) {
+    logger.error(`Failed to get workspace packages: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Publish a single package
+ * @param {Object} pkg Package info
+ * @param {Object} options Publish options
+ * @returns {boolean} success
+ */
+export function publishPackage(pkg, options = {}) {
+  try {
+    logger.info(`Publishing ${pkg.name}@${pkg.version}...`);
+    let cmd = "npm publish";
+    if (options.tag) cmd += ` --tag ${options.tag}`;
+    if (options.access) cmd += ` --access ${options.access}`;
+
+    execSync(cmd, {
+      cwd: pkg.path,
+      stdio: "inherit",
+      encoding: "utf8",
+    });
+    logger.succeed(`Published ${pkg.name}@${pkg.version}`);
+    return true;
+  } catch (err) {
+    logger.error(`Failed to publish ${pkg.name}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Publish all changed workspace packages
+ * @param {Object} options Options
+ * @returns {Promise<boolean>} success
+ */
+export async function publishWorkspace(options = {}) {
+  const packages = getWorkspacePackages();
+  if (packages.length === 0) {
+    logger.info("No publishable packages found");
+    return true;
+  }
+
+  logger.info(`Found ${packages.length} publishable packages`);
+  let allSucceeded = true;
+
+  for (const pkg of packages) {
+    if (options.dryRun) {
+      logger.info(`[dry-run] Would publish ${pkg.name}@${pkg.version}`);
+      continue;
+    }
+    const ok = publishPackage(pkg, options);
+    if (!ok) allSucceeded = false;
+  }
+
+  return allSucceeded;
+}
+
+export default { getWorkspacePackages, publishPackage, publishWorkspace };

package/src/lib/resume-session.js

@@ -0,0 +1,111 @@
+/**
+ * Session resume utilities (ESM)
+ * Mirrors Claude Code /resume behavior
+ * @module lib/resume-session
+ */
+
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { logger } from "./logger.js";
+
+const SESSION_DIR = path.join(os.homedir(), ".chainlesschain", "sessions");
+
+/**
+ * List recent chat sessions
+ * @param {number} limit Maximum sessions to return
+ * @returns {Array<Object>} list of sessions
+ */
+export function listSessions(limit = 10) {
+  try {
+    if (!fs.existsSync(SESSION_DIR)) {
+      return [];
+    }
+
+    const files = fs
+      .readdirSync(SESSION_DIR)
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => {
+        const filePath = path.join(SESSION_DIR, f);
+        const stat = fs.statSync(filePath);
+        let summary = "";
+        try {
+          const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+          summary = data.summary || data.title || f.replace(".json", "");
+        } catch {
+          summary = f.replace(".json", "");
+        }
+        return {
+          id: f.replace(".json", ""),
+          file: filePath,
+          mtime: stat.mtimeMs,
+          summary,
+        };
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, limit);
+
+    return files;
+  } catch (err) {
+    logger.debug(`Error listing sessions: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Load a session by ID
+ * @param {string} sessionId
+ * @returns {Object|null} session data
+ */
+export function loadSession(sessionId) {
+  try {
+    const filePath = path.join(SESSION_DIR, `${sessionId}.json`);
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    logger.error(`Error loading session ${sessionId}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Get the most recent session
+ * @returns {Object|null}
+ */
+export function getLatestSession() {
+  const sessions = listSessions(1);
+  return sessions.length > 0 ? loadSession(sessions[0].id) : null;
+}
+
+/**
+ * Resume a chat session
+ * @param {string} [sessionId] Optional session ID (resumes latest if not provided)
+ * @returns {Promise<Object>} resume result
+ */
+export async function resumeSession(sessionId) {
+  let session;
+  if (sessionId) {
+    session = loadSession(sessionId);
+    if (!session) {
+      return { success: false, message: `Session ${sessionId} not found` };
+    }
+  } else {
+    session = getLatestSession();
+    if (!session) {
+      return { success: false, message: "No previous sessions found" };
+    }
+  }
+
+  return {
+    success: true,
+    sessionId: session.id || sessionId,
+    messageCount: session.messages?.length || 0,
+    summary: session.summary,
+    session,
+    message: "Session loaded. Continue chatting to resume the conversation.",
+  };
+}
+
+export default { listSessions, loadSession, getLatestSession, resumeSession };

package/src/lib/session-manager.js

@@ -6,6 +6,7 @@
  */
 
 import { createHash } from "crypto";
+import { safeJsonParse } from "./safe-json.js";
 
 function ensureSessionsTable(db) {
   db.exec(`
@@ -153,7 +154,7 @@ export function listSessions(db, options = {}) {
       ...session,
       metadata:
         typeof session.metadata === "string"
-          ? JSON.parse(session.metadata || "{}")
+          ? safeJsonParse(session.metadata, {})
           : session.metadata || {},
     }));
 }

package/src/lib/settings-hooks.cjs

@@ -82,20 +82,66 @@ function readJson(file, onWarn) {
   }
 }
 
+function managedSettingsFile(env = process.env) {
+  if (env.CC_MANAGED_SETTINGS) return path.resolve(env.CC_MANAGED_SETTINGS);
+  if (process.platform === "win32") {
+    const base = env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData";
+    return path.join(base, "ChainlessChain", "managed-settings.json");
+  }
+  return "/etc/chainlesschain/managed-settings.json";
+}
+
+function appendHookBlock(merged, data) {
+  const block =
+    data && data.hooks && typeof data.hooks === "object" ? data.hooks : null;
+  if (!block) return false;
+  let contributed = false;
+  for (const [event, groups] of Object.entries(block)) {
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      if (!g || typeof g !== "object" || !Array.isArray(g.hooks)) continue;
+      const cmds = g.hooks.filter(
+        (h) => h && h.type === "command" && h.command,
+      );
+      if (cmds.length === 0) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push({ matcher: g.matcher ?? null, hooks: cmds });
+      contributed = true;
+    }
+  }
+  return contributed;
+}
+
 /**
  * Load + concatenate the `hooks` blocks across the hierarchy.
  * @returns {{ hooks: Record<string, Array<{matcher:string|null, hooks:Array<{type,command,timeout}>}>>, files:string[] }}
  */
-function loadHooks({ cwd = process.cwd(), settingsFile, onWarn } = {}) {
+function loadHooks({
+  cwd = process.cwd(),
+  settingsFile,
+  onWarn,
+  env = process.env,
+} = {}) {
   const merged = {};
   const files = [];
-  // Safe-mode kill switch (`cc agent --safe-mode` sets CC_SETTINGS_HOOKS=0):
-  // run with NO settings hooks so a broken hook can be diagnosed.
-  if (process.env.CC_SETTINGS_HOOKS === "0") {
-    return { hooks: merged, files };
+  const managedFile = managedSettingsFile(env);
+  let managed = null;
+  if (_deps.fs.existsSync(managedFile)) {
+    managed = readJson(managedFile, onWarn);
+    if (!managed) {
+      const error = new Error(
+        `managed settings are unreadable or malformed: ${managedFile}`,
+      );
+      error.code = "CC_MANAGED_SETTINGS_INVALID";
+      throw error;
+    }
   }
+  // Safe-mode kill switch (`cc agent --safe-mode` sets CC_SETTINGS_HOOKS=0):
+  // user/project hooks are disabled, but administrator hooks remain active.
+  const managedOnly = managed?.allowManagedHooksOnly === true;
+  const skipUnmanaged = env.CC_SETTINGS_HOOKS === "0" || managedOnly;
   const seenPaths = new Set();
-  for (const file of settingsFiles(cwd, settingsFile)) {
+  for (const file of skipUnmanaged ? [] : settingsFiles(cwd, settingsFile)) {
     // Dedup by RESOLVED path so the SAME physical file is never read twice — e.g.
     // `--settings .claude/settings.json` from the project root aliases the
     // auto-loaded cwd file, which would otherwise CONCATENATE its hook groups a
@@ -106,26 +152,16 @@ function loadHooks({ cwd = process.cwd(), settingsFile, onWarn } = {}) {
     if (seenPaths.has(resolved)) continue;
     seenPaths.add(resolved);
     const data = readJson(file, onWarn);
-    const block =
-      data && data.hooks && typeof data.hooks === "object" ? data.hooks : null;
-    if (!block) continue;
-    let contributed = false;
-    for (const [event, groups] of Object.entries(block)) {
-      if (!Array.isArray(groups)) continue;
-      for (const g of groups) {
-        if (!g || typeof g !== "object" || !Array.isArray(g.hooks)) continue;
-        const cmds = g.hooks.filter(
-          (h) => h && h.type === "command" && h.command,
-        );
-        if (cmds.length === 0) continue;
-        if (!merged[event]) merged[event] = [];
-        merged[event].push({ matcher: g.matcher ?? null, hooks: cmds });
-        contributed = true;
-      }
-    }
+    const contributed = appendHookBlock(merged, data);
     if (contributed) files.push(file);
   }
-  return { hooks: merged, files };
+  if (managed && appendHookBlock(merged, managed)) files.push(managedFile);
+  const result = { hooks: merged, files };
+  if (managed) {
+    result.managed = managed;
+    result.managedFile = managedFile;
+  }
+  return result;
 }
 
 /**
@@ -184,7 +220,8 @@ function collectHooks(hooksBlock, event, toolName) {
   for (const g of groups) {
     const fn = compileMatcher(g.matcher);
     if (fn(umbrella) || (raw && fn(raw))) {
-      for (const h of g.hooks) out.push({ command: h.command, timeout: h.timeout });
+      for (const h of g.hooks)
+        out.push({ command: h.command, timeout: h.timeout });
     }
   }
   return out;
@@ -265,6 +302,11 @@ function writeHookTrustStore(store) {
 function projectHookTrustNotice({ cwd = process.cwd(), settingsFile } = {}) {
   if (process.env.CC_HOOK_TRUST_NOTICE === "0") return null;
   if (process.env.CC_SETTINGS_HOOKS === "0") return null; // hooks won't run anyway
+  const managedFile = managedSettingsFile(process.env);
+  if (_deps.fs.existsSync(managedFile)) {
+    const managed = readJson(managedFile);
+    if (managed?.allowManagedHooksOnly === true) return null;
+  }
   const home = path.join(_deps.homedir(), ".claude", "settings.json");
   const explicit = settingsFile ? path.resolve(cwd, settingsFile) : null;
   const trusted = new Set([home, explicit].filter(Boolean));
@@ -328,6 +370,7 @@ module.exports = {
   compileMatcher,
   umbrellaFor,
   settingsFiles,
+  managedSettingsFile,
   HOOK_EVENTS,
   _deps,
 };

package/src/lib/settings-loader.cjs

@@ -88,6 +88,69 @@ function settingsPaths(cwd, explicitFile) {
   return list;
 }
 
+/** Organization-controlled settings file. This layer is always highest. */
+function managedSettingsPath(opts = {}) {
+  if (opts.managedSettingsFile) return path.resolve(opts.managedSettingsFile);
+  const env = opts.env || process.env;
+  if (env.CC_MANAGED_SETTINGS) return path.resolve(env.CC_MANAGED_SETTINGS);
+  if (process.platform === "win32") {
+    const base = env.ProgramData || env.PROGRAMDATA || "C:\\ProgramData";
+    return path.join(base, "ChainlessChain", "managed-settings.json");
+  }
+  return "/etc/chainlesschain/managed-settings.json";
+}
+
+function loadManagedSettings(opts = {}) {
+  const file = managedSettingsPath(opts);
+  if (!_deps.fs.existsSync(file)) return { file, settings: null };
+  const data = readSettingsFile(file, { onWarn: opts.onWarn });
+  if (!data) {
+    const error = new Error(
+      `managed settings are unreadable or malformed: ${file}`,
+    );
+    error.code = "CC_MANAGED_SETTINGS_INVALID";
+    throw error;
+  }
+  return { file, settings: data };
+}
+
+function emptyRules() {
+  return { allow: [], ask: [], deny: [] };
+}
+
+/** Apply the non-bypassable permission portion of managed settings. */
+function applyManagedPermissionPolicy(baseRules, managed, sources = {}) {
+  const policy = managed && typeof managed === "object" ? managed : {};
+  const rules = policy.allowManagedPermissionRulesOnly
+    ? emptyRules()
+    : {
+        allow: [...(baseRules?.allow || [])],
+        ask: [...(baseRules?.ask || [])],
+        deny: [...(baseRules?.deny || [])],
+      };
+  const perms =
+    policy.permissions && typeof policy.permissions === "object"
+      ? policy.permissions
+      : {};
+  for (const kind of KINDS) {
+    accrete(rules[kind], sources, perms[kind], "<managed>", kind);
+  }
+  return rules;
+}
+
+function assertManagedPermissionMode(mode, managed) {
+  if (
+    mode === "bypassPermissions" &&
+    (managed?.disableBypassPermissionsMode === true ||
+      managed?.disableBypassPermissionsMode === "disable")
+  ) {
+    throw new Error(
+      'permission mode "bypassPermissions" is disabled by managed settings',
+    );
+  }
+  return mode;
+}
+
 /** Parse a comma/space separated env override into a string[]. */
 function parseEnvList(value) {
   if (!value) return [];
@@ -116,7 +179,7 @@ function loadSettings(opts = {}) {
   const env = opts.env || process.env;
   const onWarn = opts.onWarn;
 
-  const rules = { allow: [], ask: [], deny: [] };
+  let rules = emptyRules();
   const sources = {};
   const files = [];
 
@@ -150,7 +213,27 @@ function loadSettings(opts = {}) {
   }
   if (envContributed) files.push("<env>");
 
-  return { rules, sources, files };
+  const managedLoaded = loadManagedSettings({
+    env,
+    managedSettingsFile: opts.managedSettingsFile,
+    onWarn,
+  });
+  if (managedLoaded.settings) {
+    rules = applyManagedPermissionPolicy(
+      rules,
+      managedLoaded.settings,
+      sources,
+    );
+    files.push(managedLoaded.file);
+  }
+
+  return {
+    rules,
+    sources,
+    files,
+    managed: managedLoaded.settings,
+    managedFile: managedLoaded.settings ? managedLoaded.file : null,
+  };
 }
 
 /** Look up the source file a matched `{ kind, rule }` came from. */
@@ -236,6 +319,24 @@ function loadSettingsConfig(opts = {}) {
     }
     if (contributed) files.push(file);
   }
+  const managed = loadManagedSettings(opts);
+  if (managed.settings) {
+    const data = managed.settings;
+    let contributed = false;
+    if (typeof data.model === "string" && data.model.trim()) {
+      model = data.model.trim();
+      contributed = true;
+    }
+    if (data.env && typeof data.env === "object" && !Array.isArray(data.env)) {
+      for (const [k, v] of Object.entries(data.env)) {
+        if (typeof v === "string") {
+          env[k] = v;
+          contributed = true;
+        }
+      }
+    }
+    if (contributed) files.push(managed.file);
+  }
   return { model, env, files };
 }
 
@@ -270,6 +371,14 @@ function readBooleanSetting(key, opts = {}) {
       value = node; // last (closest) layer wins
     }
   }
+  const managed = loadManagedSettings(opts);
+  if (managed.settings) {
+    let node = managed.settings;
+    for (const p of parts) {
+      node = node && typeof node === "object" ? node[p] : undefined;
+    }
+    if (typeof node === "boolean") value = node;
+  }
   return value;
 }
 
@@ -279,6 +388,10 @@ module.exports = {
   readSettingsFile,
   readBooleanSetting,
   settingsPaths,
+  managedSettingsPath,
+  loadManagedSettings,
+  applyManagedPermissionPolicy,
+  assertManagedPermissionMode,
   parseEnvList,
   ruleSource,
   addRule,

package/src/lib/task-list.js

@@ -0,0 +1,53 @@
+/**
+ * Background task listing utilities (ESM)
+ * Mirrors Claude Code /tasks behavior
+ * @module lib/task-list
+ */
+
+import { listBackgroundShellTasks } from "../runtime/agent-core.js";
+import { formatBackgroundTasks } from "../repl/tasks-status.js";
+import { logger } from "./logger.js";
+
+/**
+ * List all background tasks
+ * @param {Object} options List options
+ * @returns {Promise<Object>} task list result
+ */
+export async function listTasks(options = {}) {
+  const tasks = listBackgroundShellTasks();
+  const active = tasks.filter((t) => t.status === "running");
+  const completed = tasks.filter((t) => t.status !== "running");
+
+  if (tasks.length === 0) {
+    logger.info("No background tasks");
+    return { count: 0, active: 0, completed: 0, tasks: [] };
+  }
+
+  if (!options.quiet) {
+    logger.info(formatBackgroundTasks(tasks));
+  }
+
+  logger.info(
+    `  ${active.length} active, ${completed.length} completed (total: ${tasks.length})`,
+  );
+
+  return {
+    count: tasks.length,
+    active: active.length,
+    completed: completed.length,
+    tasks,
+    formatted: formatBackgroundTasks(tasks),
+  };
+}
+
+/**
+ * Get a specific task by ID
+ * @param {string} taskId
+ * @returns {Object|null}
+ */
+export function getTask(taskId) {
+  const tasks = listBackgroundShellTasks();
+  return tasks.find((t) => t.id === taskId) || null;
+}
+
+export default { listTasks, getTask };

package/src/program-base.js

@@ -0,0 +1,24 @@
+/**
+ * Shared base Commander program factory.
+ *
+ * Both the eager path (src/index.js `createProgram`, used by tests, help, and
+ * the unknown-command fallback) and the lazy fast path (src/lazy-dispatch.js,
+ * used by the bin for a resolved `cc <cmd>`) build their program from this so
+ * the program name, version flag, and global options can never drift between
+ * the two code paths.
+ */
+import { Command } from "commander";
+import { VERSION } from "./constants.js";
+
+export function createBaseProgram() {
+  const program = new Command();
+  program
+    .name("chainlesschain")
+    .description(
+      "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
+    )
+    .version(VERSION, "-v, --version")
+    .option("--verbose", "Enable verbose output")
+    .option("--quiet", "Suppress non-essential output");
+  return program;
+}