chainlesschain 0.162.149 → 0.162.151

package/src/lib/sandbox-v2.js

@@ -6,6 +6,7 @@
 import crypto from "crypto";
 import { safeJsonParse } from "./safe-json.js";
 import { evaluateNetworkAccess } from "./sandbox-network-policy.js";
+import { evaluatePathAccess } from "./sandbox-fs-policy.js";
 import { createRequire } from "module";
 
 const _require = createRequire(import.meta.url);
@@ -142,20 +143,19 @@ export function ensureSandboxTables(db) {
 // ─── Permission checking ──────────────────────────────────────
 
 function checkFilePermission(permissions, filePath, mode) {
-  const fs = permissions.fileSystem || {};
-  const denied = fs.denied || [];
-  for (const d of denied) {
-    if (filePath.startsWith(d)) return false;
-  }
-  if (mode === "read") {
-    const allowed = fs.read || [];
-    return allowed.some((p) => filePath.startsWith(p));
-  }
-  if (mode === "write") {
-    const allowed = fs.write || [];
-    return allowed.some((p) => filePath.startsWith(p));
-  }
-  return false;
+  // Delegate to the shared path policy: `path.resolve` collapses `..` (traversal),
+  // a `path.relative` boundary rejects `/tmpfoo` matching `/tmp`, and symlinks are
+  // resolved so a link inside an allowed dir can't escape. The old check was
+  // `filePath.startsWith(root)` and let all three through.
+  const fsPol = permissions.fileSystem || {};
+  return evaluatePathAccess(filePath, {
+    mode,
+    policy: {
+      read: fsPol.read || [],
+      write: fsPol.write || [],
+      denied: fsPol.denied || [],
+    },
+  }).allowed;
 }
 
 function checkNetworkPermission(permissions, host) {

package/src/lib/scim-manager.js

@@ -211,6 +211,42 @@ export function _resetState() {
   _syncLog.length = 0;
 }
 
+/**
+ * Rehydrate the in-memory _users Map from the persisted scim_resources table.
+ * The CLI runs each `cc scim` subcommand in a fresh node process, so _users
+ * starts empty every invocation. createUser dual-writes (Map + INSERT INTO
+ * scim_resources) but listUsers/getUser/deleteUser/getStatus are Map-only and
+ * nothing SELECTed the table back — so a provisioned user was invisible next
+ * invocation (`No SCIM users.` / `User not found`), and deleteUser threw before
+ * its DELETE ran, orphaning rows with no CLI path to remove them. The duplicate
+ * check in createUser was also blind, allowing duplicate userNames on disk.
+ * Call after ensureSCIMTables(db).
+ *
+ * Mirrors the write-side shape exactly (active INTEGER→boolean).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSCIMTables(db);
+  _users.clear();
+  for (const r of db
+    .prepare(
+      `SELECT id, display_name, user_name, email, active, created_at, updated_at
+         FROM scim_resources WHERE resource_type = 'User' ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _users.set(r.id, {
+      id: r.id,
+      userName: r.user_name,
+      displayName: r.display_name || r.user_name,
+      email: r.email || null,
+      active: !!r.active,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+    });
+  }
+  return _users.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * V2 Surface — SCIM provisioning lifecycle layer.
  * Tracks identities and sync-job lifecycle independent of legacy

package/src/lib/session-manager.js

@@ -129,10 +129,13 @@ export function getSession(db, sessionId) {
 
   return {
     ...session,
-    messages: JSON.parse(session.messages || "[]"),
+    // A single corrupt (non-JSON, non-empty) column must not make the whole
+    // session unloadable — that would block resume of the user's own data.
+    // Matches the safeJsonParse fallback listSessions already uses.
+    messages: safeJsonParse(session.messages, []),
     metadata:
       typeof session.metadata === "string"
-        ? JSON.parse(session.metadata || "{}")
+        ? safeJsonParse(session.metadata, {})
         : session.metadata || {},
   };
 }

package/src/lib/settings-hooks.cjs

@@ -48,6 +48,7 @@ const HOOK_EVENTS = Object.freeze([
   "ConfigChange",
   "PreCompact",
   "Notification",
+  "PermissionRequest",
 ]);
 
 /**

package/src/lib/siem-exporter.js

@@ -136,6 +136,51 @@ export function _resetState() {
   _exports.length = 0;
 }
 
+/**
+ * Rehydrate the in-memory _targets Map from the persisted siem_exports table.
+ * The CLI runs each `cc siem` subcommand in a fresh node process, so _targets
+ * starts empty every invocation. addTarget dual-writes (Map + INSERT INTO
+ * siem_exports) but every read (listTargets/exportLogs/getSIEMStats/
+ * removeTarget/setTargetStatus/listTargetsByStatus) is Map-only and nothing
+ * SELECTed the table back — so a target added in one invocation was invisible in
+ * the next (`No SIEM targets configured.`) and `siem export <id>` hard-crashed
+ * with `Target not found` for a target that genuinely exists on disk. Call after
+ * ensureSIEMTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSIEMTables(db);
+  _targets.clear();
+  for (const r of db
+    .prepare(
+      `SELECT id, target_type, target_url, format, last_exported_log_id,
+              exported_count, last_export_at, status, config, created_at
+         FROM siem_exports ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt config cell must not sink the whole target load.
+    let config = {};
+    try {
+      config = r.config ? JSON.parse(r.config) : {};
+    } catch {
+      config = {};
+    }
+    _targets.set(r.id, {
+      id: r.id,
+      type: r.target_type,
+      url: r.target_url,
+      format: r.format,
+      exportedCount: Number(r.exported_count) || 0,
+      lastExportAt: r.last_export_at ?? null,
+      lastExportedLogId: r.last_exported_log_id ?? null,
+      status: r.status,
+      config,
+      createdAt: r.created_at,
+    });
+  }
+  return _targets.size;
+}
+
 // ═══════════════════════════════════════════════════════════════
 // V2 Canonical Surface (Phase 51)
 // ═══════════════════════════════════════════════════════════════

package/src/lib/skill-loader.js

@@ -84,6 +84,17 @@ export const LAYER_NAMES = [
  *  `<group>/<skill>/SKILL.md` layouts (infinite-recursion / deep-tree guard). */
 export const MAX_SKILL_NEST_DEPTH = 5;
 
+// Frontmatter keys (camelCased) that are semantically strings and are consumed
+// with string methods; they must never be number/boolean-coerced. `version` is
+// deliberately excluded — it is only string-interpolated and existing behavior
+// coerces it to a number.
+const STRING_SCALAR_FIELDS = new Set([
+  "name",
+  "displayName",
+  "description",
+  "category",
+]);
+
 /**
  * Simple YAML frontmatter parser (no dependencies)
  * Shared utility extracted from skill.js
@@ -165,8 +176,15 @@ export function parseSkillMd(content) {
         continue;
       }
 
-      // Handle booleans and numbers
-      if (value === "true") value = true;
+      // Handle booleans and numbers. These fields are string-semantic and get
+      // used with string methods downstream (skill.id.includes(),
+      // description.substring(), category/displayName.toLowerCase()); coercing a
+      // bare numeric ("2024") or boolean value to Number/Boolean makes those
+      // throw and aborts the whole `cc skill list/search/run` command on a
+      // single such skill — so never coerce them. (version stays coercible.)
+      if (STRING_SCALAR_FIELDS.has(camelKey))
+        value = value.replace(/^['"]|['"]$/g, "");
+      else if (value === "true") value = true;
       else if (value === "false") value = false;
       else if (value === "null") value = null;
       else if (/^\d+(\.\d+)?$/.test(value)) value = parseFloat(value);

package/src/lib/skill-marketplace.js

@@ -109,6 +109,89 @@ export function ensureMarketplaceTables(db) {
   );
 }
 
+/**
+ * Hydrate the in-memory _services/_invocations Maps from the DB. The CLI is
+ * one-shot: both start empty each process. Writes dual-write (Map + INSERT) but
+ * every read (getService/listServices/listInvocations/getInvocationStats/
+ * getMarketplaceStatsV2) and _mustGetService (record/status/invoke) is Map-only
+ * and nothing SELECTed the tables back — so a published service was invisible on
+ * the next invocation, and record/show/status threw "Service not found". Call
+ * after ensureMarketplaceTables(db).
+ *
+ * V2 timing fields (startedAt/completedAt) are not persisted → default null.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureMarketplaceTables(db);
+  _services.clear();
+  _invocations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, version, description, endpoint, pricing, status, owner, invocation_count, created_at, updated_at
+         FROM skill_services ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt pricing cell must not crash the whole service load.
+    let pricing = null;
+    try {
+      pricing = r.pricing ? JSON.parse(r.pricing) : null;
+    } catch {
+      pricing = null;
+    }
+    _services.set(r.id, {
+      id: r.id,
+      name: r.name,
+      version: r.version,
+      description: r.description || "",
+      endpoint: r.endpoint,
+      pricing,
+      status: r.status,
+      owner: r.owner,
+      invocationCount: Number(r.invocation_count) || 0,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, service_id, caller_id, input, output, status, duration_ms, error, created_at
+         FROM skill_invocations ORDER BY created_at ASC`,
+    )
+    .all()) {
+    let input = null;
+    let output = null;
+    try {
+      input = r.input == null ? null : JSON.parse(r.input);
+    } catch {
+      input = r.input;
+    }
+    try {
+      output = r.output == null ? null : JSON.parse(r.output);
+    } catch {
+      output = r.output;
+    }
+    _invocations.set(r.id, {
+      id: r.id,
+      serviceId: r.service_id,
+      callerId: r.caller_id,
+      input,
+      output,
+      status: r.status,
+      durationMs: r.duration_ms == null ? null : Number(r.duration_ms),
+      error: r.error,
+      createdAt: Number(r.created_at),
+      startedAt: null,
+      completedAt: null,
+      _seq: ++_seq,
+    });
+  }
+
+  return _services.size + _invocations.size;
+}
+
 /* ── Catalogs ──────────────────────────────────────────────── */
 
 export function listServiceStatus() {

package/src/lib/sla-manager.js

@@ -484,6 +484,94 @@ export function _resetState() {
   _maxActiveSlasPerOrg = DEFAULT_MAX_ACTIVE_SLAS_PER_ORG;
 }
 
+/**
+ * Rehydrate the in-memory Maps from the persisted sla_* tables. The CLI runs
+ * each `cc sla` subcommand in a fresh node process, so _contracts/_metrics/
+ * _violations start empty every invocation. Every write dual-writes (Map +
+ * INSERT into sla_contracts/sla_metrics/sla_violations) but every read (listSLAs/
+ * getSLA/getSLAMetrics/checkViolations/listViolations/calculateCompensation/
+ * generateReport) is Map-only and nothing SELECTed the tables back — so `sla
+ * list` reported none, and `show`/`record`/`metrics`/`report` threw "SLA not
+ * found" for a contract that genuinely exists on disk. Call after
+ * ensureSlaTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureSlaTables(db);
+  _contracts.clear();
+  _metrics.clear();
+  _violations.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT sla_id, org_id, tier, terms, monthly_fee, start_date, end_date, status, created_at, updated_at
+         FROM sla_contracts ORDER BY created_at ASC`,
+    )
+    .all()) {
+    // One corrupt terms cell must not sink the whole contract list.
+    let terms = {};
+    try {
+      terms = r.terms ? JSON.parse(r.terms) : {};
+    } catch {
+      terms = {};
+    }
+    _contracts.set(r.sla_id, {
+      slaId: r.sla_id,
+      orgId: r.org_id,
+      tier: r.tier,
+      terms,
+      monthlyFee: Number(r.monthly_fee) || 0,
+      startDate: Number(r.start_date),
+      endDate: Number(r.end_date),
+      status: r.status,
+      createdAt: Number(r.created_at),
+      updatedAt: Number(r.updated_at),
+      _seq: ++_seq,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT metric_id, sla_id, term, value, recorded_at
+         FROM sla_metrics ORDER BY recorded_at ASC`,
+    )
+    .all()) {
+    if (!_metrics.has(r.sla_id)) _metrics.set(r.sla_id, []);
+    _metrics.get(r.sla_id).push({
+      metricId: r.metric_id,
+      slaId: r.sla_id,
+      term: r.term,
+      value: Number(r.value),
+      recordedAt: Number(r.recorded_at),
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT violation_id, sla_id, term, severity, expected_value, actual_value,
+              deviation_percent, compensation_amount, occurred_at, resolved_at
+         FROM sla_violations ORDER BY occurred_at ASC`,
+    )
+    .all()) {
+    _violations.set(r.violation_id, {
+      violationId: r.violation_id,
+      slaId: r.sla_id,
+      term: r.term,
+      severity: r.severity,
+      expectedValue: Number(r.expected_value),
+      actualValue: Number(r.actual_value),
+      deviationPercent:
+        r.deviation_percent == null ? null : Number(r.deviation_percent),
+      compensationAmount:
+        r.compensation_amount == null ? null : Number(r.compensation_amount),
+      occurredAt: Number(r.occurred_at),
+      resolvedAt: r.resolved_at == null ? null : Number(r.resolved_at),
+    });
+  }
+
+  return _contracts.size + _metrics.size + _violations.size;
+}
+
 /* ═══════════════════════════════════════════════════════════════
  * V2 (Phase 61) — Frozen enums + contract/violation state
  * machines + active-per-org cap + auto-expire + stats-v2.

package/src/lib/social-manager.js

@@ -54,6 +54,80 @@ export function ensureSocialTables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory stores from the DB. The CLI is one-shot: every command
+ * runs in a fresh process, so the module-level Maps start empty. Write paths
+ * dual-write (Map + DB), but the read paths (listContacts/listFriends/listPosts/
+ * getChatMessages/getChatThreads/getSocialStats) read the Maps ONLY — so without
+ * this, a user's persisted contacts/friends/posts/messages are invisible on the
+ * next invocation. Mirrors social-graph.loadFromDb (the asymmetry tell: graph
+ * commands hydrate, social commands didn't). Call after ensureSocialTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _contacts.clear();
+  _friends.clear();
+  _posts.clear();
+  _messages.clear();
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, did, email, notes, created_at FROM social_contacts`,
+    )
+    .all()) {
+    _contacts.set(r.id, {
+      id: r.id,
+      name: r.name,
+      did: r.did || null,
+      email: r.email || null,
+      notes: r.notes || "",
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, contact_id, status, created_at FROM social_friends`)
+    .all()) {
+    // Keyed by contact_id to match addFriend's _friends.set(contactId, ...).
+    _friends.set(r.contact_id, {
+      id: r.id,
+      contactId: r.contact_id,
+      status: r.status,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(`SELECT id, author, content, likes, created_at FROM social_posts`)
+    .all()) {
+    _posts.set(r.id, {
+      id: r.id,
+      author: r.author,
+      content: r.content,
+      likes: r.likes,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, thread_id, sender, recipient, content, read, created_at FROM social_messages`,
+    )
+    .all()) {
+    _messages.set(r.id, {
+      id: r.id,
+      threadId: r.thread_id,
+      sender: r.sender,
+      recipient: r.recipient,
+      content: r.content,
+      read: !!r.read,
+      createdAt: r.created_at,
+    });
+  }
+
+  return _contacts.size + _friends.size + _posts.size + _messages.size;
+}
+
 /* ── Contacts ──────────────────────────────────────────────── */
 
 export function addContact(db, name, did, email, notes) {

package/src/lib/stress-tester.js

@@ -95,6 +95,71 @@ export function ensureStressTables(db) {
   `);
 }
 
+/**
+ * Rehydrate _runs/_results from the persisted stress_test_runs/
+ * stress_test_results tables. The `cc` CLI runs every command in a fresh
+ * process, so without this the Maps start empty and a run recorded in a prior
+ * invocation is invisible (`cc stress list` shows "No stress tests recorded.";
+ * `cc stress show <id>` throws "Stress test not found"). Call after
+ * ensureStressTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _runs.clear();
+  _results.clear();
+
+  const resultRows = db.prepare(`SELECT * FROM stress_test_results`).all();
+  for (const row of resultRows) {
+    let bottlenecks = [];
+    let capacityRecommendations = [];
+    try {
+      bottlenecks = row.bottlenecks ? JSON.parse(row.bottlenecks) : [];
+    } catch {
+      bottlenecks = [];
+    }
+    try {
+      capacityRecommendations = row.capacity_recommendations
+        ? JSON.parse(row.capacity_recommendations)
+        : [];
+    } catch {
+      capacityRecommendations = [];
+    }
+    _results.set(row.test_id, {
+      resultId: row.result_id,
+      testId: row.test_id,
+      tps: row.tps,
+      avgResponseTime: row.avg_response_time,
+      p50ResponseTime: row.p50_response_time,
+      p95ResponseTime: row.p95_response_time,
+      p99ResponseTime: row.p99_response_time,
+      errorRate: row.error_rate,
+      bottlenecks,
+      capacityRecommendations,
+      createdAt: row.created_at,
+    });
+  }
+
+  const runRows = db.prepare(`SELECT * FROM stress_test_runs`).all();
+  for (const row of runRows) {
+    _runs.set(row.test_id, {
+      testId: row.test_id,
+      loadLevel: row.load_level,
+      concurrency: row.concurrency,
+      requestsPerSecond: row.requests_per_second,
+      duration: row.duration,
+      status: row.status,
+      startedAt: row.started_at,
+      completedAt: row.completed_at ?? null,
+      // _seq is a per-process monotonic tiebreaker; started_at is the primary
+      // sort key. Reassign in load order — ties (same ms) are the only case it
+      // affects and are cosmetic for history ordering.
+      _seq: ++_seq,
+    });
+  }
+
+  return _runs.size + _results.size;
+}
+
 /* ── Synthetic metrics ─────────────────────────────────────── */
 
 // Deterministic quasi-random: stable across runs for the same inputs. Tests

package/src/lib/tech-learning-engine.js

@@ -169,6 +169,81 @@ export function ensureTechLearningTables(db) {
   );
 }
 
+/**
+ * Rehydrate _profiles/_practices from the persisted tech_stack_profiles/
+ * learned_practices tables. The `cc` CLI runs every command in a fresh process,
+ * so without this the Maps start empty and a profile/practice recorded in a
+ * prior invocation is invisible (`cc tech profile` returns null, `cc tech
+ * practices` shows nothing, `cc tech recommend` can't infer the latest stack).
+ * Call after ensureTechLearningTables(db). The profile's frameworks/databases/
+ * tools/libraries are not stored as columns — they are reconstructed from the
+ * classified tech_stack exactly as analyzeTechStack derives them.
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  _profiles.clear();
+  _practices.clear();
+
+  const profileRows = db.prepare(`SELECT * FROM tech_stack_profiles`).all();
+  for (const row of profileRows) {
+    let classified = [];
+    let deps = [];
+    let languages = [];
+    try {
+      classified = row.tech_stack ? JSON.parse(row.tech_stack) : [];
+    } catch {
+      classified = [];
+    }
+    try {
+      deps = row.dependencies ? JSON.parse(row.dependencies) : [];
+    } catch {
+      deps = [];
+    }
+    try {
+      languages = row.languages ? JSON.parse(row.languages) : [];
+    } catch {
+      languages = [];
+    }
+    const byType = (t) =>
+      classified.filter((d) => d.type === t).map((d) => d.name);
+    _profiles.set(row.project_path, {
+      profileId: row.profile_id,
+      projectPath: row.project_path,
+      languages,
+      frameworks: byType(TECH_TYPES.FRAMEWORK),
+      databases: byType(TECH_TYPES.DATABASE),
+      tools: byType(TECH_TYPES.TOOL),
+      libraries: byType(TECH_TYPES.LIBRARY),
+      totalDependencies: deps.length,
+      analysisTimestamp: row.analysis_timestamp,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  const practiceRows = db.prepare(`SELECT * FROM learned_practices`).all();
+  for (const row of practiceRows) {
+    _practices.set(row.practice_id, {
+      practiceId: row.practice_id,
+      techType: row.tech_type,
+      techName: row.tech_name,
+      patternName: row.pattern_name,
+      level: row.level,
+      description: row.description ?? "",
+      codeExample: row.code_example ?? "",
+      usageCount: row.usage_count ?? 0,
+      score: row.score ?? 0,
+      source: row.source,
+      learnedAt: row.learned_at,
+      updatedAt: row.updated_at,
+      _seq: ++_seq,
+    });
+  }
+
+  return _profiles.size + _practices.size;
+}
+
 /* ── Parsers for dependency manifests ──────────────────────── */
 
 function _readIfExists(filePath) {

package/src/lib/telemetry/span-recorder.js

@@ -20,6 +20,16 @@ function spanId() {
   return _seq.toString(16).padStart(16, "0");
 }
 
+// One trace per recorder (a "run"). The OTLP/OTel spec treats an ALL-ZERO
+// traceId as INVALID, so a strict collector would drop every span exported with
+// `"0".repeat(32)` — defeating toOtlp()'s purpose. Derive a non-zero, monotonic
+// (RNG-free, snapshot-replayable) 32-hex traceId per recorder instead.
+let _traceSeq = 0;
+function newTraceId() {
+  _traceSeq = (_traceSeq + 1) % Number.MAX_SAFE_INTEGER;
+  return _traceSeq.toString(16).padStart(32, "0"); // never all-zero (starts at 1)
+}
+
 export class TelemetryRecorder {
   constructor({
     now = () => Date.now(),
@@ -27,6 +37,7 @@ export class TelemetryRecorder {
   } = {}) {
     this._now = typeof now === "function" ? now : () => now;
     this.serviceName = serviceName;
+    this.traceId = newTraceId(); // one trace per recorder (valid non-zero id)
     this._spans = []; // completed spans
     this._counters = new Map(); // name → { total, byAttr }
     this._failures = new Map(); // category → count
@@ -171,7 +182,7 @@ export class TelemetryRecorder {
             {
               scope: { name: "chainlesschain.cli" },
               spans: this._spans.map((s) => ({
-                traceId: "0".repeat(32),
+                traceId: this.traceId,
                 spanId: s.id,
                 parentSpanId: s.parentId || "",
                 name: s.name,