chainlesschain 0.162.184 → 0.162.186

package/src/lib/hook-runner.js

@@ -107,6 +107,8 @@ function runHookProcessSync(file, argsOrOptions, maybeOptions) {
 }
 
 export function _restoreProcessRunners() {
+  _processDeps.run = brokerRunner;
+  _processDeps.runSync = brokerSyncRunner;
   runner._deps.run = runHookProcess;
   runner._deps.runSync = runHookProcessSync;
 }

package/src/lib/hooks-v2-runtime.js

@@ -30,6 +30,13 @@ import hookShellCommand from "./hook-shell-command.cjs";
 import permissionRules from "./permission-rules.cjs";
 import { EventRuntimeStore } from "./event-runtime-store.js";
 import { getDefaultEventRuntimeHost } from "./event-runtime-host.js";
+import {
+  currentHostHooksV2WorkspaceBinding,
+  currentHostHooksV2WorkspaceRoot,
+  registerHostHooksV2Workspace,
+  resolveRegisteredHostHooksV2Workspace,
+  runWithHostHooksV2Workspace,
+} from "./hooks-v2-workspace-context.js";
 
 const { globToRegExp } = permissionRules;
 const { buildManagedHookEnvironment } = hookEnvironment;
@@ -279,12 +286,31 @@ export function resolveHookSandboxPolicy(hook = {}, managedPolicy = {}) {
   return resolved;
 }
 
+function hooksRequireWorkspaceBinding(hooks, managedPolicy) {
+  return hooks.some((hook) => {
+    if (hook.type !== "command") return false;
+    try {
+      return requiresExplicitHookShell(
+        resolveHookSandboxPolicy(hook, managedPolicy),
+      );
+    } catch {
+      // Invalid policy is fail-closed during execution and must remain so after
+      // a crash instead of recovering without workspace authority.
+      return true;
+    }
+  });
+}
+
 export function assertManagedHookPolicy(
   hook,
   context = {},
   policy = {},
   configDir = null,
+  workspaceRoot = null,
 ) {
+  // Retained for API compatibility and non-command policy growth, but never
+  // consulted as filesystem authority.
+  void context;
   if (!managedListAllows(hook.type, policy.allowedExecutors)) {
     throw managedPolicyError(
       `Hook executor is outside the managed allowlist: ${hook.type}`,
@@ -309,7 +335,11 @@ export function assertManagedHookPolicy(
         `Hook command is outside the managed allowlist: ${executable}`,
       );
     }
-    const cwd = hook.cwd || context.cwd || configDir || process.cwd();
+    // The event context is payload, not workspace authority. Keep this
+    // selection identical to _execCommand so a forged context.cwd cannot make
+    // the managed-root check approve a different directory than the one the
+    // Broker will actually execute in.
+    const cwd = hook.cwd || configDir || workspaceRoot || process.cwd();
     if (!isInsideManagedRoot(cwd, policy.workspaceRoots)) {
       throw managedPolicyError(
         `Hook working directory is outside managed workspace roots: ${cwd}`,
@@ -435,7 +465,14 @@ class HooksV2Runtime extends EventEmitter {
     // Both values are host constructor inputs. Hook definitions may select a
     // cwd inside this root, but can never replace the writable root used to
     // issue a Linux one-shot execution contract.
-    this.workspaceRoot = options.workspaceRoot || configDir || null;
+    const configuredWorkspaceRoot = options.workspaceRoot || configDir || null;
+    this.workspaceBinding =
+      typeof configuredWorkspaceRoot === "string" &&
+      path.isAbsolute(configuredWorkspaceRoot)
+        ? registerHostHooksV2Workspace(configuredWorkspaceRoot)
+        : null;
+    this.workspaceRoot =
+      this.workspaceBinding?.workspaceRoot || configuredWorkspaceRoot;
     this.durableStore = options.durableStore || null;
     this.durableOwner =
       options.durableOwner ||
@@ -587,6 +624,12 @@ class HooksV2Runtime extends EventEmitter {
       (max, hook) => Math.max(max, Number(hook?.timeoutMs) || 30000),
       0,
     );
+    const durableWorkspaceBinding =
+      this.workspaceBinding || currentHostHooksV2WorkspaceBinding();
+    const durableWorkspaceBindingRequired = hooksRequireWorkspaceBinding(
+      hooks,
+      this.managedPolicy,
+    );
     const durableRecord =
       this.durableStore && options.skipDurable !== true
         ? this.durableStore.enqueueInbox(
@@ -598,6 +641,12 @@ class HooksV2Runtime extends EventEmitter {
             },
             {
               id: context.event_id || context.eventId || null,
+              metadata: {
+                hooksV2WorkspaceBindingId:
+                  durableWorkspaceBinding?.bindingId || null,
+                hooksV2WorkspaceBindingRequired:
+                  durableWorkspaceBindingRequired,
+              },
               claimOwner: this.durableOwner,
               leaseMs: longestHookTimeout + this.durableRecoveryBufferMs,
             },
@@ -644,6 +693,7 @@ class HooksV2Runtime extends EventEmitter {
           context,
           this.managedPolicy,
           this.configDir,
+          this.workspaceRoot || currentHostHooksV2WorkspaceRoot(),
         );
         let result;
         switch (hook.type) {
@@ -750,9 +800,11 @@ class HooksV2Runtime extends EventEmitter {
     const budget = hookBudget(hook);
     const sandboxPolicy = resolveHookSandboxPolicy(hook, this.managedPolicy);
     const requiresContract = requiresExplicitHookShell(sandboxPolicy);
+    const trustedRootSource =
+      this.workspaceRoot || currentHostHooksV2WorkspaceRoot();
     const trustedRoot = requiresContract
       ? requireTrustedHookRoot(
-          this.workspaceRoot,
+          trustedRootSource,
           "Hooks v2 trusted workspace root",
         )
       : null;
@@ -1023,12 +1075,48 @@ const hooksRuntime = new HooksV2Runtime(undefined, {
       ? new EventRuntimeStore()
       : null),
 });
-defaultEventRuntimeHost?.registerHandler(
-  (event) =>
-    hooksRuntime.executeHooks(event.event, event.context || {}, {
+broker._setHooksEventSink(hooksRuntime);
+
+export async function executeRecoveredHooksV2Event(
+  runtime,
+  event,
+  record = {},
+) {
+  const bindingId = record?.metadata?.hooksV2WorkspaceBindingId || null;
+  const bindingRequired =
+    record?.metadata?.hooksV2WorkspaceBindingRequired === true ||
+    hooksRequireWorkspaceBinding(
+      runtime?.hooks?.get?.(event?.event) || [],
+      runtime?.managedPolicy || {},
+    );
+  if (!bindingId) {
+    if (bindingRequired) {
+      throw sandboxBoundaryError(
+        "durable Hooks v2 recovery requires a trusted host workspace binding",
+      );
+    }
+    return runtime.executeHooks(event.event, event.context || {}, {
+      skipDurable: true,
+      recovered: true,
+    });
+  }
+
+  const binding = resolveRegisteredHostHooksV2Workspace(bindingId);
+  if (!binding) {
+    throw sandboxBoundaryError(
+      "durable Hooks v2 workspace binding is not registered by this host",
+    );
+  }
+  return runWithHostHooksV2Workspace(binding.workspaceRoot, () =>
+    runtime.executeHooks(event.event, event.context || {}, {
       skipDurable: true,
       recovered: true,
     }),
+  );
+}
+
+defaultEventRuntimeHost?.registerHandler(
+  (event, record) => executeRecoveredHooksV2Event(hooksRuntime, event, record),
   { queue: "inbox", type: "hooks.v2" },
 );
 export default hooksRuntime;

package/src/lib/hooks-v2-workspace-context.js

@@ -0,0 +1,258 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const trustedWorkspaceStorage = new AsyncLocalStorage();
+const registeredHostWorkspaces = new Map();
+const registeredHostWorkspaceIdentities = new Map();
+const MAX_REGISTERED_HOST_WORKSPACES = 1024;
+
+function validateHostWorkspaceRoot(workspaceRoot) {
+  if (
+    typeof workspaceRoot !== "string" ||
+    workspaceRoot.length === 0 ||
+    workspaceRoot.includes("\0")
+  ) {
+    const error = new TypeError(
+      "Hooks v2 host workspace root must be a non-empty path",
+    );
+    error.code = "CC_HOOK_TRUSTED_WORKSPACE_INVALID";
+    throw error;
+  }
+  return path.resolve(workspaceRoot);
+}
+
+function invalidWorkspaceRoot(message, cause) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.code = "CC_HOOK_TRUSTED_WORKSPACE_INVALID";
+  return error;
+}
+
+function workspaceGeneration(stats) {
+  // dev+ino alone is insufficient: filesystems may immediately reuse an inode
+  // after a same-path directory replacement. Prefer the stable creation
+  // timestamp and fail closed on metadata changes when a filesystem does not
+  // expose one.
+  return stats.birthtimeNs > 0n
+    ? `birth:${stats.birthtimeNs.toString()}`
+    : `ctime:${stats.ctimeNs.toString()}`;
+}
+
+function captureWorkspaceIdentity(workspaceRoot) {
+  const resolvedRoot = validateHostWorkspaceRoot(workspaceRoot);
+  let canonicalRoot;
+  let stats;
+  try {
+    canonicalRoot = fs.realpathSync.native(resolvedRoot);
+    stats = fs.statSync(canonicalRoot, { bigint: true });
+  } catch (error) {
+    throw invalidWorkspaceRoot(
+      "Hooks v2 host workspace root must resolve to an existing directory",
+      error,
+    );
+  }
+  if (!stats.isDirectory()) {
+    throw invalidWorkspaceRoot(
+      "Hooks v2 host workspace root must resolve to a directory",
+    );
+  }
+  return Object.freeze({
+    canonicalRoot,
+    device: stats.dev,
+    inode: stats.ino,
+    generation: workspaceGeneration(stats),
+  });
+}
+
+function workspaceIdentityKey(identity) {
+  return JSON.stringify([
+    identity.canonicalRoot,
+    identity.device.toString(),
+    identity.inode.toString(),
+    identity.generation,
+  ]);
+}
+
+function sameWorkspaceIdentity(left, right) {
+  return (
+    left.canonicalRoot === right.canonicalRoot &&
+    left.device === right.device &&
+    left.inode === right.inode &&
+    left.generation === right.generation
+  );
+}
+
+function invalidateWorkspaceRecord(record) {
+  if (registeredHostWorkspaces.get(record.binding.bindingId) === record) {
+    registeredHostWorkspaces.delete(record.binding.bindingId);
+  }
+  if (
+    registeredHostWorkspaceIdentities.get(record.identityKey) ===
+    record.binding.bindingId
+  ) {
+    registeredHostWorkspaceIdentities.delete(record.identityKey);
+  }
+}
+
+function verifyWorkspaceRecord(record) {
+  if (!record) return null;
+  if (registeredHostWorkspaces.get(record.binding.bindingId) !== record) {
+    return null;
+  }
+  let currentIdentity;
+  try {
+    currentIdentity = captureWorkspaceIdentity(record.binding.workspaceRoot);
+  } catch {
+    invalidateWorkspaceRecord(record);
+    return null;
+  }
+  if (!sameWorkspaceIdentity(record.identity, currentIdentity)) {
+    invalidateWorkspaceRecord(record);
+    return null;
+  }
+  return record.binding;
+}
+
+function pruneInvalidWorkspaceRecords() {
+  for (const record of Array.from(registeredHostWorkspaces.values())) {
+    verifyWorkspaceRecord(record);
+  }
+}
+
+function workspaceBindingId(identity) {
+  return createHash("sha256")
+    .update("chainlesschain.hooks-v2-host-workspace.v3\0")
+    .update(workspaceIdentityKey(identity), "utf8")
+    .digest("hex");
+}
+
+/**
+ * Register a root selected by trusted host bootstrap code. Durable records
+ * persist only the returned opaque stable digest; the plaintext canonical path
+ * and directory identity remain process-local.
+ */
+export function registerHostHooksV2Workspace(workspaceRoot) {
+  const identity = captureWorkspaceIdentity(workspaceRoot);
+  const identityKey = workspaceIdentityKey(identity);
+  const existingBindingId = registeredHostWorkspaceIdentities.get(identityKey);
+  if (existingBindingId) {
+    const existingRecord = registeredHostWorkspaces.get(existingBindingId);
+    const existingBinding = verifyWorkspaceRecord(existingRecord);
+    if (
+      existingBinding &&
+      sameWorkspaceIdentity(existingRecord.identity, identity)
+    ) {
+      return existingBinding;
+    }
+  }
+
+  // A long-running host may create and remove many isolated worktrees. Sweep
+  // stale filesystem identities before enforcing the bounded registry so
+  // deleted roots cannot exhaust future trusted registrations.
+  if (registeredHostWorkspaces.size >= MAX_REGISTERED_HOST_WORKSPACES) {
+    pruneInvalidWorkspaceRecords();
+  }
+  if (registeredHostWorkspaces.size >= MAX_REGISTERED_HOST_WORKSPACES) {
+    const error = new Error(
+      "Hooks v2 host workspace registry capacity exceeded",
+    );
+    error.code = "CC_HOOK_TRUSTED_WORKSPACE_LIMIT";
+    throw error;
+  }
+
+  const bindingId = workspaceBindingId(identity);
+  const collidingRecord = registeredHostWorkspaces.get(bindingId);
+  if (collidingRecord) {
+    const collidingBinding = verifyWorkspaceRecord(collidingRecord);
+    if (
+      collidingBinding &&
+      sameWorkspaceIdentity(collidingRecord.identity, identity)
+    ) {
+      registeredHostWorkspaceIdentities.set(identityKey, bindingId);
+      return collidingBinding;
+    }
+    if (
+      collidingBinding &&
+      collidingRecord.identity.canonicalRoot !== identity.canonicalRoot
+    ) {
+      const error = new Error("Hooks v2 workspace binding digest collision");
+      error.code = "CC_HOOK_TRUSTED_WORKSPACE_COLLISION";
+      throw error;
+    }
+    if (collidingBinding) {
+      throw invalidWorkspaceRoot(
+        "Hooks v2 host workspace identity changed during registration",
+      );
+    }
+  }
+
+  const binding = Object.freeze({
+    bindingId,
+    workspaceRoot: identity.canonicalRoot,
+  });
+  const record = Object.freeze({
+    binding,
+    identity,
+    identityKey,
+  });
+  registeredHostWorkspaces.set(bindingId, record);
+  registeredHostWorkspaceIdentities.set(identityKey, bindingId);
+  return binding;
+}
+
+/**
+ * Run a CLI-host operation with an immutable Hooks v2 workspace authority.
+ *
+ * Only host bootstrap code may call this with a root selected before hook,
+ * plugin, model, or event payload processing. The binding is async-scoped
+ * instead of global so concurrent CLI runs cannot replace one another's
+ * writable root.
+ */
+export function runWithHostHooksV2Workspace(workspaceRoot, callback) {
+  if (typeof callback !== "function") {
+    throw new TypeError("Hooks v2 workspace callback must be a function");
+  }
+  const binding = registerHostHooksV2Workspace(workspaceRoot);
+  return trustedWorkspaceStorage.run(
+    registeredHostWorkspaces.get(binding.bindingId),
+    callback,
+  );
+}
+
+/**
+ * Internal consumer seam for HooksV2Runtime. Event and hook payloads never
+ * participate in selecting this value.
+ */
+export function currentHostHooksV2WorkspaceRoot() {
+  return currentHostHooksV2WorkspaceBinding()?.workspaceRoot || null;
+}
+
+export function currentHostHooksV2WorkspaceBinding() {
+  return verifyWorkspaceRecord(trustedWorkspaceStorage.getStore());
+}
+
+/**
+ * Resolve an opaque durable binding only against roots registered by the
+ * current host process. No persisted or event-supplied path is accepted.
+ */
+export function resolveRegisteredHostHooksV2Workspace(bindingId) {
+  if (typeof bindingId !== "string" || !/^[a-f0-9]{64}$/.test(bindingId)) {
+    return null;
+  }
+  return verifyWorkspaceRecord(registeredHostWorkspaces.get(bindingId));
+}
+
+/**
+ * Revoke a process-local binding owned by trusted host lifecycle code.
+ * Payloads, hooks, and durable records must never call this release seam.
+ */
+export function releaseRegisteredHostHooksV2Workspace(bindingId) {
+  if (typeof bindingId !== "string" || !/^[a-f0-9]{64}$/.test(bindingId)) {
+    return false;
+  }
+  const record = registeredHostWorkspaces.get(bindingId);
+  if (!record) return false;
+  invalidateWorkspaceRecord(record);
+  return true;
+}

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -102,10 +102,7 @@ describe("LSPClient handshake", () => {
     const child = new FakeChild();
     const contract = Object.freeze({ kind: "test-workspace-contract" });
     const issueAuthority = vi
-      .spyOn(
-        executionBroker,
-        "issueLinuxWorkspaceSandboxExecutionContract",
-      )
+      .spyOn(executionBroker, "issueLinuxWorkspaceSandboxExecutionContract")
       .mockReturnValue(contract);
     const brokerSpawn = vi
       .spyOn(executionBroker, "spawn")

package/src/lib/observability/index.js

@@ -1,6 +1,10 @@
 /**
- * Observability - 可观测性模块统一导出
- * M3 阶段模块：包含分布式追踪 + 性能指标收集
+ * Process-level observability runtime.
+ *
+ * It bridges the existing W3C TraceContext / MetricsCollector and the
+ * TelemetryRecorder used by agent, eval and team runs into one standard OTLP
+ * Collector exporter. Collector export is opt-in and content remains absent
+ * unless the caller explicitly enabled the existing `--otlp-content` switch.
  */
 
 import {
@@ -11,25 +15,193 @@ import {
   metricsCollector,
   MetricsCollector,
 } from "../execution-trace/metrics-collector.js";
+import { OtlpExporter, resolveOtlpConfig } from "./otlp-exporter.js";
 
-export { traceContext, TraceContext, metricsCollector, MetricsCollector };
+export {
+  traceContext,
+  TraceContext,
+  metricsCollector,
+  MetricsCollector,
+  OtlpExporter,
+  resolveOtlpConfig,
+};
 
-/**
- * 初始化可观测性模块
- * @param {Object} [options={}]
- * @param {boolean} [options.tracingEnabled=true] - 是否启用追踪
- * @param {boolean} [options.metricsEnabled=true] - 是否启用指标收集
- */
-export function initObservability(options = {}) {
-  const { tracingEnabled = true, metricsEnabled = true } = options;
-
-  // 可观测性模块初始化逻辑
-  return {
-    tracingEnabled,
-    metricsEnabled,
-    traceContext,
-    metricsCollector,
-  };
+function collectedMetrics(collector) {
+  const raw = collector?.collect?.();
+  const source = raw?.resourceMetrics?.[0]?.scopeMetrics?.[0]?.metrics || [];
+  return source.map((metric) => {
+    if (metric.type === "counter") {
+      return {
+        name: metric.name,
+        type: "sum",
+        value: metric.value,
+        attributes: metric.labels,
+      };
+    }
+    if (metric.type === "histogram") {
+      return {
+        name: metric.name,
+        type: "histogram",
+        count: metric.count,
+        sum: metric.sum,
+        attributes: metric.labels,
+      };
+    }
+    return {
+      name: metric.name,
+      type: "gauge",
+      value: metric.value,
+      attributes: metric.labels,
+    };
+  });
+}
+
+export class ObservabilityRuntime {
+  constructor(options = {}, deps = {}) {
+    this.traceContext = deps.traceContext || traceContext;
+    this.metricsCollector = deps.metricsCollector || metricsCollector;
+    this.exporter =
+      deps.exporter ||
+      new OtlpExporter(
+        {
+          ...options,
+          config:
+            options.config ||
+            resolveOtlpConfig(options, deps.env || process.env, deps),
+        },
+        deps,
+      );
+    this._closed = false;
+    this._onSpanEnd = (span) => this.exporter.exportSpans([span]);
+    if (this.exporter.enabled) {
+      this.traceContext.on("span:end", this._onSpanEnd);
+    }
+  }
+
+  get enabled() {
+    return this.exporter.enabled && !this._closed;
+  }
+
+  exportRecorder(recorder, { redact = true } = {}) {
+    if (!this.enabled || !recorder?.toOtlp) return false;
+    return this.exporter.exportTracePayload(recorder.toOtlp({ redact }), {
+      redact,
+    });
+  }
+
+  exportTeamSummary({ workflowRunId, workflowName, summary, budget } = {}) {
+    if (!this.enabled) return false;
+    const attributes = {
+      "workflow.run_id": workflowRunId || "unknown",
+      "workflow.name": workflowName || "team",
+    };
+    const stats = summary?.stats || {};
+    const budgetStatus = budget?.status?.() || budget || {};
+    return this.exporter.exportMetrics([
+      {
+        name: "chainlesschain.team.tasks",
+        type: "gauge",
+        unit: "{task}",
+        value: Number(budgetStatus.tasks ?? summary?.executions) || 0,
+        attributes,
+      },
+      {
+        name: "chainlesschain.team.tokens",
+        type: "gauge",
+        unit: "{token}",
+        value: Number(budgetStatus.tokens) || 0,
+        attributes,
+      },
+      {
+        name: "chainlesschain.team.cost",
+        type: "gauge",
+        unit: "USD",
+        value: Number(budgetStatus.spentUsd) || 0,
+        attributes,
+      },
+      {
+        name: "chainlesschain.team.failures",
+        type: "gauge",
+        unit: "{failure}",
+        value: Number(stats.failed) || 0,
+        attributes,
+      },
+      {
+        name: "chainlesschain.team.completed",
+        type: "gauge",
+        unit: "{task}",
+        value: Number(stats.completed) || 0,
+        attributes,
+      },
+    ]);
+  }
+
+  captureMetrics() {
+    if (!this.enabled) return false;
+    const metrics = collectedMetrics(this.metricsCollector);
+    return metrics.length > 0 ? this.exporter.exportMetrics(metrics) : false;
+  }
+
+  async shutdown(options = {}) {
+    if (this._closed) return this.exporter.getStats();
+    this.traceContext.off("span:end", this._onSpanEnd);
+    this.captureMetrics();
+    const stats = await this.exporter.shutdown(options);
+    this._closed = true;
+    return stats;
+  }
+
+  getStats() {
+    return this.exporter.getStats();
+  }
+}
+
+let defaultRuntime = null;
+
+export function resolveOtlpEndpointFromArgv(argv = process.argv) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (token === "--otlp-endpoint") return args[index + 1] || null;
+    if (token.startsWith("--otlp-endpoint=")) {
+      return token.slice("--otlp-endpoint=".length) || null;
+    }
+  }
+  return null;
+}
+
+export function initObservability(options = {}, deps = {}) {
+  if (defaultRuntime && !defaultRuntime._closed) return defaultRuntime;
+  defaultRuntime = new ObservabilityRuntime(options, deps);
+  return defaultRuntime;
+}
+
+export function getObservabilityRuntime() {
+  return defaultRuntime;
+}
+
+export function isOtlpCollectorEnabled() {
+  return defaultRuntime?.enabled === true;
+}
+
+export function exportTelemetryRecorder(recorder, options) {
+  return defaultRuntime?.exportRecorder(recorder, options) || false;
+}
+
+export function exportTeamTelemetry(summary) {
+  return defaultRuntime?.exportTeamSummary(summary) || false;
+}
+
+export async function shutdownObservability(options) {
+  return defaultRuntime?.shutdown(options);
+}
+
+/** Test-only lifecycle seam; avoids state leaking across module-level tests. */
+export async function resetObservabilityForTests() {
+  if (defaultRuntime && !defaultRuntime._closed) {
+    await defaultRuntime.shutdown({ timeoutMs: 0 });
+  }
+  defaultRuntime = null;
 }
 
 export * from "../execution-trace/index.js";