@astrasyncai/verification-gateway 3.10.1 → 3.11.1

package/dist/bin/astrasync-guard.js

@@ -4288,8 +4288,9 @@ function extractBacktickSubstitutions(text, collect) {
   return kept.join(" ");
 }
 function basename(token) {
-  const slash = token.lastIndexOf("/");
-  return slash === -1 ? token : token.slice(slash + 1);
+  const slash = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
+  const name = slash === -1 ? token : token.slice(slash + 1);
+  return name.replace(/\.(exe|cmd|bat|ps1)$/i, "");
 }
 function matchSegment(segment, list) {
   const tokens = segment.split(/\s+/).filter((t) => /[a-z0-9]/.test(t));
@@ -4422,7 +4423,9 @@ var LocalEvaluator = class {
     }
     return {
       recommendation: "ALLOW",
-      reason: "All PDLSS checks passed",
+      // "evaluated": dimensions absent from the policy are skipped, not
+      // failed — evaluatedDimensions below records which ones ran.
+      reason: "All evaluated PDLSS checks passed",
       evaluatedDimensions: {
         purpose: true,
         scope: !!this.policy.scope,
@@ -4521,7 +4524,7 @@ var LocalEvaluator = class {
       }
     }
     if ((context.purpose === "file.read" || context.purpose === "file.write" || context.purpose === "file.delete") && context.target) {
-      const targetLower = context.target.toLowerCase();
+      const targetLower = context.target.toLowerCase().replace(/\\/g, "/");
       for (const sensitivePath of SENSITIVE_PATHS) {
         if (targetLower.includes(sensitivePath.toLowerCase())) {
           score = Math.max(score, 50);
@@ -4550,12 +4553,20 @@ var LocalEvaluator = class {
   matchesAnyPattern(value, patterns) {
     return patterns.some((pattern) => this.matchGlob(value, pattern));
   }
-  /**
-   * Simple glob pattern matching.
-   * Supports * (matches any characters including / and spaces) and ? (single char).
-   * Uses the same approach as the backend's matchGlobPattern.
-   */
+  homePrefix() {
+    if (this.cachedHomePrefix !== void 0) return this.cachedHomePrefix;
+    const env = typeof process !== "undefined" ? process.env : void 0;
+    const home = env?.HOME || env?.USERPROFILE;
+    this.cachedHomePrefix = home ? home.replace(/\\/g, "/") : null;
+    return this.cachedHomePrefix;
+  }
   matchGlob(value, pattern) {
+    value = value.replace(/\\/g, "/");
+    pattern = pattern.replace(/\\/g, "/");
+    if (pattern === "~" || pattern.startsWith("~/")) {
+      const home = this.homePrefix();
+      if (home) pattern = home + pattern.slice(1);
+    }
     if (pattern === value) return true;
     const starCount = (pattern.match(/\*/g) ?? []).length;
     if (starCount > 8) {
@@ -4598,7 +4609,7 @@ function getTrustLevel(score) {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.10.1";
+var SDK_VERSION = "3.11.1";
 
 // src/well-known.ts
 var CACHE_TTL_MS = 60 * 60 * 1e3;
@@ -5113,10 +5124,12 @@ function toGatewayConfig(config) {
   };
 }
 function toVerificationRequest(context, astraId) {
+  const dotIndex = context.purpose.indexOf(".");
+  const dotted = dotIndex > 0;
   return {
     credentials: { astraId },
-    purpose: context.purpose,
-    action: context.action,
+    purpose: dotted ? context.purpose.slice(0, dotIndex) : context.purpose,
+    action: dotted ? context.purpose : context.action,
     resourceType: context.resourceType,
     resource: context.target,
     transactionValue: context.transactionValue,
@@ -5359,13 +5372,43 @@ var TraceLogger = class {
    * Log an evaluation event.
    */
   logEvaluation(context, decision) {
+    if (!this.enabled) return;
+    let event;
+    try {
+      event = {
+        id: this.generateId(),
+        timestamp: /* @__PURE__ */ new Date(),
+        type: "evaluation",
+        context: redactDeep(context),
+        decision: redactDeep(decision)
+      };
+    } catch (err) {
+      event = {
+        id: this.generateId(),
+        timestamp: /* @__PURE__ */ new Date(),
+        type: "error",
+        metadata: {
+          error: `trace redaction failed: ${err instanceof Error ? err.message : String(err)}`,
+          recommendation: decision.recommendation,
+          purpose: context.purpose,
+          action: context.action
+        }
+      };
+    }
+    this.write(event);
+  }
+  /**
+   * Log a tool call the guard saw but did not govern. One line per skip
+   * keeps coverage holes (unmapped platform tools) visible in the traces
+   * instead of silently indistinguishable from ALLOW.
+   */
+  logSkipped(toolName, reason) {
     if (!this.enabled) return;
     this.write({
       id: this.generateId(),
       timestamp: /* @__PURE__ */ new Date(),
-      type: "evaluation",
-      context: redactDeep(context),
-      decision: redactDeep(decision)
+      type: "skipped",
+      metadata: { toolName, reason }
     });
   }
   /**
@@ -5394,17 +5437,34 @@ var TraceLogger = class {
     });
   }
   write(event) {
+    let line;
+    try {
+      line = JSON.stringify(event) + "\n";
+    } catch {
+      return;
+    }
     try {
       const filePath = this.getCurrentFilePath();
-      const line = JSON.stringify(event) + "\n";
       if ((0, import_fs3.existsSync)(filePath)) {
         const stats = (0, import_fs3.statSync)(filePath);
         if (stats.size > MAX_FILE_SIZE) {
           this.rotate();
         }
       }
-      (0, import_fs3.appendFileSync)(filePath, line);
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          (0, import_fs3.appendFileSync)(filePath, line);
+          return;
+        } catch {
+        }
+      }
+      const fallbackPath = filePath.replace(/\.jsonl$/, `-r${process.pid}.jsonl`);
+      (0, import_fs3.appendFileSync)(fallbackPath, line);
     } catch {
+      try {
+        console.error(`[AstraSync TraceLogger] failed to persist trace line: ${line.trim()}`);
+      } catch {
+      }
     }
   }
   getCurrentFilePath() {
@@ -5565,6 +5625,13 @@ var AstraSyncGateway = class {
   getSyncStatus() {
     return this.syncQueue?.getStatus() || null;
   }
+  /**
+   * Record a tool call the calling adapter saw but did not govern
+   * (unmapped tool, skipTools, MCP with governMcp off). Trace-only.
+   */
+  logSkippedTool(toolName, reason) {
+    this.traceLogger?.logSkipped(toolName, reason);
+  }
 };
 
 // src/git-trigger/git-hooks.ts
@@ -5693,11 +5760,11 @@ async function evaluateChangedFiles(gateway, files, config = {}) {
 var import_fs5 = require("fs");
 var import_path4 = require("path");
 var ASTRASYNC_HOOK_MARKER = "astrasync-claude-hook";
-var HOOK_MATCHER = "Bash|Write|Edit|MultiEdit|NotebookEdit|Read|Glob|Grep|WebFetch|WebSearch|Task|Agent|mcp__.*";
+var HOOK_MATCHER = "Bash|PowerShell|Write|Edit|MultiEdit|NotebookEdit|Read|Glob|Grep|WebFetch|WebSearch|Task|Agent|mcp__.*";
 var HOOK_TIMEOUT_SECONDS = 10;
-function isGuardEntry(entry) {
+function isGuardEntry(entry, marker2) {
   return (entry.hooks ?? []).some(
-    (h) => typeof h.command === "string" && h.command.includes(ASTRASYNC_HOOK_MARKER)
+    (h) => typeof h.command === "string" && h.command.includes(marker2)
   );
 }
 function readSettings(settingsPath) {
@@ -5711,24 +5778,26 @@ function writeSettings(settingsPath, settings) {
   (0, import_fs5.writeFileSync)(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
 }
-function buildHookEntry(hookCommand) {
+function buildHookEntry(hookCommand, matcher = HOOK_MATCHER, extraHookFields = {}) {
   return {
-    matcher: HOOK_MATCHER,
-    hooks: [{ type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS }]
+    matcher,
+    hooks: [
+      { type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS, ...extraHookFields }
+    ]
   };
 }
-function installClaudeHooks(settingsPath, hookCommand) {
-  if (!hookCommand.includes(ASTRASYNC_HOOK_MARKER)) {
+function installClaudeHooks(settingsPath, hookCommand, marker2 = ASTRASYNC_HOOK_MARKER, matcher = HOOK_MATCHER, extraHookFields = {}) {
+  if (!hookCommand.includes(marker2)) {
     throw new Error(
-      `Hook command must reference ${ASTRASYNC_HOOK_MARKER} (got: ${hookCommand}) \u2014 the marker is how install/uninstall identify the guard entry.`
+      `Hook command must reference ${marker2} (got: ${hookCommand}) \u2014 the marker is how install/uninstall identify the guard entry.`
     );
   }
   const settings = readSettings(settingsPath);
   settings.hooks = settings.hooks ?? {};
   const preToolUse = settings.hooks.PreToolUse = settings.hooks.PreToolUse ?? [];
-  const existing = preToolUse.find(isGuardEntry);
+  const existing = preToolUse.find((entry) => isGuardEntry(entry, marker2));
   if (existing) {
-    const fresh = buildHookEntry(hookCommand);
+    const fresh = buildHookEntry(hookCommand, matcher, extraHookFields);
     const changed = JSON.stringify(existing) !== JSON.stringify(fresh);
     if (changed) {
       preToolUse[preToolUse.indexOf(existing)] = fresh;
@@ -5736,11 +5805,11 @@ function installClaudeHooks(settingsPath, hookCommand) {
     }
     return { installed: false, alreadyPresent: true, updated: changed };
   }
-  preToolUse.push(buildHookEntry(hookCommand));
+  preToolUse.push(buildHookEntry(hookCommand, matcher, extraHookFields));
   writeSettings(settingsPath, settings);
   return { installed: true, alreadyPresent: false, updated: false };
 }
-function uninstallClaudeHooks(settingsPath) {
+function uninstallClaudeHooks(settingsPath, marker2 = ASTRASYNC_HOOK_MARKER) {
   if (!(0, import_fs5.existsSync)(settingsPath)) return false;
   let settings;
   try {
@@ -5750,7 +5819,7 @@ function uninstallClaudeHooks(settingsPath) {
   }
   const preToolUse = settings.hooks?.PreToolUse;
   if (!preToolUse) return false;
-  const remaining = preToolUse.filter((entry) => !isGuardEntry(entry));
+  const remaining = preToolUse.filter((entry) => !isGuardEntry(entry, marker2));
   if (remaining.length === preToolUse.length) return false;
   if (remaining.length > 0) {
     settings.hooks.PreToolUse = remaining;
@@ -5764,7 +5833,9 @@ function uninstallClaudeHooks(settingsPath) {
 var GUARD_SELF_PROTECTION_PATTERNS = [
   "**/.claude/settings.json",
   "**/.claude/settings.local.json",
-  "**/.astrasync/**"
+  "**/.astrasync/**",
+  "**/.codex/hooks.json",
+  "**/.codex/config.toml"
 ];
 function ensureGuardSelfProtection(policyPath) {
   const parsed = parseFile(policyPath);
@@ -5811,6 +5882,25 @@ function buildDefaultClaudeCodePolicy(name = "claude-code-local-guard") {
   };
 }
 
+// src/codex/settings-installer.ts
+var ASTRASYNC_CODEX_HOOK_MARKER = "astrasync-codex-hook";
+var CODEX_HOOK_MATCHER = "Bash|apply_patch|Edit|Write|web_search|mcp__.*";
+var CODEX_STATUS_MESSAGE = "AstraSync Local Guard";
+function installCodexHooks(hooksPath, hookCommand) {
+  return installClaudeHooks(
+    hooksPath,
+    hookCommand,
+    ASTRASYNC_CODEX_HOOK_MARKER,
+    CODEX_HOOK_MATCHER,
+    {
+      statusMessage: CODEX_STATUS_MESSAGE
+    }
+  );
+}
+function uninstallCodexHooks(hooksPath) {
+  return uninstallClaudeHooks(hooksPath, ASTRASYNC_CODEX_HOOK_MARKER);
+}
+
 // src/cli/guard.ts
 var DEFAULT_POLICY_PATH = "./local-policy.yaml";
 var DEFAULT_CONFIG_DIR = ".astrasync";
@@ -5976,6 +6066,7 @@ async function cmdStatus() {
     console.log('  Policy:   not found \u2014 run "astrasync guard setup"');
   }
   printClaudeCodeStatus();
+  printCodexStatus();
   console.log("");
 }
 async function cmdCheck() {
@@ -6154,6 +6245,108 @@ async function cmdUninstallClaudeCode() {
     `[AstraSync] Policy and traces left in place at ${astrasyncDir} \u2014 delete manually if unwanted.`
   );
 }
+function resolveCodexHookCommand() {
+  const sibling = path.join(__dirname, "astrasync-codex-hook.js");
+  if (fs.existsSync(sibling)) {
+    return `"${process.execPath}" "${sibling}"`;
+  }
+  return "astrasync-codex-hook";
+}
+function codexPaths(project) {
+  const root = project ? process.cwd() : os.homedir();
+  return {
+    hooksPath: path.join(root, ".codex", "hooks.json"),
+    astrasyncDir: path.join(root, ".astrasync")
+  };
+}
+async function cmdInstallCodex() {
+  const flags = parseClaudeCodeFlags();
+  const { hooksPath, astrasyncDir } = codexPaths(flags.project);
+  const policyPath = flags.policyOverride || path.join(astrasyncDir, "policy.yaml");
+  const guardJsonPath = path.join(astrasyncDir, "guard.json");
+  console.log("\nAstraSync Local Guard for Codex CLI \u2014 install\n");
+  if (fs.existsSync(policyPath)) {
+    console.log(`  Policy:   using existing ${policyPath} (shared across adapters)`);
+    if (ensureGuardSelfProtection(policyPath)) {
+      console.log("            added guard self-protection patterns to file.write");
+    }
+  } else if (flags.wizard) {
+    const prompt = createPrompt();
+    try {
+      fs.mkdirSync(path.dirname(policyPath), { recursive: true });
+      const wizard = new SetupWizard(prompt);
+      await wizard.runAndSave(policyPath);
+    } finally {
+      prompt.close();
+    }
+    ensureGuardSelfProtection(policyPath);
+    console.log(`  Policy:   created via wizard at ${policyPath}`);
+  } else {
+    fs.mkdirSync(path.dirname(policyPath), { recursive: true });
+    fs.writeFileSync(policyPath, toYaml(buildDefaultClaudeCodePolicy()), "utf-8");
+    console.log(`  Policy:   default coding-agent policy written to ${policyPath}`);
+    console.log("            (re-run with --wizard for the interactive setup instead)");
+  }
+  if (!fs.existsSync(guardJsonPath)) {
+    const guardSettings = {
+      posture: flags.active ? "active" : "passive",
+      governMcp: false
+    };
+    fs.writeFileSync(guardJsonPath, `${JSON.stringify(guardSettings, null, 2)}
+`, "utf-8");
+    console.log(
+      `  Guard:    ${guardJsonPath} (posture: ${guardSettings.posture}, governMcp: false)`
+    );
+  } else {
+    console.log(`  Guard:    using existing ${guardJsonPath}`);
+  }
+  const hookCommand = resolveCodexHookCommand();
+  const result = installCodexHooks(hooksPath, hookCommand);
+  if (result.installed) {
+    console.log(`  Hook:     installed in ${hooksPath}`);
+  } else if (result.updated) {
+    console.log(`  Hook:     updated in ${hooksPath}`);
+  } else {
+    console.log(`  Hook:     already present in ${hooksPath}`);
+  }
+  console.log("\n  Next steps:");
+  console.log("    1. Start a NEW Codex session (hooks load at startup; /hooks to inspect).");
+  console.log(`    2. Watch decisions: tail -f ${path.join(astrasyncDir, "traces")}/*.jsonl`);
+  console.log(`    3. When the traces look right, set "posture": "active" in ${guardJsonPath}.`);
+  console.log("       Denies block; approvals fall through to Codex's own prompt \u2014");
+  console.log("       except in dontAsk/bypassPermissions modes, where they deny.");
+  console.log("    4. Note: Codex fails OPEN if the hook itself times out; the guard");
+  console.log("       fails closed on every failure it can see.\n");
+}
+async function cmdUninstallCodex() {
+  const flags = parseClaudeCodeFlags();
+  const { hooksPath, astrasyncDir } = codexPaths(flags.project);
+  const removed = uninstallCodexHooks(hooksPath);
+  if (removed) {
+    console.log(`[AstraSync] Removed Codex hook from ${hooksPath}`);
+  } else {
+    console.log(`[AstraSync] No AstraSync hook found in ${hooksPath}`);
+  }
+  console.log(
+    `[AstraSync] Policy and traces left in place at ${astrasyncDir} \u2014 delete manually if unwanted.`
+  );
+}
+function printCodexStatus() {
+  for (const scope of ["user", "project"]) {
+    const { hooksPath, astrasyncDir } = codexPaths(scope === "project");
+    let hookInstalled = false;
+    try {
+      const content = fs.readFileSync(hooksPath, "utf-8");
+      hookInstalled = content.includes(ASTRASYNC_CODEX_HOOK_MARKER);
+    } catch {
+    }
+    if (hookInstalled) {
+      const policyPath = path.join(astrasyncDir, "policy.yaml");
+      const policy = fs.existsSync(policyPath) ? `policy: ${policyPath}` : "policy: missing";
+      console.log(`  Codex CLI (${scope}): hook installed, ${policy}`);
+    }
+  }
+}
 function printClaudeCodeStatus() {
   for (const scope of ["user", "project"]) {
     const { settingsPath, astrasyncDir } = claudeCodePaths(scope === "project");
@@ -6211,6 +6404,12 @@ async function main() {
     case "uninstall-claude-code":
       await cmdUninstallClaudeCode();
       break;
+    case "install-codex":
+      await cmdInstallCodex();
+      break;
+    case "uninstall-codex":
+      await cmdUninstallCodex();
+      break;
     default:
       console.log("AstraSync Local Guard\n");
       console.log("Usage: astrasync guard <command>\n");
@@ -6228,6 +6427,9 @@ async function main() {
       console.log(
         "  uninstall-claude-code  Remove the Claude Code hook (--project for project scope)"
       );
+      console.log("  install-codex          Install the Local Guard hook for OpenAI Codex CLI");
+      console.log("                         (same flags; policy shared with Claude Code)");
+      console.log("  uninstall-codex        Remove the Codex hook (--project for project scope)");
       console.log("");
       process.exit(command ? 1 : 0);
   }