@abelxiaoxing/cadence 2.0.10 → 2.0.12

package/src/service-host.mjs

@@ -218,15 +218,19 @@ function readBounded(path, max, packaged = false) {
   }
 }
 function gitEnvironment() {
+  const root = process.getuid?.() === 0;
   return {
-    ...Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_"))),
+    ...Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_") && !(root && name === "SUDO_UID"))),
     GIT_OPTIONAL_LOCKS: "0",
     LC_ALL: "C"
   };
 }
+function gitArguments(args) {
+  return process.platform !== "win32" && process.getuid?.() === 0 ? ["-c", "safe.directory=", "-c", "core.fsmonitor=false", ...args] : args;
+}
 function resolveWorkspace(cwd) {
   const actual = realpathSync(cwd);
-  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+  const result = spawnSync("git", gitArguments(["rev-parse", "--show-toplevel"]), {
     cwd: actual,
     env: gitEnvironment(),
     encoding: "utf8",
@@ -288,12 +292,17 @@ function contains(root, path) {
   const within = relative(root, resolve(path));
   return !within || !within.startsWith(`..${sep}`) && within !== ".." && !isAbsolute(within);
 }
+function privateWorkspace(requested, stateHome = defaultStateHome()) {
+  return contains(join(canonicalAmbientRoot(stateHome), "cadence-assistant-v1"), canonicalAmbientRoot(requested));
+}
 class TaskStore {
   root;
   tasks;
   privateRoot;
   constructor(root, stateHome = defaultStateHome()) {
     this.root = realpathSync(root);
+    if (privateWorkspace(this.root, stateHome))
+      throw new Error("Private state cannot be a workspace");
     this.tasks = join(this.root, ".cadence", "assistant", "tasks");
     this.privateRoot = privateRootFor(this.root, stateHome);
     if (contains(this.root, this.privateRoot))
@@ -3861,7 +3870,8 @@ function savedGraph(v) {
   return { status: "unavailable", error: noEffect2(o.error) };
 }
 function correlate(v) {
-  if (v.request.taskId !== (v.task?.id ?? null) || controlWorkspace(v.context) !== v.workspaceId || controlTask(v.context) !== v.request.taskId)
+  const taskMatches = v.task ? v.task.id === v.request.taskId : v.request.taskId === null || v.context.status === "unavailable";
+  if (!taskMatches || controlWorkspace(v.context) !== v.workspaceId || controlTask(v.context) !== v.request.taskId)
     invalid();
   if (v.context.status === "available") {
     const c = v.context.version;
@@ -5233,6 +5243,22 @@ function emptyScan() {
 }
 
 // src/history/live.ts
+function scopedSnapshot(source, scope) {
+  if (scope.kind === "task" || source.scope.kind === "child")
+    return;
+  if (!source.runs.some((run) => scope.kind === "run" ? run.runId === scope.id && run.childRunId === null : run.childRunId === scope.id))
+    return;
+  return decodeSnapshot({
+    ...source,
+    scope,
+    runs: source.runs.filter((run) => scope.kind === "run" ? run.runId === scope.id : run.childRunId === scope.id),
+    horizon: {
+      ...source.horizon,
+      historicalRuns: { ...source.horizon.historicalRuns, scope }
+    }
+  });
+}
+
 class HistoryLive {
   writer;
   projection;
@@ -5346,8 +5372,10 @@ class HistoryLive {
     }
   }
   async drain() {
-    const scopes = [...this.pending.values()];
+    const order = { task: 0, run: 1, child: 2 };
+    const scopes = [...this.pending.values()].sort((a, b) => order[a.kind] - order[b.kind]);
     this.pending.clear();
+    const sources = [];
     try {
       for (const scope of scopes) {
         if (this.closed)
@@ -5355,14 +5383,19 @@ class HistoryLive {
         if (scope.kind !== "run" && ![...this.viewers].some((v) => canonicalJson(v.scope) === canonicalJson(scope)))
           continue;
         let snapshot;
+        for (let i = sources.length - 1;i >= 0 && !snapshot; i--)
+          snapshot = scopedSnapshot(sources[i], scope);
+        const reused = snapshot !== undefined;
         try {
-          snapshot = await this.projection.snapshot(scope);
+          snapshot ??= await this.projection.snapshot(scope);
         } catch {
           for (const v of this.viewers)
             if (v.scope.id === scope.id)
               this.enqueue(v, this.watermark(v.scope));
           continue;
         }
+        if (!reused && sources.length < LIMITS.viewers && (scope.kind === "task" || scopes.some((s) => s.kind === "child" && snapshot.runs.some((r) => r.childRunId === s.id))))
+          sources.push(snapshot);
         const key = `${scope.kind}/${scope.id}`, old = this.rings.get(key);
         const update = (previousSeq, selected2 = scope, previousKeys) => decodeLiveEvent({
           kind: "update",
@@ -14808,7 +14841,13 @@ function localOrigin(policy, actualPort) {
 }
 
 // src/service/server-config.ts
-import { lstatSync as lstatSync8, realpathSync as realpathSync3, statSync } from "node:fs";
+import {
+  existsSync as existsSync2,
+  lstatSync as lstatSync8,
+  mkdirSync as mkdirSync3,
+  realpathSync as realpathSync3,
+  statSync
+} from "node:fs";
 import { dirname as dirname7, join as join10 } from "node:path";
 
 // skills/_shared/load-config.mjs
@@ -18931,7 +18970,7 @@ function captureChanges(root) {
       limits.push("Git observation time budget exhausted");
       return { stdout: Buffer.alloc(0) };
     }
-    const result = spawnSync2("git", ["-c", "core.quotepath=true", ...args], {
+    const result = spawnSync2("git", gitArguments(["-c", "core.quotepath=true", ...args]), {
       cwd: root,
       encoding: "buffer",
       timeout: Math.max(1, deadline - Date.now()),
@@ -18979,7 +19018,7 @@ function captureChanges(root) {
       limits.push(`Unreadable/changing: ${name}`);
     }
   };
-  const probe = spawnSync2("git", ["rev-parse", "--is-inside-work-tree"], {
+  const probe = spawnSync2("git", gitArguments(["rev-parse", "--is-inside-work-tree"]), {
     cwd: root,
     env: gitEnvironment(),
     timeout: 3000,
@@ -22152,8 +22191,6 @@ class TaskActions {
     const access = this.currentAccess();
     const committedSeq = snapshot ?? h.writer.committedSeq;
     const selected2 = taskId ? h.coordination.store.loadSnapshot(taskId) : null;
-    if (taskId && !selected2)
-      throw new ContractError("stale");
     if (selected2 && realpathSync6(selected2.record.cwd) !== this.cwd)
       throw new ContractError("unsupported-context");
     const secrets = this.viewSecrets();
@@ -22166,7 +22203,7 @@ class TaskActions {
     const plan = selected2 ? sanitizeText(selected2.record.plan, secrets) : null;
     const editable = selected2 ? plan === selected2.record.plan : true;
     let descriptor = null;
-    let unavailable2 = null;
+    let unavailable2 = taskId && !selected2 ? publicError("unavailable") : null;
     let saved = { status: "none" };
     if (selected2) {
       try {
@@ -22290,6 +22327,8 @@ class TaskActions {
     if (request.storeId !== this.options.host.reader.storeId)
       throw new ContractError("stale");
     const { view, changes, observation, secrets } = this.observeCurrent(request.taskId);
+    if (!view.task)
+      throw new ContractError("unavailable");
     const text2 = sanitizeText(changes.text, secrets);
     return decodeCurrentChanges({
       request,
@@ -22360,7 +22399,7 @@ class TaskActions {
   checkObligations(taskId) {
     const { view, assertCurrent } = this.observeCurrent(taskId);
     if (!view.task)
-      throw new ContractError("stale");
+      throw new ContractError("unavailable");
     const checks = this.obligationsFor(taskId, view.task.kind, view.context, view.committedSeq).checks;
     assertCurrent();
     return checks;
@@ -22885,7 +22924,7 @@ function refuseAt(stage, step) {
   }
 }
 async function createServiceHost(value, sourceBuild) {
-  const embedded = "c2bb81519387005a71e88a64364dff47d5c39dab17812833ca898bc51055e59d";
+  const embedded = "e9b1ea4bb8d1c275a0cb0cf70947f9ac58e5de0cc438d551dc96809f3e82dd7c";
   if (embedded && sourceBuild)
     throw new ContractError("unsupported-context");
   const contractHash = decodeHash(embedded ?? sourceBuild?.contractHash);

package/src/task-store.ts

@@ -171,26 +171,44 @@ export function readBounded(
   }
 }
 
-/** Git observations must describe the physical cwd, not inherited alternate index/worktree overrides. */
+/** Git observations describe the physical cwd, not inherited alternate
+ * index/worktree overrides. Root never borrows sudo's original user's trust. */
 export function gitEnvironment(): NodeJS.ProcessEnv {
+  const root = process.getuid?.() === 0;
   return {
     ...Object.fromEntries(
-      Object.entries(process.env).filter(([name]) => !name.startsWith("GIT_")),
+      Object.entries(process.env).filter(
+        ([name]) => !name.startsWith("GIT_") && !(root && name === "SUDO_UID"),
+      ),
     ),
     GIT_OPTIONAL_LOCKS: "0",
     LC_ALL: "C",
   };
 }
+/** Observation is not permission to trust another account's repository.
+ * Even with fsmonitor/textconv/ext-diff disabled, status/diff can invoke clean
+ * or process filters. Root therefore requires Git's own ownership check, with
+ * no safe.directory exceptions (including inherited wildcards). No config is
+ * written and ordinary-user trust behavior stays unchanged. */
+export function gitArguments(args: string[]): string[] {
+  return process.platform !== "win32" && process.getuid?.() === 0
+    ? ["-c", "safe.directory=", "-c", "core.fsmonitor=false", ...args]
+    : args;
+}
 export function resolveWorkspace(cwd: string): { root: string; cwd: string } {
   const actual = realpathSync(cwd);
-  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-    cwd: actual,
-    env: gitEnvironment(),
-    encoding: "utf8",
-    timeout: 3000,
-    maxBuffer: 8192,
-    windowsHide: true,
-  });
+  const result = spawnSync(
+    "git",
+    gitArguments(["rev-parse", "--show-toplevel"]),
+    {
+      cwd: actual,
+      env: gitEnvironment(),
+      encoding: "utf8",
+      timeout: 3000,
+      maxBuffer: 8192,
+      windowsHide: true,
+    },
+  );
   // Remove only Git's record terminator, not valid whitespace in a path.
   const topLevel = result.stdout?.replace(
     process.platform === "win32" ? /\r?\n$/ : /\n$/,
@@ -274,6 +292,18 @@ export function stateHomeInside(
   const canonical = realpathSync(root);
   return contains(canonical, privateRootFor(canonical, stateHome));
 }
+/** Also exclude projects *inside* our reserved private namespace. Root access
+ * does not turn private history/coordination into an ordinary engineering tree.
+ * Resolves missing tails without creating anything (for explicit project mkdir). */
+export function privateWorkspace(
+  requested: string,
+  stateHome = defaultStateHome(),
+): boolean {
+  return contains(
+    join(canonicalAmbientRoot(stateHome), "cadence-assistant-v1"),
+    canonicalAmbientRoot(requested),
+  );
+}
 export const LANDING_WORKSPACE = "cadence";
 /** A directory that contains the private state home (the home directory and
  * its ancestors) can never be a workspace; use ~/cadence instead of refusing.
@@ -283,6 +313,8 @@ export function effectiveWorkspace(
   stateHome?: string,
   home = homedir(),
 ): { workspace: string; redirected: boolean } {
+  if (privateWorkspace(requested, stateHome))
+    throw new Error("Private state cannot be a workspace");
   if (!stateHomeInside(resolveWorkspace(requested).root, stateHome))
     return { workspace: requested, redirected: false };
   return { workspace: join(home, LANDING_WORKSPACE), redirected: true };
@@ -301,6 +333,8 @@ export class TaskStore {
   readonly privateRoot: string;
   constructor(root: string, stateHome = defaultStateHome()) {
     this.root = realpathSync(root);
+    if (privateWorkspace(this.root, stateHome))
+      throw new Error("Private state cannot be a workspace");
     this.tasks = join(this.root, ".cadence", "assistant", "tasks");
     this.privateRoot = privateRootFor(this.root, stateHome);
     if (contains(this.root, this.privateRoot))