@probelabs/visor 0.1.144 → 0.1.145

package/dist/sdk/{chunk-PXWWPPNF.mjs → chunk-GZMQPC6D.mjs}

@@ -33,7 +33,7 @@ import {
 import {
   config_exports,
   init_config
-} from "./chunk-AKCHIYWU.mjs";
+} from "./chunk-YOKAA4IU.mjs";
 import {
   ScheduleStore,
   buildScheduleToolContext,
@@ -2288,7 +2288,7 @@ ${"=".repeat(60)}
        * Generate mock response for testing
        */
       async generateMockResponse(_prompt, _checkName, _schema) {
-        await new Promise((resolve6) => setTimeout(resolve6, 500));
+        await new Promise((resolve8) => setTimeout(resolve8, 500));
         const name = (_checkName || "").toLowerCase();
         if (name.includes("extract-facts")) {
           const arr = Array.from({ length: 6 }, (_, i) => ({
@@ -3947,7 +3947,7 @@ async function executeWorkflowAsTool(workflowId, args, context2, argsOverrides)
     ...args,
     ...argsOverrides
   };
-  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-FLBIJQ4Z.mjs");
+  const { WorkflowCheckProvider: WorkflowCheckProvider2 } = await import("./workflow-check-provider-3IIKJFM4.mjs");
   const provider = new WorkflowCheckProvider2();
   const checkConfig = {
     type: "workflow",
@@ -9974,8 +9974,8 @@ var init_runner = __esm({
         stats.sort((a, b) => (b.errorMessage ? 1 : 0) - (a.errorMessage ? 1 : 0));
         const results = this.aggregateResultsFromJournal();
         let totalDuration = 0;
-        for (const stat of stats) {
-          totalDuration = Math.max(totalDuration, stat.totalDuration);
+        for (const stat2 of stats) {
+          totalDuration = Math.max(totalDuration, stat2.totalDuration);
         }
         try {
           for (const s of stats) {
@@ -10641,9 +10641,271 @@ var init_cache_volume_manager = __esm({
   }
 });
 
-// src/sandbox/sandbox-manager.ts
-import { resolve, dirname, join as join6 } from "path";
+// src/sandbox/bubblewrap-sandbox.ts
+var bubblewrap_sandbox_exports = {};
+__export(bubblewrap_sandbox_exports, {
+  BubblewrapSandbox: () => BubblewrapSandbox
+});
+import { promisify as promisify4 } from "util";
+import { execFile as execFileCb4 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
+import { resolve } from "path";
+var execFileAsync4, EXEC_MAX_BUFFER4, BubblewrapSandbox;
+var init_bubblewrap_sandbox = __esm({
+  "src/sandbox/bubblewrap-sandbox.ts"() {
+    "use strict";
+    init_logger();
+    init_sandbox_telemetry();
+    execFileAsync4 = promisify4(execFileCb4);
+    EXEC_MAX_BUFFER4 = 50 * 1024 * 1024;
+    BubblewrapSandbox = class {
+      name;
+      config;
+      repoPath;
+      constructor(name, config, repoPath) {
+        this.name = name;
+        this.config = config;
+        this.repoPath = resolve(repoPath);
+      }
+      /**
+       * Check if bwrap binary is available on the system.
+       */
+      static async isAvailable() {
+        try {
+          await execFileAsync4("which", ["bwrap"], { timeout: 5e3 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Execute a command inside a bubblewrap sandbox.
+       * Each exec creates a fresh namespace — no persistent container.
+       */
+      async exec(options) {
+        const args = this.buildArgs(options);
+        args.push("--", "/bin/sh", "-c", options.command);
+        logger.debug(
+          `[BubblewrapSandbox] Executing in sandbox '${this.name}': ${options.command.slice(0, 100)}`
+        );
+        try {
+          const { stdout, stderr } = await execFileAsync4("bwrap", args, {
+            maxBuffer: options.maxBuffer || EXEC_MAX_BUFFER4,
+            timeout: options.timeoutMs || 6e5
+          });
+          addEvent2("visor.sandbox.bwrap.exec", {
+            "visor.sandbox.name": this.name,
+            "visor.sandbox.exit_code": 0
+          });
+          return { stdout, stderr, exitCode: 0 };
+        } catch (err) {
+          const execErr = err;
+          const exitCode = typeof execErr.code === "number" ? execErr.code : 1;
+          addEvent2("visor.sandbox.bwrap.exec", {
+            "visor.sandbox.name": this.name,
+            "visor.sandbox.exit_code": exitCode
+          });
+          return {
+            stdout: execErr.stdout || "",
+            stderr: execErr.stderr || "",
+            exitCode
+          };
+        }
+      }
+      /**
+       * No-op: bubblewrap processes are ephemeral (no persistent container to stop).
+       */
+      async stop() {
+      }
+      /**
+       * Build the bwrap command-line arguments.
+       */
+      buildArgs(options) {
+        const workdir = this.config.workdir || "/workspace";
+        const args = [];
+        args.push("--ro-bind", "/usr", "/usr");
+        args.push("--ro-bind", "/bin", "/bin");
+        if (existsSync4("/lib")) {
+          args.push("--ro-bind", "/lib", "/lib");
+        }
+        if (existsSync4("/lib64")) {
+          args.push("--ro-bind", "/lib64", "/lib64");
+        }
+        if (existsSync4("/etc/resolv.conf")) {
+          args.push("--ro-bind", "/etc/resolv.conf", "/etc/resolv.conf");
+        }
+        if (existsSync4("/etc/ssl")) {
+          args.push("--ro-bind", "/etc/ssl", "/etc/ssl");
+        }
+        args.push("--dev", "/dev");
+        args.push("--proc", "/proc");
+        args.push("--tmpfs", "/tmp");
+        args.push("--tmpfs", "/root");
+        if (this.config.read_only) {
+          args.push("--ro-bind", this.repoPath, workdir);
+        } else {
+          args.push("--bind", this.repoPath, workdir);
+        }
+        args.push("--chdir", workdir);
+        args.push("--unshare-pid");
+        args.push("--new-session");
+        args.push("--die-with-parent");
+        if (this.config.network === false) {
+          args.push("--unshare-net");
+        }
+        args.push("--clearenv");
+        for (const [key, value] of Object.entries(options.env)) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+            throw new Error(`Invalid environment variable name: '${key}'`);
+          }
+          args.push("--setenv", key, value);
+        }
+        return args;
+      }
+    };
+  }
+});
+
+// src/sandbox/seatbelt-sandbox.ts
+var seatbelt_sandbox_exports = {};
+__export(seatbelt_sandbox_exports, {
+  SeatbeltSandbox: () => SeatbeltSandbox
+});
+import { promisify as promisify5 } from "util";
+import { execFile as execFileCb5 } from "child_process";
+import { resolve as resolve2 } from "path";
+import { realpathSync } from "fs";
+var execFileAsync5, EXEC_MAX_BUFFER5, SeatbeltSandbox;
+var init_seatbelt_sandbox = __esm({
+  "src/sandbox/seatbelt-sandbox.ts"() {
+    "use strict";
+    init_logger();
+    init_sandbox_telemetry();
+    execFileAsync5 = promisify5(execFileCb5);
+    EXEC_MAX_BUFFER5 = 50 * 1024 * 1024;
+    SeatbeltSandbox = class {
+      name;
+      config;
+      repoPath;
+      constructor(name, config, repoPath) {
+        this.name = name;
+        this.config = config;
+        this.repoPath = realpathSync(resolve2(repoPath));
+      }
+      /**
+       * Check if sandbox-exec binary is available on the system.
+       */
+      static async isAvailable() {
+        try {
+          await execFileAsync5("which", ["sandbox-exec"], { timeout: 5e3 });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Execute a command inside a macOS seatbelt sandbox.
+       * Each exec creates a fresh sandbox process — no persistent container.
+       */
+      async exec(options) {
+        const profile = this.buildProfile();
+        for (const key of Object.keys(options.env)) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+            throw new Error(`Invalid environment variable name: '${key}'`);
+          }
+        }
+        const args = ["-p", profile];
+        args.push("/usr/bin/env", "-i");
+        for (const [key, value] of Object.entries(options.env)) {
+          args.push(`${key}=${value}`);
+        }
+        args.push("/bin/sh", "-c", options.command);
+        logger.debug(
+          `[SeatbeltSandbox] Executing in sandbox '${this.name}': ${options.command.slice(0, 100)}`
+        );
+        try {
+          const { stdout, stderr } = await execFileAsync5("sandbox-exec", args, {
+            maxBuffer: options.maxBuffer || EXEC_MAX_BUFFER5,
+            timeout: options.timeoutMs || 6e5,
+            cwd: this.repoPath
+          });
+          addEvent2("visor.sandbox.seatbelt.exec", {
+            "visor.sandbox.name": this.name,
+            "visor.sandbox.exit_code": 0
+          });
+          return { stdout, stderr, exitCode: 0 };
+        } catch (err) {
+          const execErr = err;
+          const exitCode = typeof execErr.code === "number" ? execErr.code : 1;
+          addEvent2("visor.sandbox.seatbelt.exec", {
+            "visor.sandbox.name": this.name,
+            "visor.sandbox.exit_code": exitCode
+          });
+          return {
+            stdout: execErr.stdout || "",
+            stderr: execErr.stderr || "",
+            exitCode
+          };
+        }
+      }
+      /**
+       * No-op: sandbox-exec processes are ephemeral (no persistent container to stop).
+       */
+      async stop() {
+      }
+      /**
+       * Escape a path for use inside an SBPL profile string.
+       * Escapes backslashes and double quotes.
+       */
+      escapePath(p) {
+        return p.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      }
+      /**
+       * Build the SBPL (Seatbelt Profile Language) profile string.
+       */
+      buildProfile() {
+        const repoPath = this.escapePath(this.repoPath);
+        const lines = [];
+        lines.push("(version 1)");
+        lines.push("(deny default)");
+        lines.push("(allow process-exec)");
+        lines.push("(allow process-fork)");
+        lines.push("(allow file-read*");
+        lines.push('  (literal "/")');
+        lines.push('  (subpath "/usr")');
+        lines.push('  (subpath "/bin")');
+        lines.push('  (subpath "/sbin")');
+        lines.push('  (subpath "/Library")');
+        lines.push('  (subpath "/System")');
+        lines.push('  (subpath "/private")');
+        lines.push('  (subpath "/var")');
+        lines.push('  (subpath "/etc")');
+        lines.push('  (subpath "/dev")');
+        lines.push('  (subpath "/tmp"))');
+        lines.push("(allow file-write*");
+        lines.push('  (subpath "/tmp")');
+        lines.push('  (subpath "/private/tmp")');
+        lines.push('  (subpath "/dev"))');
+        lines.push('(allow file-write* (regex #"/private/var/folders/.*/T/xcrun_db"))');
+        lines.push(`(allow file-read* (subpath "${repoPath}"))`);
+        if (!this.config.read_only) {
+          lines.push(`(allow file-write* (subpath "${repoPath}"))`);
+        }
+        if (this.config.network !== false) {
+          lines.push("(allow network*)");
+        }
+        lines.push("(allow sysctl-read)");
+        lines.push("(allow mach-lookup)");
+        lines.push("(allow signal)");
+        return lines.join("\n");
+      }
+    };
+  }
+});
+
+// src/sandbox/sandbox-manager.ts
+import { resolve as resolve3, dirname, join as join6 } from "path";
+import { existsSync as existsSync5 } from "fs";
 var SandboxManager;
 var init_sandbox_manager = __esm({
   "src/sandbox/sandbox-manager.ts"() {
@@ -10666,10 +10928,10 @@ var init_sandbox_manager = __esm({
       }
       constructor(sandboxDefs, repoPath, gitBranch) {
         this.sandboxDefs = sandboxDefs;
-        this.repoPath = resolve(repoPath);
+        this.repoPath = resolve3(repoPath);
         this.gitBranch = gitBranch;
         this.cacheManager = new CacheVolumeManager();
-        this.visorDistPath = existsSync4(join6(__dirname, "index.js")) ? __dirname : resolve(dirname(__dirname));
+        this.visorDistPath = existsSync5(join6(__dirname, "index.js")) ? __dirname : resolve3(dirname(__dirname));
       }
       /**
        * Resolve which sandbox a check should use.
@@ -10699,6 +10961,18 @@ var init_sandbox_manager = __esm({
           throw new Error(`Sandbox '${name}' is not defined`);
         }
         const mode = config.compose ? "compose" : "image";
+        if (config.engine === "bubblewrap") {
+          const { BubblewrapSandbox: BubblewrapSandbox2 } = (init_bubblewrap_sandbox(), __toCommonJS(bubblewrap_sandbox_exports));
+          const instance = new BubblewrapSandbox2(name, config, this.repoPath);
+          this.instances.set(name, instance);
+          return instance;
+        }
+        if (config.engine === "seatbelt") {
+          const { SeatbeltSandbox: SeatbeltSandbox2 } = (init_seatbelt_sandbox(), __toCommonJS(seatbelt_sandbox_exports));
+          const instance = new SeatbeltSandbox2(name, config, this.repoPath);
+          this.instances.set(name, instance);
+          return instance;
+        }
         return withActiveSpan2(
           "visor.sandbox.start",
           {
@@ -10878,8 +11152,8 @@ var init_workspace_manager = __esm({
         );
         if (this.cleanupRequested && this.activeOperations === 0) {
           logger.debug(`[Workspace] All references released, proceeding with deferred cleanup`);
-          for (const resolve6 of this.cleanupResolvers) {
-            resolve6();
+          for (const resolve8 of this.cleanupResolvers) {
+            resolve8();
           }
           this.cleanupResolvers = [];
         }
@@ -10929,13 +11203,34 @@ var init_workspace_manager = __esm({
         const mainProjectPath = path5.join(this.workspacePath, mainProjectName);
         const isGitRepo = await this.isGitRepository(this.originalPath);
         if (isGitRepo) {
-          await this.createMainProjectWorktree(mainProjectPath);
+          const exists = await this.pathExists(mainProjectPath);
+          if (exists) {
+            logger.info(`[Workspace] Reusing existing main project worktree: ${mainProjectPath}`);
+            const isValid = await this.isGitRepository(mainProjectPath);
+            if (!isValid) {
+              logger.warn(`[Workspace] Existing path is not a valid git dir, recreating`);
+              await fsp.rm(mainProjectPath, { recursive: true, force: true });
+              try {
+                await commandExecutor.execute(
+                  `git -C ${shellEscape(this.originalPath)} worktree prune`,
+                  { timeout: 1e4 }
+                );
+              } catch {
+              }
+              await this.createMainProjectWorktree(mainProjectPath);
+            }
+          } else {
+            await this.createMainProjectWorktree(mainProjectPath);
+          }
         } else {
           logger.debug(`Original path is not a git repo, creating symlink`);
-          try {
-            await fsp.symlink(this.originalPath, mainProjectPath);
-          } catch (error) {
-            throw new Error(`Failed to create symlink for main project: ${error}`);
+          const exists = await this.pathExists(mainProjectPath);
+          if (!exists) {
+            try {
+              await fsp.symlink(this.originalPath, mainProjectPath);
+            } catch (error) {
+              throw new Error(`Failed to create symlink for main project: ${error}`);
+            }
           }
         }
         this.registerCleanupHandlers();
@@ -10995,6 +11290,15 @@ var init_workspace_manager = __esm({
        * @param timeout Maximum time to wait for active operations (default: 60s)
        */
       async cleanup(timeout = 6e4) {
+        if (!this.config.cleanupOnExit) {
+          logger.debug(`[Workspace] Skipping cleanup (cleanupOnExit=false): ${this.workspacePath}`);
+          _WorkspaceManager.instances.delete(this.sessionId);
+          this.initialized = false;
+          this.mainProjectInfo = null;
+          this.projects.clear();
+          this.usedNames.clear();
+          return;
+        }
         logger.info(
           `Cleaning up workspace: ${this.workspacePath} (active operations: ${this.activeOperations})`
         );
@@ -11004,19 +11308,19 @@ var init_workspace_manager = __esm({
           );
           this.cleanupRequested = true;
           await Promise.race([
-            new Promise((resolve6) => {
+            new Promise((resolve8) => {
               if (this.activeOperations === 0) {
-                resolve6();
+                resolve8();
               } else {
-                this.cleanupResolvers.push(resolve6);
+                this.cleanupResolvers.push(resolve8);
               }
             }),
-            new Promise((resolve6) => {
+            new Promise((resolve8) => {
               setTimeout(() => {
                 logger.warn(
                   `[Workspace] Cleanup timeout after ${timeout}ms, proceeding anyway (${this.activeOperations} operations still active)`
                 );
-                resolve6();
+                resolve8();
               }, timeout);
             })
           ]);
@@ -11046,6 +11350,68 @@ var init_workspace_manager = __esm({
           logger.warn(`Failed to cleanup workspace: ${error}`);
         }
       }
+      /**
+       * Check if a path exists (file or directory).
+       */
+      async pathExists(p) {
+        try {
+          await fsp.access(p);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Clean up stale workspace directories older than maxAge.
+       * Call periodically (e.g. at socket-runner startup) to prevent disk bloat.
+       */
+      static async cleanupStale(basePath = process.env.VISOR_WORKSPACE_PATH || "/tmp/visor-workspaces", maxAgeMs = 24 * 60 * 60 * 1e3) {
+        let cleaned = 0;
+        try {
+          const entries = await fsp.readdir(basePath, { withFileTypes: true });
+          const now = Date.now();
+          for (const entry of entries) {
+            if (!entry.isDirectory()) continue;
+            const dirPath = path5.join(basePath, entry.name);
+            try {
+              const stat2 = await fsp.stat(dirPath);
+              if (now - stat2.mtimeMs > maxAgeMs) {
+                try {
+                  const subdirs = await fsp.readdir(dirPath, { withFileTypes: true });
+                  for (const sub of subdirs) {
+                    if (!sub.isDirectory()) continue;
+                    const subPath = path5.join(dirPath, sub.name);
+                    const gitFilePath = path5.join(subPath, ".git");
+                    try {
+                      const gitContent = await fsp.readFile(gitFilePath, "utf-8");
+                      const match = gitContent.match(/gitdir:\s*(.+)/);
+                      if (match) {
+                        const worktreeGitDir = match[1].trim();
+                        const repoGitDir = worktreeGitDir.replace(/\/\.git\/worktrees\/.*$/, "");
+                        await commandExecutor.execute(
+                          `git -C ${shellEscape(repoGitDir)} worktree remove ${shellEscape(subPath)} --force`,
+                          { timeout: 1e4 }
+                        );
+                      }
+                    } catch {
+                    }
+                  }
+                } catch {
+                }
+                await fsp.rm(dirPath, { recursive: true, force: true });
+                cleaned++;
+              }
+            } catch {
+            }
+          }
+          if (cleaned > 0) {
+            logger.info(`[Workspace] Cleaned up ${cleaned} stale workspace(s) from ${basePath}`);
+          }
+        } catch (error) {
+          logger.debug(`[Workspace] Stale cleanup error: ${error}`);
+        }
+        return cleaned;
+      }
       /**
        * Create worktree for the main project
        *
@@ -11435,7 +11801,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const map = options?.webhookContext?.webhookData;
             if (map) {
-              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-VTNNTMWC.mjs");
+              const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-HFPKHYTG.mjs");
               const reg = CheckProviderRegistry2.getInstance();
               const p = reg.getProvider("http_input");
               if (p && typeof p.setWebhookContext === "function") p.setWebhookContext(map);
@@ -11548,7 +11914,7 @@ var init_state_machine_execution_engine = __esm({
           logger.info("[StateMachine] Using state machine engine");
         }
         if (!config) {
-          const { ConfigManager } = await import("./config-KOKJ3PYE.mjs");
+          const { ConfigManager } = await import("./config-AAB2FL22.mjs");
           const configManager = new ConfigManager();
           config = await configManager.getDefaultConfig();
           logger.debug("[StateMachine] Using default configuration (no config provided)");
@@ -11558,7 +11924,7 @@ var init_state_machine_execution_engine = __esm({
           tag_filter: tagFilter
         } : config;
         try {
-          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-VTNNTMWC.mjs");
+          const { CheckProviderRegistry: CheckProviderRegistry2 } = await import("./check-provider-registry-HFPKHYTG.mjs");
           const registry = CheckProviderRegistry2.getInstance();
           registry.setCustomTools(configWithTagFilter.tools || {});
         } catch (error) {
@@ -11622,7 +11988,7 @@ var init_state_machine_execution_engine = __esm({
           try {
             const webhookData = this.executionContext?.webhookContext?.webhookData;
             if (webhookData instanceof Map) {
-              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-7RGTKO24.mjs");
+              const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-BTLEDYAI.mjs");
               const slackCtx = extractSlackContext2(webhookData);
               if (slackCtx) {
                 const payload = Array.from(webhookData.values())[0];
@@ -12460,7 +12826,7 @@ var init_mcp_custom_sse_server = __esm({
        * Returns the actual bound port number
        */
       async start() {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           try {
             this.server = http.createServer((req, res) => {
               this.handleRequest(req, res).catch((error) => {
@@ -12494,7 +12860,7 @@ var init_mcp_custom_sse_server = __esm({
                 );
               }
               this.startKeepalive();
-              resolve6(this.port);
+              resolve8(this.port);
             });
           } catch (error) {
             reject(error);
@@ -12557,7 +12923,7 @@ var init_mcp_custom_sse_server = __esm({
             logger.debug(
               `[CustomToolsSSEServer:${this.sessionId}] Grace period before stop: ${waitMs}ms (activeToolCalls=${this.activeToolCalls})`
             );
-            await new Promise((resolve6) => setTimeout(resolve6, waitMs));
+            await new Promise((resolve8) => setTimeout(resolve8, waitMs));
           }
         }
         if (this.activeToolCalls > 0) {
@@ -12566,7 +12932,7 @@ var init_mcp_custom_sse_server = __esm({
             `[CustomToolsSSEServer:${this.sessionId}] Waiting for ${this.activeToolCalls} active tool call(s) before stop`
           );
           while (this.activeToolCalls > 0 && Date.now() - startedAt < effectiveDrainTimeoutMs) {
-            await new Promise((resolve6) => setTimeout(resolve6, 250));
+            await new Promise((resolve8) => setTimeout(resolve8, 250));
           }
           if (this.activeToolCalls > 0) {
             logger.warn(
@@ -12591,21 +12957,21 @@ var init_mcp_custom_sse_server = __esm({
         }
         this.connections.clear();
         if (this.server) {
-          await new Promise((resolve6, reject) => {
+          await new Promise((resolve8, reject) => {
             const timeout = setTimeout(() => {
               if (this.debug) {
                 logger.debug(
                   `[CustomToolsSSEServer:${this.sessionId}] Force closing server after timeout`
                 );
               }
-              this.server?.close(() => resolve6());
+              this.server?.close(() => resolve8());
             }, 5e3);
             this.server.close((error) => {
               clearTimeout(timeout);
               if (error) {
                 reject(error);
               } else {
-                resolve6();
+                resolve8();
               }
             });
           });
@@ -13031,7 +13397,7 @@ var init_mcp_custom_sse_server = __esm({
               logger.warn(
                 `[CustomToolsSSEServer:${this.sessionId}] Tool ${toolName} failed (attempt ${attempt + 1}/${retryCount + 1}): ${errorMsg}. Retrying in ${delay}ms`
               );
-              await new Promise((resolve6) => setTimeout(resolve6, delay));
+              await new Promise((resolve8) => setTimeout(resolve8, delay));
               attempt++;
             }
           }
@@ -13336,8 +13702,8 @@ var init_ai_check_provider = __esm({
           }
           const fs10 = __require("fs").promises;
           try {
-            const stat = await fs10.stat(resolvedPath);
-            return stat.isFile();
+            const stat2 = await fs10.stat(resolvedPath);
+            return stat2.isFile();
           } catch {
             return hasFileExtension && (isRelativePath || isAbsolutePath || hasPathSeparators);
           }
@@ -16585,8 +16951,8 @@ var init_claude_code_check_provider = __esm({
             resolvedPath = path9.resolve(process.cwd(), str);
           }
           try {
-            const stat = await fs7.stat(resolvedPath);
-            return stat.isFile();
+            const stat2 = await fs7.stat(resolvedPath);
+            return stat2.isFile();
           } catch {
             return hasFileExtension && (isRelativePath || isAbsolutePath || hasPathSeparators);
           }
@@ -22215,8 +22581,8 @@ var require_util2 = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve6, reject) => {
-        res = resolve6;
+      const promise = new Promise((resolve8, reject) => {
+        res = resolve8;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -23721,8 +24087,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r
                 });
               }
             });
-            const busboyResolve = new Promise((resolve6, reject) => {
-              busboy.on("finish", resolve6);
+            const busboyResolve = new Promise((resolve8, reject) => {
+              busboy.on("finish", resolve8);
               busboy.on("error", (err) => reject(new TypeError(err)));
             });
             if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk);
@@ -24256,9 +24622,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve8, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve6(data);
+              return err ? reject(err) : resolve8(data);
             });
           });
         }
@@ -24296,12 +24662,12 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve6, reject) => {
+          return new Promise((resolve8, reject) => {
             this.destroy(err, (err2, data) => {
               return err2 ? (
                 /* istanbul ignore next: should never error */
                 reject(err2)
-              ) : resolve6(data);
+              ) : resolve8(data);
             });
           });
         }
@@ -25363,16 +25729,16 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       async [kClose]() {
-        return new Promise((resolve6) => {
+        return new Promise((resolve8) => {
           if (!this[kSize]) {
-            resolve6(null);
+            resolve8(null);
           } else {
-            this[kClosedResolve] = resolve6;
+            this[kClosedResolve] = resolve8;
           }
         });
       }
       async [kDestroy](err) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve8) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request = requests[i];
@@ -25383,7 +25749,7 @@ var require_client = __commonJS({
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve6();
+            resolve8();
           };
           if (this[kHTTP2Session] != null) {
             util.destroy(this[kHTTP2Session], err);
@@ -25963,7 +26329,7 @@ var require_client = __commonJS({
         });
       }
       try {
-        const socket = await new Promise((resolve6, reject) => {
+        const socket = await new Promise((resolve8, reject) => {
           client[kConnector]({
             host,
             hostname,
@@ -25975,7 +26341,7 @@ var require_client = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve6(socket2);
+              resolve8(socket2);
             }
           });
         });
@@ -26599,12 +26965,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve6, reject) => {
+      const waitForDrain = () => new Promise((resolve8, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve6;
+          callback = resolve8;
         }
       });
       if (client[kHTTPConnVersion] === "h2") {
@@ -26950,8 +27316,8 @@ var require_pool_base = __commonJS({
         if (this[kQueue].isEmpty()) {
           return Promise.all(this[kClients].map((c) => c.close()));
         } else {
-          return new Promise((resolve6) => {
-            this[kClosedResolve] = resolve6;
+          return new Promise((resolve8) => {
+            this[kClosedResolve] = resolve8;
           });
         }
       }
@@ -27529,7 +27895,7 @@ var require_readable = __commonJS({
         if (this.closed) {
           return Promise.resolve(null);
         }
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           const signalListenerCleanup = signal ? util.addAbortListener(signal, () => {
             this.destroy();
           }) : noop;
@@ -27538,7 +27904,7 @@ var require_readable = __commonJS({
             if (signal && signal.aborted) {
               reject(signal.reason || Object.assign(new Error("The operation was aborted"), { name: "AbortError" }));
             } else {
-              resolve6(null);
+              resolve8(null);
             }
           }).on("error", noop).on("data", function(chunk) {
             limit -= chunk.length;
@@ -27560,11 +27926,11 @@ var require_readable = __commonJS({
         throw new TypeError("unusable");
       }
       assert(!stream[kConsume]);
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve8, reject) => {
         stream[kConsume] = {
           type,
           stream,
-          resolve: resolve6,
+          resolve: resolve8,
           reject,
           length: 0,
           body: []
@@ -27599,12 +27965,12 @@ var require_readable = __commonJS({
       }
     }
     function consumeEnd(consume2) {
-      const { type, body, resolve: resolve6, stream, length } = consume2;
+      const { type, body, resolve: resolve8, stream, length } = consume2;
       try {
         if (type === "text") {
-          resolve6(toUSVString(Buffer.concat(body)));
+          resolve8(toUSVString(Buffer.concat(body)));
         } else if (type === "json") {
-          resolve6(JSON.parse(Buffer.concat(body)));
+          resolve8(JSON.parse(Buffer.concat(body)));
         } else if (type === "arrayBuffer") {
           const dst = new Uint8Array(length);
           let pos = 0;
@@ -27612,12 +27978,12 @@ var require_readable = __commonJS({
             dst.set(buf, pos);
             pos += buf.byteLength;
           }
-          resolve6(dst.buffer);
+          resolve8(dst.buffer);
         } else if (type === "blob") {
           if (!Blob2) {
             Blob2 = __require("buffer").Blob;
           }
-          resolve6(new Blob2(body, { type: stream[kContentType] }));
+          resolve8(new Blob2(body, { type: stream[kContentType] }));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -27874,9 +28240,9 @@ var require_api_request = __commonJS({
     };
     function request(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           request.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve8(data);
           });
         });
       }
@@ -28049,9 +28415,9 @@ var require_api_stream = __commonJS({
     };
     function stream(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           stream.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve8(data);
           });
         });
       }
@@ -28332,9 +28698,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve8(data);
           });
         });
       }
@@ -28423,9 +28789,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve6, reject) => {
+        return new Promise((resolve8, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve6(data);
+            return err ? reject(err) : resolve8(data);
           });
         });
       }
@@ -28949,7 +29315,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "node_modules/undici/lib/mock/mock-client.js"(exports, module) {
     "use strict";
-    var { promisify: promisify4 } = __require("util");
+    var { promisify: promisify6 } = __require("util");
     var Client2 = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -28989,7 +29355,7 @@ var require_mock_client = __commonJS({
         return new MockInterceptor(opts, this[kDispatches]);
       }
       async [kClose]() {
-        await promisify4(this[kOriginalClose])();
+        await promisify6(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -29002,7 +29368,7 @@ var require_mock_client = __commonJS({
 var require_mock_pool = __commonJS({
   "node_modules/undici/lib/mock/mock-pool.js"(exports, module) {
     "use strict";
-    var { promisify: promisify4 } = __require("util");
+    var { promisify: promisify6 } = __require("util");
     var Pool = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -29042,7 +29408,7 @@ var require_mock_pool = __commonJS({
         return new MockInterceptor(opts, this[kDispatches]);
       }
       async [kClose]() {
-        await promisify4(this[kOriginalClose])();
+        await promisify6(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -32048,7 +32414,7 @@ var require_fetch = __commonJS({
       async function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve6, reject) => agent.dispatch(
+        return new Promise((resolve8, reject) => agent.dispatch(
           {
             path: url.pathname + url.search,
             origin: url.origin,
@@ -32124,7 +32490,7 @@ var require_fetch = __commonJS({
                   }
                 }
               }
-              resolve6({
+              resolve8({
                 status,
                 statusText,
                 headersList: headers[kHeadersList],
@@ -32167,7 +32533,7 @@ var require_fetch = __commonJS({
                 const val = headersList[n + 1].toString("latin1");
                 headers[kHeadersList].append(key, val);
               }
-              resolve6({
+              resolve8({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList: headers[kHeadersList],
@@ -35708,7 +36074,8 @@ var init_mcp_check_provider = __esm({
             fileCount: prInfo.files.length,
             outputs: this.buildOutputContext(dependencyResults),
             args: sessionInfo?.args || {},
-            env: this.getSafeEnvironmentVariables()
+            env: this.getSafeEnvironmentVariables(),
+            inputs: config.workflowInputs || sessionInfo?.workflowInputs || {}
           };
           let methodArgs = cfg.methodArgs || {};
           if (cfg.argsTransform) {
@@ -35961,7 +36328,7 @@ var init_mcp_check_provider = __esm({
             logger.warn(
               `MCP ${transportName} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms: ${error instanceof Error ? error.message : String(error)}`
             );
-            await new Promise((resolve6) => setTimeout(resolve6, delay));
+            await new Promise((resolve8) => setTimeout(resolve8, delay));
             attempt += 1;
           } finally {
             try {
@@ -36244,7 +36611,7 @@ async function acquirePromptLock() {
     activePrompt = true;
     return;
   }
-  await new Promise((resolve6) => waiters.push(resolve6));
+  await new Promise((resolve8) => waiters.push(resolve8));
   activePrompt = true;
 }
 function releasePromptLock() {
@@ -36254,7 +36621,7 @@ function releasePromptLock() {
 }
 async function interactivePrompt(options) {
   await acquirePromptLock();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     const dbg = process.env.VISOR_DEBUG === "true";
     try {
       if (dbg) {
@@ -36341,12 +36708,12 @@ async function interactivePrompt(options) {
     };
     const finish = (value) => {
       cleanup();
-      resolve6(value);
+      resolve8(value);
     };
     if (options.timeout && options.timeout > 0) {
       timeoutId = setTimeout(() => {
         cleanup();
-        if (defaultValue !== void 0) return resolve6(defaultValue);
+        if (defaultValue !== void 0) return resolve8(defaultValue);
         return reject(new Error("Input timeout"));
       }, options.timeout);
     }
@@ -36478,7 +36845,7 @@ async function interactivePrompt(options) {
   });
 }
 async function simplePrompt(prompt) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -36494,7 +36861,7 @@ async function simplePrompt(prompt) {
     rl.question(`${prompt}
 > `, (answer) => {
       rl.close();
-      resolve6(answer.trim());
+      resolve8(answer.trim());
     });
   });
 }
@@ -36512,7 +36879,7 @@ function isStdinAvailable() {
   return !process.stdin.isTTY;
 }
 async function readStdin(timeout, maxSize = 1024 * 1024) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     let data = "";
     let timeoutId;
     if (timeout) {
@@ -36539,7 +36906,7 @@ async function readStdin(timeout, maxSize = 1024 * 1024) {
     };
     const onEnd = () => {
       cleanup();
-      resolve6(data.trim());
+      resolve8(data.trim());
     };
     const onError = (err) => {
       cleanup();
@@ -37327,7 +37694,7 @@ function buildBuiltinGlobals(opts) {
   const scheduleFn = async (args = {}) => {
     try {
       const { handleScheduleAction: handleScheduleAction2, buildScheduleToolContext: buildScheduleToolContext2 } = await import("./schedule-tool-2COUUTF7.mjs");
-      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-7RGTKO24.mjs");
+      const { extractSlackContext: extractSlackContext2 } = await import("./schedule-tool-handler-BTLEDYAI.mjs");
       const parentCtx = opts.sessionInfo?._parentContext;
       const webhookData = parentCtx?.prInfo?.eventContext?.webhookData;
       const visorCfg = parentCtx?.config;
@@ -40281,4 +40648,4 @@ undici/lib/fetch/body.js:
 undici/lib/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
-//# sourceMappingURL=chunk-PXWWPPNF.mjs.map
+//# sourceMappingURL=chunk-GZMQPC6D.mjs.map