@abelxiaoxing/cadence 2.0.9 → 2.0.11

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))
@@ -4019,16 +4028,24 @@ function decodeModelCandidate(value) {
 }
 function decodeModelCatalog(value) {
   canonicalJson({ kind: "ok", value }, LIMITS.pageBytes);
-  const o = closed(value, ["version", "selected", "status", "entries"]);
+  const o = closed(value, [
+    "version",
+    "selected",
+    "status",
+    "entries",
+    "withheld"
+  ]);
   const entries = list(o.entries, LIMITS.maxPageEntries, decodeModelCandidate);
   const status = oneOf(o.status, ["complete", "capacity"]);
-  if (status === "capacity" && entries.length || new Set(entries.map((e) => canonicalJson([e.provider, e.model]))).size !== entries.length)
+  const withheld = integer(o.withheld, 0, LIMITS.maxPageEntries);
+  if (status === "capacity" && (entries.length || withheld) || entries.length + withheld > LIMITS.maxPageEntries || new Set(entries.map((e) => canonicalJson([e.provider, e.model]))).size !== entries.length)
     invalid();
   return {
     version: decodeChoiceVersion(o.version),
     selected: nullable(o.selected, decodeModelSelection),
     status,
-    entries
+    entries,
+    withheld
   };
 }
 // src/history/admission.ts
@@ -5225,6 +5242,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;
@@ -5338,8 +5371,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)
@@ -5347,14 +5382,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",
@@ -14800,7 +14840,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
@@ -17959,19 +18005,22 @@ class OwnerModelContext {
           throw new ContractError("unsupported-context");
         count2 += runtime.getModels(provider).length;
         if (count2 > LIMITS.maxPageEntries)
-          return { status: "capacity", entries: [] };
+          return { status: "capacity", entries: [], withheld: 0 };
       }
       const literals = this.catalogLiterals(current2);
       const entries = [];
+      let withheld = 0;
       for (const provider of providers) {
         const models = runtime.getModels(provider);
-        if (entries.length + models.length > LIMITS.maxPageEntries)
+        if (entries.length + withheld + models.length > LIMITS.maxPageEntries)
           throw new ContractError("capacity");
         for (const model of models) {
           if (model.provider !== provider)
             throw new ContractError("unsupported-context");
-          this.publicIdentifier(provider, literals);
-          this.publicIdentifier(model.id, literals);
+          if (!this.isPublicIdentifier(provider, literals) || !this.isPublicIdentifier(model.id, literals)) {
+            withheld++;
+            continue;
+          }
           const api = modelApis.find((api2) => api2 === model.api) ?? null;
           const levels = this.#thinking(model);
           if (levels.length > 7)
@@ -18018,7 +18067,7 @@ class OwnerModelContext {
       const after = this.catalogSource();
       if (after.auth.identity !== current2.auth.identity || after.auth.stamp !== current2.auth.stamp)
         throw new ContractError("stale");
-      return { status: "complete", entries };
+      return { status: "complete", entries, withheld };
     } catch (error) {
       throw new ContractError(error instanceof ContractError ? error.code : "corrupt-selected");
     }
@@ -18089,8 +18138,11 @@ class OwnerModelContext {
         add(value);
     return [...literals];
   }
+  isPublicIdentifier(value, literals) {
+    return !/[\p{Cc}\p{Cf}\p{Cs}]/u.test(value) && diagnosticText(value, 512, literals) === value && sanitizeText(value, literals) === value;
+  }
   publicIdentifier(value, literals) {
-    if (/[\p{Cc}\p{Cf}\p{Cs}]/u.test(value) || diagnosticText(value, 512, literals) !== value || sanitizeText(value, literals) !== value)
+    if (!this.isPublicIdentifier(value, literals))
       throw new ContractError("unsupported-context");
   }
   replaceSelection(input, beforeInstall) {
@@ -18917,7 +18969,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()),
@@ -18965,7 +19017,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,
@@ -22871,7 +22923,7 @@ function refuseAt(stage, step) {
   }
 }
 async function createServiceHost(value, sourceBuild) {
-  const embedded = "ff017feffc6b6b4521e470d82514d0ca008e15472fa1442ec498b243b0f7cf87";
+  const embedded = "c2bb81519387005a71e88a64364dff47d5c39dab17812833ca898bc51055e59d";
   if (embedded && sourceBuild)
     throw new ContractError("unsupported-context");
   const contractHash = decodeHash(embedded ?? sourceBuild?.contractHash);

package/src/task-shell.ts

@@ -579,7 +579,7 @@ export function registerTaskShell(pi: ExtensionAPI): void {
               `${e.provider}/${e.model} • ${e.api ?? "unsupported"} • ${e.eligibility}`,
           );
           const selected = await ui.select(
-            `Exact OWNER model (Pi conversation model is independent) • ${catalog.status}\nCurrent ${pretty(catalog.selected)}`,
+            `Exact OWNER model (Pi conversation model is independent) • ${catalog.status}\nCurrent ${pretty(catalog.selected)}${catalog.withheld ? `\n${catalog.withheld} withheld: a provider/model ID contains a credential value (such as an apiKey equal to the provider name) or control characters. Give each credential a value that matches no ID; restart the service after editing models.json.` : ""}`,
             [...labels, "Return"],
           );
           if (!selected || !labels.includes(selected)) return;

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))