@gobing-ai/spur 0.3.94 → 0.3.96

package/plugins/sp/scripts/script-root.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// @bun
+
+// plugins/sp/scripts/script-root.ts
+import { spawnSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+// plugins/sp/lib/env.ts
+function getEnvVars() {
+  return process.env;
+}
+
+// plugins/sp/scripts/script-root.ts
+var SOURCE_REPO_MARKER = join("config", "plugin-scripts.json");
+var PROJECT_SCRIPTS_DIR = join("plugins", "sp", "scripts");
+var SCRIPT_ROOT_TWIN_REL = "script-root.mjs";
+function defaultResolveScript(cwd) {
+  return (rel) => {
+    const run = spawnSync("superskill", ["script", "path", "sp", rel, "--json"], {
+      cwd,
+      encoding: "utf8",
+      env: getEnvVars()
+    });
+    if (run.status !== 0 || !run.stdout)
+      return null;
+    const lastLine = run.stdout.trim().split(`
+`).pop() ?? "";
+    try {
+      const parsed = JSON.parse(lastLine);
+      return typeof parsed.path === "string" && parsed.path.length > 0 ? parsed : null;
+    } catch {
+      return null;
+    }
+  };
+}
+function digestScriptSet(dir, cwd) {
+  const abs = cwd ? join(cwd, dir) : dir;
+  const names = readdirSync(abs).filter((name) => {
+    try {
+      return statSync(join(abs, name)).isFile();
+    } catch {
+      return false;
+    }
+  }).sort();
+  const list = names.map((name) => `${name}:${createHash("sha256").update(readFileSync(join(abs, name))).digest("hex")}`);
+  return `sha256:${createHash("sha256").update(list.join(`
+`)).digest("hex")}`;
+}
+function runScriptRoot(env, options = {}) {
+  const cwd = options.cwd;
+  const runId = env.__runId ?? env.runId ?? "";
+  const relResult = join(".spur", "run", `${runId}-script-root.json`);
+  const abs = (p) => cwd ? join(cwd, p) : p;
+  const warn = options.warn ?? ((message) => void process.stderr.write(`${message}
+`));
+  mkdirSync(abs(join(".spur", "run")), { recursive: true });
+  const write = (row) => {
+    writeFileSync(abs(relResult), `${JSON.stringify(row)}
+`);
+    return { ...row, resultFile: relResult, exitCode: 0 };
+  };
+  if (existsSync(abs(SOURCE_REPO_MARKER))) {
+    try {
+      return write({
+        mode: "source-repo",
+        source: "project",
+        dir: PROJECT_SCRIPTS_DIR,
+        scriptSetDigest: digestScriptSet(PROJECT_SCRIPTS_DIR, cwd)
+      });
+    } catch (error) {
+      return write({ mode: "unresolved", error: `source-repo digest failed: ${String(error)}` });
+    }
+  }
+  if (existsSync(abs(PROJECT_SCRIPTS_DIR))) {
+    warn(`script-root: ignoring vendored ${PROJECT_SCRIPTS_DIR}/ (no ${SOURCE_REPO_MARKER} marker) \u2014 ` + `steps resolve the installed twin via 'superskill script path sp <rel>'`);
+  }
+  const resolve = options.resolveScript ?? defaultResolveScript(cwd);
+  const resolved = resolve(SCRIPT_ROOT_TWIN_REL);
+  if (!resolved?.path) {
+    return write({
+      mode: "unresolved",
+      error: `'superskill script path sp ${SCRIPT_ROOT_TWIN_REL}' resolved nothing`
+    });
+  }
+  const dir = dirname(resolved.path);
+  try {
+    return write({
+      mode: "installed",
+      source: resolved.source ?? "unknown",
+      dir,
+      scriptSetDigest: digestScriptSet(dir)
+    });
+  } catch (error) {
+    return write({ mode: "unresolved", error: `installed digest failed: ${String(error)}` });
+  }
+}
+var SCRIPT_ROOT_USAGE = "usage: script-root --run-id <id> [--spur-bin <path>]";
+function main(argv, env = getEnvVars(), options = {}) {
+  let runId = env.__runId ?? "";
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--run-id") {
+      runId = argv[i + 1] ?? "";
+      i++;
+      continue;
+    }
+    if (argv[i] === "--spur-bin") {
+      i++;
+      continue;
+    }
+    process.stderr.write(`${SCRIPT_ROOT_USAGE}
+`);
+    return 2;
+  }
+  return runScriptRoot({ ...env, __runId: runId }, options).exitCode;
+}
+{
+  process.exit(main(process.argv.slice(2)));
+}
+export {
+  runScriptRoot,
+  main,
+  digestScriptSet,
+  SOURCE_REPO_MARKER,
+  SCRIPT_ROOT_USAGE,
+  SCRIPT_ROOT_TWIN_REL,
+  PROJECT_SCRIPTS_DIR
+};

package/plugins/sp/scripts/script-root.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun
+/**
+ * script-root — run-start script-resolution identity for the sp pipelines (task 0960 R2).
+ *
+ * WHY: the pipeline YAML ships to every consumer, but its script probes resolved
+ * `plugins/sp/scripts/` **project-first**. A consumer that hand-vendored a stale copy then ran
+ * a different revision than the installed twin, mixing revisions across steps that write and
+ * read the same cross-step artifacts (status files, verdicts, proof digests). The probe is
+ * dogfooding-only, so it is now gated on `config/plugin-scripts.json` — a marker that lives
+ * outside `plugins/sp/`, so copying the plugin tree cannot reproduce it.
+ *
+ * This script records *which* tree a run resolved, once, before any step executes:
+ *   `.spur/run/<runId>-script-root.json`  `{ mode, source, dir, scriptSetDigest }`
+ *
+ * - `source-repo` — the marker is present; the project's live `plugins/sp/scripts/` is the
+ *   resolved tree (the dogfood path).
+ * - `installed` — no marker; the tree is `dirname(superskill script path sp script-root.mjs
+ *   --json .path)`, with `source` from the same probe. One stderr warning names a dead
+ *   vendored `plugins/sp/scripts/` dir that is no longer executed.
+ * - `unresolved` — nothing resolved. Written with an `error` and **exit 0**: a missing
+ *   optional script must stay a per-step fail-closed outcome, never a run-wide abort (R3).
+ *
+ * `scriptSetDigest` is one sha256 over the sorted `name:sha256` list of the resolved dir's
+ * regular files (non-recursive) — the installed staging has no version file, so this answers
+ * "which revision produced this run?" without a Superskill change.
+ *
+ * Node/bun builtins and the vendored `../lib/env` gateway only — bundled standalone by
+ * `superskill install`, so no `@gobing-ai/*` value imports (task 0669).
+ */
+
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getEnvVars } from '../lib/env';
+
+export type ScriptRootMode = 'source-repo' | 'installed' | 'unresolved';
+
+export interface ScriptRoot {
+    mode: ScriptRootMode;
+    source?: string;
+    dir?: string;
+    scriptSetDigest?: string;
+    error?: string;
+}
+
+export interface ScriptRootResult extends ScriptRoot {
+    resultFile: string;
+    exitCode: number;
+}
+
+export interface ScriptRootEnv {
+    __runId?: string;
+    [key: string]: string | undefined;
+}
+
+/** Resolved script descriptor from `superskill script path sp <rel> --json`. */
+export interface ResolvedScript {
+    path?: string;
+    source?: string;
+}
+
+export interface ScriptRootOptions {
+    /** Base directory for `.spur/run` and the project marker; defaults to process cwd. */
+    cwd?: string;
+    /** Test seam: run `superskill script path sp script-root.mjs --json`. */
+    resolveScript?: (rel: string) => ResolvedScript | null;
+    /** Test seam: the one-warning sink. */
+    warn?: (message: string) => void;
+}
+
+/** Marker that identifies the Spur source repo (owned by script-contract-check, outside plugins/sp). */
+export const SOURCE_REPO_MARKER = join('config', 'plugin-scripts.json');
+/** The project-first tree the dogfood probes execute. */
+export const PROJECT_SCRIPTS_DIR = join('plugins', 'sp', 'scripts');
+/** The rel the installed twin resolves under (its own staging name). */
+export const SCRIPT_ROOT_TWIN_REL = 'script-root.mjs';
+
+function defaultResolveScript(cwd?: string): (rel: string) => ResolvedScript | null {
+    return (rel: string): ResolvedScript | null => {
+        const run = spawnSync('superskill', ['script', 'path', 'sp', rel, '--json'], {
+            cwd,
+            encoding: 'utf8',
+            env: getEnvVars(),
+        });
+        if (run.status !== 0 || !run.stdout) return null;
+        const lastLine = run.stdout.trim().split('\n').pop() ?? '';
+        try {
+            const parsed = JSON.parse(lastLine) as ResolvedScript;
+            return typeof parsed.path === 'string' && parsed.path.length > 0 ? parsed : null;
+        } catch {
+            return null;
+        }
+    };
+}
+
+/** sha256 over the sorted `name:sha256` list of `dir`'s regular files (non-recursive). */
+export function digestScriptSet(dir: string, cwd?: string): string {
+    const abs = cwd ? join(cwd, dir) : dir;
+    const names = readdirSync(abs)
+        .filter((name) => {
+            try {
+                return statSync(join(abs, name)).isFile();
+            } catch {
+                return false;
+            }
+        })
+        .sort();
+    const list = names.map(
+        (name) =>
+            `${name}:${createHash('sha256')
+                .update(readFileSync(join(abs, name)))
+                .digest('hex')}`,
+    );
+    return `sha256:${createHash('sha256').update(list.join('\n')).digest('hex')}`;
+}
+
+/**
+ * Resolve the run's script root and write `.spur/run/<runId>-script-root.json`.
+ * Never aborts: every failure is recorded as `mode: "unresolved"` with exit 0 (R3).
+ */
+export function runScriptRoot(env: ScriptRootEnv, options: ScriptRootOptions = {}): ScriptRootResult {
+    const cwd = options.cwd;
+    const runId = env.__runId ?? env.runId ?? '';
+    const relResult = join('.spur', 'run', `${runId}-script-root.json`);
+    const abs = (p: string): string => (cwd ? join(cwd, p) : p);
+    const warn = options.warn ?? ((message: string): void => void process.stderr.write(`${message}\n`));
+    mkdirSync(abs(join('.spur', 'run')), { recursive: true });
+
+    const write = (row: ScriptRoot): ScriptRootResult => {
+        writeFileSync(abs(relResult), `${JSON.stringify(row)}\n`);
+        return { ...row, resultFile: relResult, exitCode: 0 };
+    };
+
+    // Source repo: the project's live tree is the resolved tree (R6).
+    if (existsSync(abs(SOURCE_REPO_MARKER))) {
+        try {
+            return write({
+                mode: 'source-repo',
+                source: 'project',
+                dir: PROJECT_SCRIPTS_DIR,
+                scriptSetDigest: digestScriptSet(PROJECT_SCRIPTS_DIR, cwd),
+            });
+        } catch (error) {
+            return write({ mode: 'unresolved', error: `source-repo digest failed: ${String(error)}` });
+        }
+    }
+
+    // Installed: resolve the twin, and name a dead vendored dir that is no longer executed.
+    if (existsSync(abs(PROJECT_SCRIPTS_DIR))) {
+        warn(
+            `script-root: ignoring vendored ${PROJECT_SCRIPTS_DIR}/ (no ${SOURCE_REPO_MARKER} marker) — ` +
+                `steps resolve the installed twin via 'superskill script path sp <rel>'`,
+        );
+    }
+    const resolve = options.resolveScript ?? defaultResolveScript(cwd);
+    const resolved = resolve(SCRIPT_ROOT_TWIN_REL);
+    if (!resolved?.path) {
+        return write({
+            mode: 'unresolved',
+            error: `'superskill script path sp ${SCRIPT_ROOT_TWIN_REL}' resolved nothing`,
+        });
+    }
+    const dir = dirname(resolved.path);
+    try {
+        return write({
+            mode: 'installed',
+            source: resolved.source ?? 'unknown',
+            dir,
+            scriptSetDigest: digestScriptSet(dir),
+        });
+    } catch (error) {
+        return write({ mode: 'unresolved', error: `installed digest failed: ${String(error)}` });
+    }
+}
+
+export const SCRIPT_ROOT_USAGE = 'usage: script-root --run-id <id> [--spur-bin <path>]';
+
+export function main(argv: string[], env: ScriptRootEnv = getEnvVars(), options: ScriptRootOptions = {}): number {
+    let runId = env.__runId ?? '';
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === '--run-id') {
+            runId = argv[i + 1] ?? '';
+            i++;
+            continue;
+        }
+        if (argv[i] === '--spur-bin') {
+            i++;
+            continue;
+        }
+        process.stderr.write(`${SCRIPT_ROOT_USAGE}\n`);
+        return 2;
+    }
+    return runScriptRoot({ ...env, __runId: runId }, options).exitCode;
+}
+
+if (import.meta.main) {
+    process.exit(main(process.argv.slice(2)));
+}

package/plugins/sp/scripts/workflow-step-profile.mjs

@@ -3,8 +3,10 @@
 
 // plugins/sp/scripts/workflow-step-profile.ts
 import { spawnSync } from "child_process";
-import { existsSync } from "fs";
-import { fileURLToPath } from "url";
+
+// plugins/sp/lib/spur-bin.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 
 // plugins/sp/lib/env.ts
 function getEnvVar(name, fallback) {
@@ -12,7 +14,22 @@ function getEnvVar(name, fallback) {
   return raw === undefined ? fallback : raw;
 }
 
-// plugins/sp/scripts/workflow-step-profile.ts
+// plugins/sp/lib/spur-bin.ts
+function spurCommand(spurBin) {
+  const parts = (spurBin ?? "spur").trim().split(/\s+/).filter((p) => p.length > 0);
+  return { cmd: parts[0] ?? "spur", prefix: parts.slice(1) };
+}
+function defaultSpurBin() {
+  const fromEnv = getEnvVar("SPUR_BIN");
+  if (fromEnv)
+    return fromEnv;
+  const local = fileURLToPath(new URL("../../../apps/cli/src/index.ts", import.meta.url));
+  if (existsSync(local))
+    return `bun ${local}`;
+  return "spur";
+}
+
+// plugins/sp/lib/step-profile.generated.mjs
 var DEFAULT_LAST = 20;
 var DEFAULT_WINDOW_SEC = 300;
 function nearestRankP50(values) {
@@ -156,7 +173,7 @@ function ratio(value) {
 }
 function formatStepProfileHuman(profile) {
   const lines = [
-    `step profile \u2014 ${profile.workflow} (window ${profile.windowSec}s, ${profile.sampledRuns} sampled runs)`
+    `step profile — ${profile.workflow} (window ${profile.windowSec}s, ${profile.sampledRuns} sampled runs)`
   ];
   for (const row of profile.rows) {
     lines.push([
@@ -175,14 +192,8 @@ function formatStepProfileHuman(profile) {
 `)}
 `;
 }
-function defaultSpurBin() {
-  if (getEnvVar("SPUR_BIN"))
-    return getEnvVar("SPUR_BIN");
-  const local = fileURLToPath(new URL("../../../apps/cli/src/index.ts", import.meta.url));
-  if (existsSync(local))
-    return `bun ${local}`;
-  return "spur";
-}
+
+// plugins/sp/scripts/workflow-step-profile.ts
 function positiveInt(raw, fallback) {
   const parsed = Number.parseInt(raw ?? "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -196,6 +207,8 @@ function parseStepProfileCliArgs(argv) {
   let help = false;
   for (let i = 0;i < argv.length; i++) {
     const a = argv[i];
+    if (a === undefined)
+      continue;
     if (a === "--help" || a === "-h")
       help = true;
     else if (a === "--json")
@@ -212,9 +225,8 @@ function parseStepProfileCliArgs(argv) {
   return { workflow, last, windowSec, spurBin, json, help };
 }
 function runSpurJson(spurBin, args) {
-  const binParts = spurBin.split(/\s+/).filter(Boolean);
-  const cmd = binParts[0] ?? "spur";
-  const cmdArgs = [...binParts.slice(1), ...args];
+  const { cmd, prefix } = spurCommand(spurBin);
+  const cmdArgs = [...prefix, ...args];
   const r = spawnSync(cmd, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
   const decode = (b) => typeof b === "string" ? b : Buffer.from(b ?? []).toString("utf8");
   return {
@@ -318,7 +330,6 @@ export {
   main,
   formatStepProfileHuman,
   extractExecutions,
-  defaultSpurBin,
   buildStepProfile,
   buildRows,
   STEP_PROFILE_USAGE,