@abelxiaoxing/cadence 1.2.4 → 1.4.0

package/src/isolation-backend.ts

@@ -15,6 +15,7 @@ export interface IsolationRunInput {
   mounts?: IsolationMount[];
   environment?: Record<string, string>;
   signal?: AbortSignal;
+  outputWitness?: string;
 }
 
 export type IsolationRunResult =
@@ -24,6 +25,11 @@ export type IsolationRunResult =
       exitCode: number;
       stdout: string;
       stderr: string;
+      outputWitnessMatched?: boolean;
+      logs: {
+        stdout: { bytes: number; truncated: boolean };
+        stderr: { bytes: number; truncated: boolean };
+      };
     }
   | {
       ok: false;
@@ -31,14 +37,13 @@ export type IsolationRunResult =
       code:
         | "isolation-backend-unavailable"
         | "isolation-backend-launch-failed"
-        | "isolation-execution-timeout"
-        | "isolation-output-limit-exceeded";
+        | "isolation-execution-timeout";
     }
   | { ok: false; state: "cancelled"; code: "cancelled" };
 
 export const ISOLATION_RUN_LIMITS = Object.freeze({
   timeoutMs: 10 * 60_000,
-  maxOutputBytes: 1024 * 1024,
+  maxOutputBytes: 256 * 1024,
   terminateGraceMs: 1_000,
 });
 
@@ -64,6 +69,59 @@ function validEnvironmentName(name: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(name);
 }
 
+/** Retains independent head/tail copies; discarded chunks never stay referenced. */
+class BoundedLog {
+  bytes = 0;
+  #head = Buffer.alloc(0);
+  #tail = Buffer.alloc(0);
+  readonly limit: number;
+  readonly #witness?: Buffer;
+  #witnessTail = Buffer.alloc(0);
+  witnessMatched = false;
+  constructor(limit: number, witness?: string) {
+    this.limit = limit;
+    if (witness) this.#witness = Buffer.from(witness);
+  }
+  append(chunk: Buffer | string): void {
+    const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.bytes += input.byteLength;
+    if (this.#witness && !this.witnessMatched) {
+      const searchable = Buffer.concat([this.#witnessTail, input]);
+      this.witnessMatched = searchable.includes(this.#witness);
+      this.#witnessTail = this.witnessMatched
+        ? Buffer.alloc(0)
+        : Buffer.from(
+            searchable.subarray(
+              Math.max(0, searchable.length - this.#witness.length + 1),
+            ),
+          );
+    }
+    const headLimit = Math.ceil(this.limit / 2);
+    const take = Math.min(input.length, headLimit - this.#head.length);
+    if (take > 0)
+      this.#head = Buffer.concat([this.#head, input.subarray(0, take)]);
+    const rest = input.subarray(take);
+    const tailLimit = this.limit - headLimit;
+    if (rest.length && tailLimit) {
+      this.#tail =
+        rest.length >= tailLimit
+          ? Buffer.from(rest.subarray(-tailLimit))
+          : Buffer.concat([
+              this.#tail.subarray(
+                Math.max(0, this.#tail.length + rest.length - tailLimit),
+              ),
+              rest,
+            ]);
+    }
+  }
+  text(): string {
+    return Buffer.concat([this.#head, this.#tail]).toString("utf8");
+  }
+  metadata() {
+    return { bytes: this.bytes, truncated: this.bytes > this.limit };
+  }
+}
+
 /** Linux isolation capability. Lack of Bubblewrap is a pause, never a fallback. */
 export class BubblewrapIsolationBackend {
   readonly #bwrapPath: string;
@@ -103,6 +161,13 @@ export class BubblewrapIsolationBackend {
   }
 
   async run(input: IsolationRunInput): Promise<IsolationRunResult> {
+    if (
+      input.outputWitness !== undefined &&
+      (typeof input.outputWitness !== "string" ||
+        input.outputWitness.length < 1 ||
+        input.outputWitness.length > 512)
+    )
+      throw new Error("isolation-output-witness-invalid");
     if (!(await this.available())) {
       return {
         ok: false,
@@ -165,9 +230,8 @@ export class BubblewrapIsolationBackend {
 
     return new Promise((resolve) => {
       let settled = false;
-      const stdout: Buffer[] = [];
-      const stderr: Buffer[] = [];
-      let capturedBytes = 0;
+      const stdout = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
+      const stderr = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
       let child: ReturnType<typeof spawn>;
       let executionTimer: ReturnType<typeof setTimeout> | undefined;
       let killTimer: ReturnType<typeof setTimeout> | undefined;
@@ -207,21 +271,11 @@ export class BubblewrapIsolationBackend {
         });
         return;
       }
-      const capture = (destination: Buffer[], chunk: Buffer | string): void => {
-        if (settled || terminationResult) return;
-        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        const remaining = this.#maxOutputBytes - capturedBytes;
-        if (remaining > 0) destination.push(bytes.subarray(0, remaining));
-        if (bytes.byteLength > remaining) {
-          capturedBytes = this.#maxOutputBytes;
-          terminate({
-            ok: false,
-            state: "paused",
-            code: "isolation-output-limit-exceeded",
-          });
-          return;
-        }
-        capturedBytes += bytes.byteLength;
+      const capture = (
+        destination: BoundedLog,
+        chunk: Buffer | string,
+      ): void => {
+        if (!settled && !terminationResult) destination.append(chunk);
       };
       child.stdout?.on("data", (chunk: Buffer | string) => {
         capture(stdout, chunk);
@@ -244,8 +298,15 @@ export class BubblewrapIsolationBackend {
             ok: true,
             state: "completed",
             exitCode: code ?? 1,
-            stdout: Buffer.concat(stdout).toString("utf8"),
-            stderr: Buffer.concat(stderr).toString("utf8"),
+            stdout: stdout.text(),
+            stderr: stderr.text(),
+            logs: { stdout: stdout.metadata(), stderr: stderr.metadata() },
+            ...(input.outputWitness
+              ? {
+                  outputWitnessMatched:
+                    stdout.witnessMatched || stderr.witnessMatched,
+                }
+              : {}),
           },
         );
       });

package/src/openspec-cli.ts

@@ -0,0 +1,494 @@
+import { execFile } from "node:child_process";
+import { lstatSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+
+const PACKAGE_NAME = "@fission-ai/openspec";
+export const OPENSPEC_LIMITS = Object.freeze({
+  timeoutMs: 30_000,
+  maxBuffer: 4 * 1024 * 1024,
+});
+
+type Command = "resolve" | "status" | "validate";
+type Phase = "resolution" | "spawn" | "execution" | "protocol";
+type Reason =
+  | "installation-not-found"
+  | "installation-invalid"
+  | "runtime-unavailable"
+  | "cwd-unavailable"
+  | "terminated"
+  | "unsafe-installation"
+  | "launch-failed"
+  | "timeout"
+  | "cancelled"
+  | "output-limit"
+  | "exit-nonzero"
+  | "json-invalid"
+  | "schema-invalid"
+  | "change-invalid";
+
+/** Only code-owned, non-secret fields may cross the Design failure boundary. */
+export interface OpenSpecDiagnostic {
+  code: "design-openspec-unavailable";
+  command: Command;
+  phase: Phase;
+  reason: Reason;
+  systemCode?: string;
+  exitCode?: string;
+}
+
+export class OpenSpecCliError extends Error {
+  readonly diagnostic: Readonly<OpenSpecDiagnostic>;
+
+  constructor(
+    command: Command,
+    phase: Phase,
+    reason: Reason,
+    detail: { systemCode?: string; exitCode?: number } = {},
+  ) {
+    super("design-openspec-unavailable");
+    this.name = "OpenSpecCliError";
+    this.diagnostic = Object.freeze({
+      code: "design-openspec-unavailable",
+      command,
+      phase,
+      reason,
+      ...(["ENOENT", "EINVAL", "EACCES", "EPERM", "ENOEXEC", "E2BIG"].includes(
+        detail.systemCode ?? "",
+      )
+        ? { systemCode: detail.systemCode }
+        : {}),
+      ...(Number.isSafeInteger(detail.exitCode) && (detail.exitCode ?? -1) >= 0
+        ? { exitCode: String(detail.exitCode) }
+        : {}),
+    });
+  }
+}
+
+export interface OpenSpecCliOptions {
+  /** Trusted operator configuration, never a Worker-supplied command string. */
+  environment?: NodeJS.ProcessEnv;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  maxBuffer?: number;
+}
+
+export interface OpenSpecInvocation {
+  executable: string;
+  entry: string;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function inside(root: string, target: string): boolean {
+  const relative = path.relative(root, target);
+  return (
+    relative === "" ||
+    (relative !== ".." &&
+      !relative.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relative))
+  );
+}
+
+function envValue(
+  environment: NodeJS.ProcessEnv,
+  name: string,
+): string | undefined {
+  // Match Node's lexicographic, case-insensitive environment selection on Windows.
+  const key = Object.keys(environment)
+    .sort()
+    .find((candidate) =>
+      process.platform === "win32"
+        ? candidate.toUpperCase() === name.toUpperCase()
+        : candidate === name,
+    );
+  return key === undefined ? undefined : environment[key];
+}
+
+function packageEntry(root: string): string {
+  const canonicalRoot = realpathSync(root);
+  const manifestPath = realpathSync(path.join(canonicalRoot, "package.json"));
+  const manifestStat = lstatSync(manifestPath);
+  if (
+    !inside(canonicalRoot, manifestPath) ||
+    !manifestStat.isFile() ||
+    manifestStat.size > 1024 * 1024
+  )
+    throw new Error("manifest-limit");
+  const manifest = record(JSON.parse(readFileSync(manifestPath, "utf8")));
+  const bin =
+    typeof manifest?.bin === "string"
+      ? manifest.bin
+      : record(manifest?.bin)?.openspec;
+  if (
+    manifest?.name !== PACKAGE_NAME ||
+    typeof bin !== "string" ||
+    path.isAbsolute(bin)
+  )
+    throw new Error("manifest-invalid");
+  const entry = realpathSync(path.resolve(canonicalRoot, bin));
+  if (
+    !inside(canonicalRoot, entry) ||
+    !/\.(?:cjs|mjs|js)$/iu.test(entry) ||
+    !lstatSync(entry).isFile()
+  )
+    throw new Error("entry-invalid");
+  return entry;
+}
+
+function canonicalConsumerRoot(consumerRoot: string): string {
+  try {
+    const root = realpathSync(consumerRoot);
+    if (!lstatSync(root).isDirectory()) throw new Error("cwd-invalid");
+    return root;
+  } catch (error) {
+    throw new OpenSpecCliError("resolve", "resolution", "cwd-unavailable", {
+      systemCode: (error as NodeJS.ErrnoException).code,
+    });
+  }
+}
+
+function commandIn(directory: string): string | undefined {
+  const names =
+    process.platform === "win32"
+      ? ["openspec.exe", "openspec.cmd", "openspec"]
+      : ["openspec"];
+  // Windows filesystems are usually case-insensitive; reject ambiguous names.
+  const entries = process.platform === "win32" ? readdirSync(directory) : names;
+  for (const name of names) {
+    const matches = entries.filter((entry) => entry.toLowerCase() === name);
+    if (matches.length > 1) throw new Error("ambiguous-command");
+    if (matches.length === 1) {
+      const candidate = path.join(directory, matches[0]);
+      if (lstatSync(candidate, { throwIfNoEntry: false })) return candidate;
+    }
+  }
+  return undefined;
+}
+
+/** Resolve once per inspection. Never execute or parse a shell shim. */
+export function resolveOpenSpecInvocation(
+  consumerRoot: string,
+  environment: NodeJS.ProcessEnv = process.env,
+): OpenSpecInvocation {
+  const configuredRoot = envValue(environment, "ABEL_OPENSPEC_PACKAGE_ROOT");
+  const configuredNode = envValue(environment, "ABEL_OPENSPEC_NODE");
+  const node =
+    configuredNode ??
+    (process.release.name === "node" && !process.versions.bun
+      ? process.execPath
+      : undefined);
+  let executable: string;
+  try {
+    if (!node || !path.isAbsolute(node) || /\.(?:cmd|bat|ps1)$/iu.test(node)) {
+      throw new Error("runtime-invalid");
+    }
+    executable = realpathSync(node);
+    if (!lstatSync(executable).isFile()) throw new Error("runtime-invalid");
+  } catch {
+    throw new OpenSpecCliError("resolve", "resolution", "runtime-unavailable");
+  }
+  if (configuredRoot !== undefined) {
+    try {
+      if (!path.isAbsolute(configuredRoot)) throw new Error("root-invalid");
+      return { executable, entry: packageEntry(configuredRoot) };
+    } catch {
+      throw new OpenSpecCliError(
+        "resolve",
+        "resolution",
+        "installation-invalid",
+      );
+    }
+  }
+
+  const consumer = canonicalConsumerRoot(consumerRoot);
+  const directories = (envValue(environment, "PATH") ?? "").split(
+    path.delimiter,
+  );
+  for (const directory of directories) {
+    // Do not introduce implicit cwd search or automatically trust repository CLIs.
+    if (!path.isAbsolute(directory)) continue;
+    let command: string | undefined;
+    let canonicalDirectory: string;
+    try {
+      canonicalDirectory = realpathSync(directory);
+      if (inside(consumer, canonicalDirectory)) continue;
+      command = commandIn(canonicalDirectory);
+    } catch {
+      continue;
+    }
+    if (!command) continue;
+    try {
+      const target = realpathSync(command);
+      if (inside(consumer, target)) {
+        throw new OpenSpecCliError(
+          "resolve",
+          "resolution",
+          "unsafe-installation",
+        );
+      }
+      // npm Windows/custom prefix and Unix global layouts. Symlinked npm/Bun
+      // entries are also discovered by walking their real target's ancestors.
+      const layoutRoots = [
+        path.join(canonicalDirectory, "node_modules", PACKAGE_NAME),
+        path.resolve(canonicalDirectory, "../lib/node_modules", PACKAGE_NAME),
+      ];
+      const roots: string[] = [];
+      let ancestor = path.dirname(target);
+      for (let depth = 0; depth < 8; depth++) {
+        roots.push(ancestor);
+        const parent = path.dirname(ancestor);
+        if (parent === ancestor) break;
+        ancestor = parent;
+      }
+      // A real symlink target identifies the selected version more precisely
+      // than an adjacent global installation.
+      const linked = lstatSync(command).isSymbolicLink();
+      const candidates = linked ? roots : layoutRoots;
+      for (const root of candidates) {
+        let entry: string;
+        try {
+          entry = packageEntry(root);
+          if (linked && entry !== target) continue;
+        } catch {
+          continue;
+        }
+        if (inside(consumer, entry)) {
+          throw new OpenSpecCliError(
+            "resolve",
+            "resolution",
+            "unsafe-installation",
+          );
+        }
+        return { executable, entry };
+      }
+    } catch (error) {
+      if (error instanceof OpenSpecCliError) throw error;
+    }
+    // A broken/shadowing installation must not silently select another version.
+    throw new OpenSpecCliError("resolve", "resolution", "installation-invalid");
+  }
+  throw new OpenSpecCliError("resolve", "resolution", "installation-not-found");
+}
+
+interface CommandResult {
+  stdout: string;
+  exitCode: number;
+}
+
+function execute(
+  invocation: OpenSpecInvocation,
+  command: "status" | "validate",
+  args: string[],
+  consumerRoot: string,
+  options: OpenSpecCliOptions,
+): Promise<CommandResult> {
+  return new Promise((resolve, reject) => {
+    let child: ReturnType<typeof execFile> | undefined;
+    const abort = () => child?.kill("SIGKILL");
+    const failLaunch = (error: unknown) => {
+      const code = (error as NodeJS.ErrnoException)?.code;
+      reject(
+        new OpenSpecCliError(command, "spawn", "launch-failed", {
+          systemCode: typeof code === "string" ? code : undefined,
+        }),
+      );
+    };
+    try {
+      child = execFile(
+        invocation.executable,
+        [invocation.entry, ...args],
+        {
+          cwd: consumerRoot,
+          env: {
+            ...(options.environment ?? process.env),
+            OPENSPEC_TELEMETRY: "0",
+          },
+          encoding: "utf8",
+          shell: false,
+          windowsHide: true,
+          timeout: options.timeoutMs ?? OPENSPEC_LIMITS.timeoutMs,
+          maxBuffer: options.maxBuffer ?? OPENSPEC_LIMITS.maxBuffer,
+          // This adapter launches a single Node CLI, not a shell/process tree.
+          killSignal: "SIGKILL",
+        },
+        (error, stdout) => {
+          options.signal?.removeEventListener("abort", abort);
+          if (options.signal?.aborted) {
+            return reject(
+              new OpenSpecCliError(command, "execution", "cancelled"),
+            );
+          }
+          if (!error) return resolve({ stdout, exitCode: 0 });
+          const code = error.code;
+          if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+            return reject(
+              new OpenSpecCliError(command, "execution", "output-limit"),
+            );
+          }
+          if (error.killed) {
+            return reject(
+              new OpenSpecCliError(command, "execution", "timeout"),
+            );
+          }
+          if (error.signal) {
+            return reject(
+              new OpenSpecCliError(command, "execution", "terminated"),
+            );
+          }
+          if (typeof code === "number")
+            return resolve({ stdout, exitCode: code });
+          reject(
+            new OpenSpecCliError(command, "spawn", "launch-failed", {
+              systemCode: typeof code === "string" ? code : undefined,
+            }),
+          );
+        },
+      );
+      child.stdin?.end();
+      options.signal?.addEventListener("abort", abort, { once: true });
+      if (options.signal?.aborted) abort();
+    } catch (error) {
+      options.signal?.removeEventListener("abort", abort);
+      failLaunch(error);
+    }
+  });
+}
+
+function parseJson(result: CommandResult, command: "status" | "validate") {
+  if (
+    result.exitCode !== 0 &&
+    !(command === "validate" && result.exitCode === 1)
+  ) {
+    throw new OpenSpecCliError(command, "execution", "exit-nonzero", result);
+  }
+  try {
+    const parsed = record(JSON.parse(result.stdout));
+    if (!parsed) throw new Error("not-object");
+    return parsed;
+  } catch {
+    throw new OpenSpecCliError(command, "protocol", "json-invalid", result);
+  }
+}
+
+export interface OpenSpecDeliveryInspection {
+  change: string;
+  schema: string;
+  planningComplete: boolean;
+  strictValid: boolean;
+  artifactPaths: string[];
+}
+
+export async function inspectOpenSpecDelivery(
+  consumerRoot: string,
+  change: string,
+  options: OpenSpecCliOptions = {},
+): Promise<OpenSpecDeliveryInspection> {
+  if (!/^[a-z0-9](?:[a-z0-9-]{0,126}[a-z0-9])?$/u.test(change)) {
+    throw new OpenSpecCliError("resolve", "resolution", "change-invalid");
+  }
+  for (const limit of [options.timeoutMs, options.maxBuffer]) {
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 1)) {
+      throw new Error("openspec-limit-invalid");
+    }
+  }
+  if (options.signal?.aborted) {
+    throw new OpenSpecCliError("resolve", "execution", "cancelled");
+  }
+  consumerRoot = canonicalConsumerRoot(consumerRoot);
+  options = {
+    ...options,
+    environment: { ...(options.environment ?? process.env) },
+  };
+  const invocation = resolveOpenSpecInvocation(
+    consumerRoot,
+    options.environment,
+  );
+  // allSettled ensures neither child outlives a failed inspection. Both have
+  // bounded time/output; deterministic status-first diagnostics avoid races.
+  const results = await Promise.allSettled([
+    execute(
+      invocation,
+      "status",
+      ["status", "--change", change, "--json"],
+      consumerRoot,
+      options,
+    ),
+    execute(
+      invocation,
+      "validate",
+      ["validate", change, "--strict", "--json", "--no-interactive"],
+      consumerRoot,
+      options,
+    ),
+  ]);
+  const executions = results.map((result) => {
+    if (result.status === "rejected") throw result.reason;
+    return result.value;
+  });
+  const status = parseJson(executions[0], "status");
+  const validation = parseJson(executions[1], "validate");
+  const changeRoot = path.resolve(consumerRoot, "openspec", "changes", change);
+  const paths = record(status.artifactPaths);
+  const artifactPaths: string[] = [];
+  let invalidPaths = !paths;
+  for (const entry of Object.values(paths ?? {})) {
+    const outputs = record(entry)?.existingOutputPaths;
+    if (!Array.isArray(outputs)) {
+      invalidPaths = true;
+      continue;
+    }
+    for (const candidate of outputs) {
+      if (typeof candidate !== "string" || candidate.includes("\0")) {
+        invalidPaths = true;
+        continue;
+      }
+      // Relative CLI output is relative to its cwd, not the extension process.
+      const resolved = path.resolve(consumerRoot, candidate);
+      const relative = path.relative(changeRoot, resolved);
+      if (!relative || !inside(changeRoot, resolved)) {
+        invalidPaths = true;
+        continue;
+      }
+      artifactPaths.push(relative.split(path.sep).join("/"));
+    }
+  }
+  if (
+    status.changeName !== change ||
+    typeof status.schemaName !== "string" ||
+    !status.schemaName ||
+    ("isPlanningComplete" in status &&
+      typeof status.isPlanningComplete !== "boolean") ||
+    typeof status.isComplete !== "boolean" ||
+    invalidPaths ||
+    artifactPaths.length === 0
+  )
+    throw new OpenSpecCliError("status", "protocol", "schema-invalid");
+  const items = Array.isArray(validation.items) ? validation.items : [];
+  const item = record(items[0]);
+  if (
+    items.length !== 1 ||
+    item?.id !== change ||
+    typeof item.valid !== "boolean" ||
+    (executions[1].exitCode !== 0 && item.valid)
+  ) {
+    throw new OpenSpecCliError(
+      "validate",
+      "protocol",
+      "schema-invalid",
+      executions[1],
+    );
+  }
+  return {
+    change,
+    schema: status.schemaName,
+    // OpenSpec 1.5.0 reports artifact completion only as isComplete.
+    // When a separate planning flag is present, both flags must be true.
+    planningComplete: status.isComplete && status.isPlanningComplete !== false,
+    strictValid: item.valid,
+    artifactPaths: [...new Set(artifactPaths)].sort(),
+  };
+}