chainlesschain 0.162.148 → 0.162.149

package/src/lib/settings-loader.cjs

@@ -300,6 +300,7 @@ function loadSettingsConfig(opts = {}) {
   const cwd = opts.cwd || process.cwd();
   let model = null;
   const env = {};
+  let sandbox = null;
   const files = [];
   for (const file of settingsPaths(cwd, opts.settingsFile)) {
     const data = readSettingsFile(file, { onWarn: opts.onWarn });
@@ -317,6 +318,14 @@ function loadSettingsConfig(opts = {}) {
         }
       }
     }
+    if (
+      data.sandbox &&
+      typeof data.sandbox === "object" &&
+      !Array.isArray(data.sandbox)
+    ) {
+      sandbox = mergeSandboxSettings(sandbox, data.sandbox);
+      contributed = true;
+    }
     if (contributed) files.push(file);
   }
   const managed = loadManagedSettings(opts);
@@ -335,9 +344,33 @@ function loadSettingsConfig(opts = {}) {
         }
       }
     }
+    if (
+      data.sandbox &&
+      typeof data.sandbox === "object" &&
+      !Array.isArray(data.sandbox)
+    ) {
+      sandbox = mergeSandboxSettings(sandbox, data.sandbox);
+      contributed = true;
+    }
     if (contributed) files.push(managed.file);
   }
-  return { model, env, files };
+  return { model, env, sandbox, files };
+}
+
+function mergeSandboxSettings(base, overlay) {
+  const out =
+    base && typeof base === "object" ? JSON.parse(JSON.stringify(base)) : {};
+  for (const [key, value] of Object.entries(overlay || {})) {
+    if (Array.isArray(value)) {
+      const previous = Array.isArray(out[key]) ? out[key] : [];
+      out[key] = [...new Set([...previous, ...value].map(String))];
+    } else if (value && typeof value === "object") {
+      out[key] = mergeSandboxSettings(out[key], value);
+    } else if (["string", "boolean", "number"].includes(typeof value)) {
+      out[key] = value;
+    }
+  }
+  return out;
 }
 
 /**
@@ -393,6 +426,7 @@ module.exports = {
   applyManagedPermissionPolicy,
   assertManagedPermissionMode,
   parseEnvList,
+  mergeSandboxSettings,
   ruleSource,
   addRule,
   scopeFile,

package/src/lib/skill-loader.js

@@ -28,6 +28,7 @@ import { getElectronUserDataDir } from "./paths.js";
 import { findProjectRoot } from "./project-detector.js";
 import { findProjectRoot as findGitRoot } from "./project-instructions.js";
 import { parseSkillMcpServers } from "./skill-mcp.js";
+import { discoverPluginSkillLayers } from "./plugin-runtime/skills.js";
 import settingsLoader from "./settings-loader.cjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -72,6 +73,7 @@ export const LAYER_NAMES = [
   "bundled",
   "cli-bundled",
   "marketplace",
+  "plugin",
   "managed",
   "claude-user",
   "claude-project",
@@ -312,6 +314,22 @@ export class CLISkillLoader {
       exists: fs.existsSync(marketplacePath),
     });
 
+    // Layer 1b: plugin — each installed plugin's skills/ dir (Phase 3). Sits
+    // just above marketplace so a user's managed/workspace/project skills still
+    // override a plugin's on a name collision. One entry per plugin.
+    try {
+      for (const p of discoverPluginSkillLayers({ cwd: process.cwd() })) {
+        layers.push({
+          layer: "plugin",
+          path: p.path,
+          exists: fs.existsSync(p.path),
+          plugin: p.name,
+        });
+      }
+    } catch {
+      /* plugin skill discovery is best-effort — never break skill loading */
+    }
+
     // Layer 2: managed — <userData>/skills/
     const managedPath = path.join(userData, "skills");
     layers.push({

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

@@ -0,0 +1,237 @@
+/**
+ * TelemetryRecorder (Phase 7) — a dependency-free, OpenTelemetry-SHAPED span +
+ * metrics recorder for the agent's real execution (model calls, tool calls,
+ * cache, retries, failures). The plan asks to "引入 OpenTelemetry，覆盖模型、
+ * 工具、缓存、重试和失败分类" — but pulling the `@opentelemetry/*` SDK in (a
+ * heavy dep tree that also needs a running collector) is the wrong default for a
+ * ~2 MB CLI. This records the SAME span/attribute model and can emit OTLP JSON
+ * (`toOtlp()`) so a real collector can ingest it later, without the dependency.
+ *
+ * It captures the plan's metric set — per-name durations (avg/p50/p95/max),
+ * counters (token / cost / cache-hit / retry), and failure classification — and
+ * `summary()` renders them. The clock is injected so tests are deterministic.
+ */
+
+let _seq = 0;
+function spanId() {
+  _seq = (_seq + 1) % Number.MAX_SAFE_INTEGER;
+  // 16-hex-ish id derived from a monotonic counter (deterministic, no RNG —
+  // Math.random is intentionally avoided so callers can snapshot/replay).
+  return _seq.toString(16).padStart(16, "0");
+}
+
+export class TelemetryRecorder {
+  constructor({
+    now = () => Date.now(),
+    serviceName = "chainlesschain-cli",
+  } = {}) {
+    this._now = typeof now === "function" ? now : () => now;
+    this.serviceName = serviceName;
+    this._spans = []; // completed spans
+    this._counters = new Map(); // name → { total, byAttr }
+    this._failures = new Map(); // category → count
+  }
+
+  /**
+   * Start a span. Returns a handle; call `.end()` (optionally with a status /
+   * extra attributes) to record it. Nesting is expressed via `parentId`.
+   */
+  startSpan(name, attributes = {}, { parentId = null } = {}) {
+    const id = spanId();
+    const start = this._now();
+    const attrs = { ...attributes };
+    const events = [];
+    const self = this;
+    let ended = false;
+    return {
+      id,
+      name,
+      setAttribute(k, v) {
+        attrs[k] = v;
+        return this;
+      },
+      addEvent(evName, evAttrs = {}) {
+        events.push({
+          name: evName,
+          time: self._now(),
+          attributes: { ...evAttrs },
+        });
+        return this;
+      },
+      /**
+       * Record a failure on this span, classified into a category (defaults to
+       * the error name) so `summary().failures` aggregates by cause.
+       */
+      recordException(err, category) {
+        const cat = category || err?.code || err?.name || "error";
+        attrs["failure.category"] = cat;
+        attrs["error"] = true;
+        events.push({
+          name: "exception",
+          time: self._now(),
+          attributes: {
+            "exception.message": err?.message || String(err),
+            "exception.category": cat,
+          },
+        });
+        self._failures.set(cat, (self._failures.get(cat) || 0) + 1);
+        return this;
+      },
+      end(extra = {}) {
+        if (ended) return; // idempotent
+        ended = true;
+        const endTime = self._now();
+        Object.assign(attrs, extra.attributes || {});
+        const status = extra.status || (attrs.error ? "error" : "ok");
+        self._spans.push({
+          id,
+          parentId,
+          name,
+          startTime: start,
+          endTime,
+          durationMs: endTime - start,
+          status,
+          attributes: attrs,
+          events,
+        });
+      },
+    };
+  }
+
+  /** Increment a named counter (tokens, cost, cache.hit, retry, …). */
+  counter(name, value = 1, attributes = {}) {
+    const entry = this._counters.get(name) || { total: 0, byAttr: {} };
+    entry.total += value;
+    for (const [k, v] of Object.entries(attributes)) {
+      const key = `${k}=${v}`;
+      entry.byAttr[key] = (entry.byAttr[key] || 0) + value;
+    }
+    this._counters.set(name, entry);
+    return entry.total;
+  }
+
+  _percentile(sorted, p) {
+    if (sorted.length === 0) return 0;
+    // nearest-rank
+    const rank = Math.ceil((p / 100) * sorted.length);
+    return sorted[Math.min(rank, sorted.length) - 1];
+  }
+
+  /** Aggregate metrics across everything recorded so far. */
+  summary() {
+    const byName = {};
+    for (const s of this._spans) {
+      (byName[s.name] = byName[s.name] || []).push(s);
+    }
+    const durations = {};
+    for (const [name, spans] of Object.entries(byName)) {
+      const ds = spans.map((s) => s.durationMs).sort((a, b) => a - b);
+      const total = ds.reduce((a, b) => a + b, 0);
+      const errors = spans.filter((s) => s.status === "error").length;
+      durations[name] = {
+        count: spans.length,
+        errors,
+        totalMs: total,
+        avgMs: Math.round(total / spans.length),
+        p50Ms: this._percentile(ds, 50),
+        p95Ms: this._percentile(ds, 95),
+        maxMs: ds[ds.length - 1] || 0,
+      };
+    }
+    const counters = {};
+    for (const [name, entry] of this._counters) {
+      counters[name] = { total: entry.total, byAttr: { ...entry.byAttr } };
+    }
+    const failures = {};
+    let failureTotal = 0;
+    for (const [cat, n] of this._failures) {
+      failures[cat] = n;
+      failureTotal += n;
+    }
+    return {
+      spanCount: this._spans.length,
+      durations,
+      counters,
+      failures,
+      failureTotal,
+    };
+  }
+
+  /** OTLP/JSON-shaped export (resourceSpans) — ingestible by an OTel collector. */
+  toOtlp() {
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              { key: "service.name", value: { stringValue: this.serviceName } },
+            ],
+          },
+          scopeSpans: [
+            {
+              scope: { name: "chainlesschain.cli" },
+              spans: this._spans.map((s) => ({
+                traceId: "0".repeat(32),
+                spanId: s.id,
+                parentSpanId: s.parentId || "",
+                name: s.name,
+                startTimeUnixNano: s.startTime * 1e6,
+                endTimeUnixNano: s.endTime * 1e6,
+                status: { code: s.status === "error" ? 2 : 1 },
+                attributes: Object.entries(s.attributes).map(([k, v]) => ({
+                  key: k,
+                  value:
+                    typeof v === "number"
+                      ? { doubleValue: v }
+                      : typeof v === "boolean"
+                        ? { boolValue: v }
+                        : { stringValue: String(v) },
+                })),
+                events: s.events.map((e) => ({
+                  name: e.name,
+                  timeUnixNano: e.time * 1e6,
+                  attributes: Object.entries(e.attributes).map(([k, v]) => ({
+                    key: k,
+                    value: { stringValue: String(v) },
+                  })),
+                })),
+              })),
+            },
+          ],
+        },
+      ],
+    };
+  }
+
+  spans() {
+    return this._spans.slice();
+  }
+
+  reset() {
+    this._spans = [];
+    this._counters = new Map();
+    this._failures = new Map();
+  }
+}
+
+/** Render a summary as a compact text block. */
+export function formatTelemetry(summary) {
+  const lines = [];
+  lines.push(`Telemetry: ${summary.spanCount} span(s)`);
+  for (const [name, d] of Object.entries(summary.durations)) {
+    lines.push(
+      `  ${name}: n=${d.count}${d.errors ? ` err=${d.errors}` : ""} ` +
+        `avg=${d.avgMs}ms p50=${d.p50Ms}ms p95=${d.p95Ms}ms max=${d.maxMs}ms`,
+    );
+  }
+  for (const [name, c] of Object.entries(summary.counters)) {
+    lines.push(`  ${name}: ${c.total}`);
+  }
+  if (summary.failureTotal > 0) {
+    const parts = Object.entries(summary.failures)
+      .map(([cat, n]) => `${cat}=${n}`)
+      .join(", ");
+    lines.push(`  failures: ${summary.failureTotal} (${parts})`);
+  }
+  return lines.join("\n");
+}