nestor-sh 2.0.2 → 2.0.4

package/dist/nestor.mjs

@@ -18392,9 +18392,9 @@ var init_checker = __esm({
       // ── Risk Assessment ─────────────────────────────────────────────────
       assessRisk(toolName, args2) {
         if (toolName === "shell_exec" || toolName.includes("shell") || toolName.includes("exec")) {
-          const command2 = String(args2.command ?? args2.cmd ?? "");
-          if (command2 && !this.isAllowlisted(command2)) {
-            return scanPatterns(command2, SHELL_PATTERNS);
+          const command3 = String(args2.command ?? args2.cmd ?? "");
+          if (command3 && !this.isAllowlisted(command3)) {
+            return scanPatterns(command3, SHELL_PATTERNS);
           }
         }
         if (toolName === "file_write" || toolName.startsWith("file_") && (toolName.includes("write") || toolName.includes("create"))) {
@@ -18447,8 +18447,8 @@ var init_checker = __esm({
         return { denied: true, reason: `Auto-denied (no approval handler): ${reason}`, riskLevel };
       }
       // ── Helpers ─────────────────────────────────────────────────────────
-      isAllowlisted(command2) {
-        return this.allowlist.some((prefix) => command2.startsWith(prefix));
+      isAllowlisted(command3) {
+        return this.allowlist.some((prefix) => command3.startsWith(prefix));
       }
       withTimeout(promise, ms) {
         return new Promise((resolve17, reject) => {
@@ -18476,9 +18476,9 @@ import { exec } from "node:child_process";
 import { promises as fs5 } from "node:fs";
 import { resolve as resolve2, dirname as dirname2, basename, join as join3, relative } from "node:path";
 import crypto3 from "node:crypto";
-function execAsync(command2, cwd) {
+function execAsync(command3, cwd) {
   return new Promise((res, rej) => {
-    exec(command2, { cwd, timeout: 15e3, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+    exec(command3, { cwd, timeout: 15e3, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
       if (err)
         rej(err);
       else
@@ -18506,20 +18506,20 @@ function getAffectedFiles(toolName, args2, workingDir) {
       return [resolve2(workingDir, filePath)];
   }
   if (toolName === "shell_exec") {
-    const command2 = String(args2.command || "");
+    const command3 = String(args2.command || "");
     const files = [];
-    const rmMatch = command2.match(/\brm\s+(?:-[a-zA-Z]*\s+)*(.+)/);
+    const rmMatch = command3.match(/\brm\s+(?:-[a-zA-Z]*\s+)*(.+)/);
     if (rmMatch) {
       const paths = rmMatch[1].split(/\s+/).filter((p8) => !p8.startsWith("-"));
       for (const p8 of paths) {
         files.push(resolve2(workingDir, p8));
       }
     }
-    const mvMatch = command2.match(/\bmv\s+(?:-[a-zA-Z]*\s+)*(\S+)\s+/);
+    const mvMatch = command3.match(/\bmv\s+(?:-[a-zA-Z]*\s+)*(\S+)\s+/);
     if (mvMatch) {
       files.push(resolve2(workingDir, mvMatch[1]));
     }
-    const sedMatch = command2.match(/\bsed\s+-i\S*\s+.*?\s+(\S+)$/);
+    const sedMatch = command3.match(/\bsed\s+-i\S*\s+.*?\s+(\S+)$/);
     if (sedMatch) {
       files.push(resolve2(workingDir, sedMatch[1]));
     }
@@ -18838,9 +18838,9 @@ function redactSecrets2(text7) {
   }
   return result;
 }
-function checkCommand(command2, policy = "smart", allowlist = []) {
+function checkCommand(command3, policy = "smart", allowlist = []) {
   if (native) {
-    const result = native.check_command(command2, policy, allowlist);
+    const result = native.check_command(command3, policy, allowlist);
     return {
       decision: result.decision,
       reasons: result.reasons.map((r) => ({
@@ -18865,14 +18865,14 @@ function checkCommand(command2, policy = "smart", allowlist = []) {
     return { decision: "approved", reasons: [] };
   }
   for (const allowed of allowlist) {
-    if (command2.startsWith(allowed)) {
+    if (command3.startsWith(allowed)) {
       return { decision: "approved", reasons: [] };
     }
   }
   const reasons = [];
   for (const { pattern, desc, category } of DANGEROUS_PATTERNS3) {
     pattern.lastIndex = 0;
-    const match = pattern.exec(command2);
+    const match = pattern.exec(command3);
     if (match) {
       reasons.push({
         description: desc,
@@ -18943,8 +18943,8 @@ var init_native = __esm({
 // ../agent/dist/tools/executor.js
 function createDefaultSecurityChecks() {
   return {
-    checkShellCommand(command2) {
-      const result = checkCommand(command2, "smart", []);
+    checkShellCommand(command3) {
+      const result = checkCommand(command3, "smart", []);
       if (result.decision === "blocked") {
         const reason = result.reasons.length > 0 ? result.reasons.map((r) => r.description).join("; ") : "Blocked by command policy";
         return { allowed: false, reason };
@@ -19092,9 +19092,9 @@ var init_executor2 = __esm({
        */
       preExecutionCheck(toolName, input, context3) {
         if (toolName === "shell_exec" || toolName.includes("shell") || toolName.includes("exec")) {
-          const command2 = input["command"] ?? input["cmd"] ?? "";
-          if (command2) {
-            const check = this.security.checkShellCommand(command2);
+          const command3 = input["command"] ?? input["cmd"] ?? "";
+          if (command3) {
+            const check = this.security.checkShellCommand(command3);
             if (!check.allowed) {
               return { output: `Security check failed: ${check.reason}`, isError: true };
             }
@@ -19178,9 +19178,9 @@ var init_docker = __esm({
       /**
        * Execute a command inside the sandbox container.
        */
-      async execute(command2, args2 = []) {
+      async execute(command3, args2 = []) {
         const containerId = await this.ensureContainer();
-        return this.execInContainer(containerId, [command2, ...args2]);
+        return this.execInContainer(containerId, [command3, ...args2]);
       }
       /**
        * Clean up the sandbox container.
@@ -19394,7 +19394,7 @@ var init_ssh = __esm({
       /**
        * Execute a command on the remote server.
        */
-      async execute(command2, opts) {
+      async execute(command3, opts) {
         await this.ensureConnected();
         const client = this.client;
         const timeoutMs = opts?.timeoutMs ?? 3e4;
@@ -19409,7 +19409,7 @@ var init_ssh = __esm({
           const envParts = Object.entries(opts.env).map(([k, v]) => `${k}=${escapeShellArg(v)}`).join(" ");
           fullCommand += `${envParts} `;
         }
-        fullCommand += command2;
+        fullCommand += command3;
         return new Promise((resolve17, reject) => {
           let timer2 = null;
           let settled = false;
@@ -19677,11 +19677,11 @@ var init_sandbox = __esm({
       constructor(workingDir) {
         this.workingDir = workingDir ?? process.cwd();
       }
-      async execute(command2, opts) {
+      async execute(command3, opts) {
         const cwd = opts?.cwd ? resolve4(this.workingDir, opts.cwd) : this.workingDir;
         const timeoutMs = opts?.timeoutMs ?? 3e4;
         return new Promise((resolveP) => {
-          const child = execFile2("sh", ["-c", command2], {
+          const child = execFile2("sh", ["-c", command3], {
             cwd,
             timeout: timeoutMs,
             maxBuffer: 1024 * 1024,
@@ -19735,8 +19735,8 @@ var init_sandbox = __esm({
       constructor(config2) {
         this.sandbox = new DockerSandbox(config2);
       }
-      async execute(command2, opts) {
-        const result = await this.sandbox.execute("/bin/sh", ["-c", command2]);
+      async execute(command3, opts) {
+        const result = await this.sandbox.execute("/bin/sh", ["-c", command3]);
         return {
           stdout: result.stdout,
           stderr: result.stderr,
@@ -19784,8 +19784,8 @@ var init_sandbox = __esm({
       constructor(config2) {
         this.sandbox = new SSHSandbox(config2);
       }
-      async execute(command2, opts) {
-        return this.sandbox.execute(command2, {
+      async execute(command3, opts) {
+        return this.sandbox.execute(command3, {
           cwd: opts?.cwd,
           env: opts?.env,
           timeoutMs: opts?.timeoutMs
@@ -19836,7 +19836,7 @@ var init_ssh_executor = __esm({
       /**
        * Execute a command on the remote host via SSH.
        */
-      async execute(command2, opts) {
+      async execute(command3, opts) {
         const timeoutMs = opts?.timeout ?? this.timeout;
         const sshArgs = [
           "-o",
@@ -19856,9 +19856,9 @@ var init_ssh_executor = __esm({
           sshArgs.push("-i", this.identityFile);
         }
         sshArgs.push(`${this.user}@${this.host}`);
-        let remoteCmd = command2;
+        let remoteCmd = command3;
         if (opts?.cwd) {
-          remoteCmd = `cd ${this.shellEscape(opts.cwd)} && ${command2}`;
+          remoteCmd = `cd ${this.shellEscape(opts.cwd)} && ${command3}`;
         }
         if (opts?.env) {
           const envPrefix = Object.entries(opts.env).filter(([k]) => !k.match(/SECRET|TOKEN|KEY|PASSWORD/i)).map(([k, v]) => `${k}=${this.shellEscape(v)}`).join(" ");
@@ -19981,7 +19981,7 @@ var init_k8s_executor = __esm({
        * Execute a command in an ephemeral Kubernetes pod.
        * The pod is automatically removed after completion (--rm).
        */
-      async execute(command2, opts) {
+      async execute(command3, opts) {
         const timeoutMs = opts?.timeout ?? this.timeout;
         const podName = `nestor-exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
         const envVars = opts?.env ? Object.entries(opts.env).filter(([k]) => !k.match(/SECRET|TOKEN|KEY|PASSWORD/i)).map(([k, v]) => ({ name: k, value: v })) : [];
@@ -19991,7 +19991,7 @@ var init_k8s_executor = __esm({
             containers: [{
               name: "exec",
               image: this.image,
-              command: ["sh", "-c", command2],
+              command: ["sh", "-c", command3],
               resources: {
                 limits: {
                   cpu: this.cpuLimit,
@@ -20020,7 +20020,7 @@ var init_k8s_executor = __esm({
           "--",
           "sh",
           "-c",
-          command2
+          command3
         ];
         try {
           const result = await execFileAsync2("kubectl", kubectlArgs, {
@@ -43823,23 +43823,23 @@ var require_ActionDispatcher = __commonJS({
         const { modifiers } = source2;
         const unmodifiedText = getKeyEventUnmodifiedText(key, source2, isGrapheme);
         const text7 = getKeyEventText(code ?? "", source2) ?? unmodifiedText;
-        let command2;
+        let command3;
         if (this.#isMacOS && source2.meta) {
           switch (code) {
             case "KeyA":
-              command2 = "SelectAll";
+              command3 = "SelectAll";
               break;
             case "KeyC":
-              command2 = "Copy";
+              command3 = "Copy";
               break;
             case "KeyV":
-              command2 = source2.shift ? "PasteAndMatchStyle" : "Paste";
+              command3 = source2.shift ? "PasteAndMatchStyle" : "Paste";
               break;
             case "KeyX":
-              command2 = "Cut";
+              command3 = "Cut";
               break;
             case "KeyZ":
-              command2 = source2.shift ? "Redo" : "Undo";
+              command3 = source2.shift ? "Redo" : "Undo";
               break;
             default:
           }
@@ -43857,7 +43857,7 @@ var require_ActionDispatcher = __commonJS({
             location: location < 3 ? location : void 0,
             isKeypad: location === 3,
             modifiers,
-            commands: command2 ? [command2] : void 0
+            commands: command3 ? [command3] : void 0
           })
         ];
         if (key === "Escape") {
@@ -45825,158 +45825,158 @@ var require_CommandProcessor = __commonJS({
         this.#sessionProcessor = new SessionProcessor_js_1.SessionProcessor(eventManager, browserCdpClient, initConnection);
         this.#storageProcessor = new StorageProcessor_js_1.StorageProcessor(browserCdpClient, browsingContextStorage, logger);
       }
-      async #processCommand(command2) {
-        switch (command2.method) {
+      async #processCommand(command3) {
+        switch (command3.method) {
           // Bluetooth module
           // keep-sorted start block=yes
           case "bluetooth.handleRequestDevicePrompt":
-            return await this.#bluetoothProcessor.handleRequestDevicePrompt(this.#parser.parseHandleRequestDevicePromptParams(command2.params));
+            return await this.#bluetoothProcessor.handleRequestDevicePrompt(this.#parser.parseHandleRequestDevicePromptParams(command3.params));
           case "bluetooth.simulateAdapter":
-            return await this.#bluetoothProcessor.simulateAdapter(this.#parser.parseSimulateAdapterParameters(command2.params));
+            return await this.#bluetoothProcessor.simulateAdapter(this.#parser.parseSimulateAdapterParameters(command3.params));
           case "bluetooth.simulateAdvertisement":
-            return await this.#bluetoothProcessor.simulateAdvertisement(this.#parser.parseSimulateAdvertisementParameters(command2.params));
+            return await this.#bluetoothProcessor.simulateAdvertisement(this.#parser.parseSimulateAdvertisementParameters(command3.params));
           case "bluetooth.simulatePreconnectedPeripheral":
-            return await this.#bluetoothProcessor.simulatePreconnectedPeripheral(this.#parser.parseSimulatePreconnectedPeripheralParameters(command2.params));
+            return await this.#bluetoothProcessor.simulatePreconnectedPeripheral(this.#parser.parseSimulatePreconnectedPeripheralParameters(command3.params));
           // keep-sorted end
           // Browser module
           // keep-sorted start block=yes
           case "browser.close":
             return this.#browserProcessor.close();
           case "browser.createUserContext":
-            return await this.#browserProcessor.createUserContext(command2.params);
+            return await this.#browserProcessor.createUserContext(command3.params);
           case "browser.getClientWindows":
             return await this.#browserProcessor.getClientWindows();
           case "browser.getUserContexts":
             return await this.#browserProcessor.getUserContexts();
           case "browser.removeUserContext":
-            return await this.#browserProcessor.removeUserContext(this.#parser.parseRemoveUserContextParams(command2.params));
+            return await this.#browserProcessor.removeUserContext(this.#parser.parseRemoveUserContextParams(command3.params));
           case "browser.setClientWindowState":
-            throw new protocol_js_1.UnknownErrorException(`Method ${command2.method} is not implemented.`);
+            throw new protocol_js_1.UnknownErrorException(`Method ${command3.method} is not implemented.`);
           // keep-sorted end
           // Browsing Context module
           // keep-sorted start block=yes
           case "browsingContext.activate":
-            return await this.#browsingContextProcessor.activate(this.#parser.parseActivateParams(command2.params));
+            return await this.#browsingContextProcessor.activate(this.#parser.parseActivateParams(command3.params));
           case "browsingContext.captureScreenshot":
-            return await this.#browsingContextProcessor.captureScreenshot(this.#parser.parseCaptureScreenshotParams(command2.params));
+            return await this.#browsingContextProcessor.captureScreenshot(this.#parser.parseCaptureScreenshotParams(command3.params));
           case "browsingContext.close":
-            return await this.#browsingContextProcessor.close(this.#parser.parseCloseParams(command2.params));
+            return await this.#browsingContextProcessor.close(this.#parser.parseCloseParams(command3.params));
           case "browsingContext.create":
-            return await this.#browsingContextProcessor.create(this.#parser.parseCreateParams(command2.params));
+            return await this.#browsingContextProcessor.create(this.#parser.parseCreateParams(command3.params));
           case "browsingContext.getTree":
-            return this.#browsingContextProcessor.getTree(this.#parser.parseGetTreeParams(command2.params));
+            return this.#browsingContextProcessor.getTree(this.#parser.parseGetTreeParams(command3.params));
           case "browsingContext.handleUserPrompt":
-            return await this.#browsingContextProcessor.handleUserPrompt(this.#parser.parseHandleUserPromptParams(command2.params));
+            return await this.#browsingContextProcessor.handleUserPrompt(this.#parser.parseHandleUserPromptParams(command3.params));
           case "browsingContext.locateNodes":
-            return await this.#browsingContextProcessor.locateNodes(this.#parser.parseLocateNodesParams(command2.params));
+            return await this.#browsingContextProcessor.locateNodes(this.#parser.parseLocateNodesParams(command3.params));
           case "browsingContext.navigate":
-            return await this.#browsingContextProcessor.navigate(this.#parser.parseNavigateParams(command2.params));
+            return await this.#browsingContextProcessor.navigate(this.#parser.parseNavigateParams(command3.params));
           case "browsingContext.print":
-            return await this.#browsingContextProcessor.print(this.#parser.parsePrintParams(command2.params));
+            return await this.#browsingContextProcessor.print(this.#parser.parsePrintParams(command3.params));
           case "browsingContext.reload":
-            return await this.#browsingContextProcessor.reload(this.#parser.parseReloadParams(command2.params));
+            return await this.#browsingContextProcessor.reload(this.#parser.parseReloadParams(command3.params));
           case "browsingContext.setViewport":
-            return await this.#browsingContextProcessor.setViewport(this.#parser.parseSetViewportParams(command2.params));
+            return await this.#browsingContextProcessor.setViewport(this.#parser.parseSetViewportParams(command3.params));
           case "browsingContext.traverseHistory":
-            return await this.#browsingContextProcessor.traverseHistory(this.#parser.parseTraverseHistoryParams(command2.params));
+            return await this.#browsingContextProcessor.traverseHistory(this.#parser.parseTraverseHistoryParams(command3.params));
           // keep-sorted end
           // CDP module
           // keep-sorted start block=yes
           case "goog:cdp.getSession":
-            return this.#cdpProcessor.getSession(this.#parser.parseGetSessionParams(command2.params));
+            return this.#cdpProcessor.getSession(this.#parser.parseGetSessionParams(command3.params));
           case "goog:cdp.resolveRealm":
-            return this.#cdpProcessor.resolveRealm(this.#parser.parseResolveRealmParams(command2.params));
+            return this.#cdpProcessor.resolveRealm(this.#parser.parseResolveRealmParams(command3.params));
           case "goog:cdp.sendCommand":
-            return await this.#cdpProcessor.sendCommand(this.#parser.parseSendCommandParams(command2.params));
+            return await this.#cdpProcessor.sendCommand(this.#parser.parseSendCommandParams(command3.params));
           // keep-sorted end
           // CDP deprecated domain.
           // https://github.com/GoogleChromeLabs/chromium-bidi/issues/2844
           // keep-sorted start block=yes
           case "cdp.getSession":
-            return this.#cdpProcessor.getSession(this.#parser.parseGetSessionParams(command2.params));
+            return this.#cdpProcessor.getSession(this.#parser.parseGetSessionParams(command3.params));
           case "cdp.resolveRealm":
-            return this.#cdpProcessor.resolveRealm(this.#parser.parseResolveRealmParams(command2.params));
+            return this.#cdpProcessor.resolveRealm(this.#parser.parseResolveRealmParams(command3.params));
           case "cdp.sendCommand":
-            return await this.#cdpProcessor.sendCommand(this.#parser.parseSendCommandParams(command2.params));
+            return await this.#cdpProcessor.sendCommand(this.#parser.parseSendCommandParams(command3.params));
           // keep-sorted end
           // Input module
           // keep-sorted start block=yes
           case "input.performActions":
-            return await this.#inputProcessor.performActions(this.#parser.parsePerformActionsParams(command2.params));
+            return await this.#inputProcessor.performActions(this.#parser.parsePerformActionsParams(command3.params));
           case "input.releaseActions":
-            return await this.#inputProcessor.releaseActions(this.#parser.parseReleaseActionsParams(command2.params));
+            return await this.#inputProcessor.releaseActions(this.#parser.parseReleaseActionsParams(command3.params));
           case "input.setFiles":
-            return await this.#inputProcessor.setFiles(this.#parser.parseSetFilesParams(command2.params));
+            return await this.#inputProcessor.setFiles(this.#parser.parseSetFilesParams(command3.params));
           // keep-sorted end
           // Network module
           // keep-sorted start block=yes
           case "network.addIntercept":
-            return await this.#networkProcessor.addIntercept(this.#parser.parseAddInterceptParams(command2.params));
+            return await this.#networkProcessor.addIntercept(this.#parser.parseAddInterceptParams(command3.params));
           case "network.continueRequest":
-            return await this.#networkProcessor.continueRequest(this.#parser.parseContinueRequestParams(command2.params));
+            return await this.#networkProcessor.continueRequest(this.#parser.parseContinueRequestParams(command3.params));
           case "network.continueResponse":
-            return await this.#networkProcessor.continueResponse(this.#parser.parseContinueResponseParams(command2.params));
+            return await this.#networkProcessor.continueResponse(this.#parser.parseContinueResponseParams(command3.params));
           case "network.continueWithAuth":
-            return await this.#networkProcessor.continueWithAuth(this.#parser.parseContinueWithAuthParams(command2.params));
+            return await this.#networkProcessor.continueWithAuth(this.#parser.parseContinueWithAuthParams(command3.params));
           case "network.failRequest":
-            return await this.#networkProcessor.failRequest(this.#parser.parseFailRequestParams(command2.params));
+            return await this.#networkProcessor.failRequest(this.#parser.parseFailRequestParams(command3.params));
           case "network.provideResponse":
-            return await this.#networkProcessor.provideResponse(this.#parser.parseProvideResponseParams(command2.params));
+            return await this.#networkProcessor.provideResponse(this.#parser.parseProvideResponseParams(command3.params));
           case "network.removeIntercept":
-            return await this.#networkProcessor.removeIntercept(this.#parser.parseRemoveInterceptParams(command2.params));
+            return await this.#networkProcessor.removeIntercept(this.#parser.parseRemoveInterceptParams(command3.params));
           case "network.setCacheBehavior":
-            return await this.#networkProcessor.setCacheBehavior(this.#parser.parseSetCacheBehavior(command2.params));
+            return await this.#networkProcessor.setCacheBehavior(this.#parser.parseSetCacheBehavior(command3.params));
           // keep-sorted end
           // Permissions module
           // keep-sorted start block=yes
           case "permissions.setPermission":
-            return await this.#permissionsProcessor.setPermissions(this.#parser.parseSetPermissionsParams(command2.params));
+            return await this.#permissionsProcessor.setPermissions(this.#parser.parseSetPermissionsParams(command3.params));
           // keep-sorted end
           // Script module
           // keep-sorted start block=yes
           case "script.addPreloadScript":
-            return await this.#scriptProcessor.addPreloadScript(this.#parser.parseAddPreloadScriptParams(command2.params));
+            return await this.#scriptProcessor.addPreloadScript(this.#parser.parseAddPreloadScriptParams(command3.params));
           case "script.callFunction":
-            return await this.#scriptProcessor.callFunction(this.#parser.parseCallFunctionParams(this.#processTargetParams(command2.params)));
+            return await this.#scriptProcessor.callFunction(this.#parser.parseCallFunctionParams(this.#processTargetParams(command3.params)));
           case "script.disown":
-            return await this.#scriptProcessor.disown(this.#parser.parseDisownParams(this.#processTargetParams(command2.params)));
+            return await this.#scriptProcessor.disown(this.#parser.parseDisownParams(this.#processTargetParams(command3.params)));
           case "script.evaluate":
-            return await this.#scriptProcessor.evaluate(this.#parser.parseEvaluateParams(this.#processTargetParams(command2.params)));
+            return await this.#scriptProcessor.evaluate(this.#parser.parseEvaluateParams(this.#processTargetParams(command3.params)));
           case "script.getRealms":
-            return this.#scriptProcessor.getRealms(this.#parser.parseGetRealmsParams(command2.params));
+            return this.#scriptProcessor.getRealms(this.#parser.parseGetRealmsParams(command3.params));
           case "script.removePreloadScript":
-            return await this.#scriptProcessor.removePreloadScript(this.#parser.parseRemovePreloadScriptParams(command2.params));
+            return await this.#scriptProcessor.removePreloadScript(this.#parser.parseRemovePreloadScriptParams(command3.params));
           // keep-sorted end
           // Session module
           // keep-sorted start block=yes
           case "session.end":
-            throw new protocol_js_1.UnknownErrorException(`Method ${command2.method} is not implemented.`);
+            throw new protocol_js_1.UnknownErrorException(`Method ${command3.method} is not implemented.`);
           case "session.new":
-            return await this.#sessionProcessor.new(command2.params);
+            return await this.#sessionProcessor.new(command3.params);
           case "session.status":
             return this.#sessionProcessor.status();
           case "session.subscribe":
-            return await this.#sessionProcessor.subscribe(this.#parser.parseSubscribeParams(command2.params), command2.channel);
+            return await this.#sessionProcessor.subscribe(this.#parser.parseSubscribeParams(command3.params), command3.channel);
           case "session.unsubscribe":
-            return await this.#sessionProcessor.unsubscribe(this.#parser.parseSubscribeParams(command2.params), command2.channel);
+            return await this.#sessionProcessor.unsubscribe(this.#parser.parseSubscribeParams(command3.params), command3.channel);
           // keep-sorted end
           // Storage module
           // keep-sorted start block=yes
           case "storage.deleteCookies":
-            return await this.#storageProcessor.deleteCookies(this.#parser.parseDeleteCookiesParams(command2.params));
+            return await this.#storageProcessor.deleteCookies(this.#parser.parseDeleteCookiesParams(command3.params));
           case "storage.getCookies":
-            return await this.#storageProcessor.getCookies(this.#parser.parseGetCookiesParams(command2.params));
+            return await this.#storageProcessor.getCookies(this.#parser.parseGetCookiesParams(command3.params));
           case "storage.setCookie":
-            return await this.#storageProcessor.setCookie(this.#parser.parseSetCookieParams(command2.params));
+            return await this.#storageProcessor.setCookie(this.#parser.parseSetCookieParams(command3.params));
           // keep-sorted end
           // WebExtension module
           // keep-sorted start block=yes
           case "webExtension.install":
-            throw new protocol_js_1.UnknownErrorException(`Method ${command2.method} is not implemented.`);
+            throw new protocol_js_1.UnknownErrorException(`Method ${command3.method} is not implemented.`);
           case "webExtension.uninstall":
-            throw new protocol_js_1.UnknownErrorException(`Method ${command2.method} is not implemented.`);
+            throw new protocol_js_1.UnknownErrorException(`Method ${command3.method} is not implemented.`);
         }
-        throw new protocol_js_1.UnknownCommandException(`Unknown command '${command2?.method}'.`);
+        throw new protocol_js_1.UnknownCommandException(`Unknown command '${command3?.method}'.`);
       }
       // Workaround for as zod.union always take the first schema
       // https://github.com/w3c/webdriver-bidi/issues/635
@@ -45986,30 +45986,30 @@ var require_CommandProcessor = __commonJS({
         }
         return params;
       }
-      async processCommand(command2) {
+      async processCommand(command3) {
         try {
-          const result = await this.#processCommand(command2);
+          const result = await this.#processCommand(command3);
           const response = {
             type: "success",
-            id: command2.id,
+            id: command3.id,
             result
           };
           this.emit("response", {
-            message: OutgoingMessage_js_1.OutgoingMessage.createResolved(response, command2.channel),
-            event: command2.method
+            message: OutgoingMessage_js_1.OutgoingMessage.createResolved(response, command3.channel),
+            event: command3.method
           });
         } catch (e) {
           if (e instanceof protocol_js_1.Exception) {
             this.emit("response", {
-              message: OutgoingMessage_js_1.OutgoingMessage.createResolved(e.toErrorResponse(command2.id), command2.channel),
-              event: command2.method
+              message: OutgoingMessage_js_1.OutgoingMessage.createResolved(e.toErrorResponse(command3.id), command3.channel),
+              event: command3.method
             });
           } else {
             const error = e;
             this.#logger?.(log_js_1.LogType.bidi, error);
             this.emit("response", {
-              message: OutgoingMessage_js_1.OutgoingMessage.createResolved(new protocol_js_1.UnknownErrorException(error.message, error.stack).toErrorResponse(command2.id), command2.channel),
-              event: command2.method
+              message: OutgoingMessage_js_1.OutgoingMessage.createResolved(new protocol_js_1.UnknownErrorException(error.message, error.stack).toErrorResponse(command3.id), command3.channel),
+              event: command3.method
             });
           }
         }
@@ -65818,18 +65818,18 @@ var require_FtpContext = __commonJS({
       /**
        * Send an FTP command without waiting for or handling the result.
        */
-      send(command2) {
-        const containsPassword = command2.startsWith("PASS");
-        const message = containsPassword ? "> PASS ###" : `> ${command2}`;
+      send(command3) {
+        const containsPassword = command3.startsWith("PASS");
+        const message = containsPassword ? "> PASS ###" : `> ${command3}`;
         this.log(message);
-        this._socket.write(command2 + "\r\n", this.encoding);
+        this._socket.write(command3 + "\r\n", this.encoding);
       }
       /**
        * Send an FTP command and handle the first response. Use this if you have a simple
        * request-response situation.
        */
-      request(command2) {
-        return this.handle(command2, (res, task) => {
+      request(command3) {
+        return this.handle(command3, (res, task) => {
           if (res instanceof Error) {
             task.reject(res);
           } else {
@@ -65841,7 +65841,7 @@ var require_FtpContext = __commonJS({
        * Send an FTP command and handle any response until you resolve/reject. Use this if you expect multiple responses
        * to a request. This returns a Promise that will hold whatever the response handler passed on when resolving/rejecting its task.
        */
-      handle(command2, responseHandler) {
+      handle(command3, responseHandler) {
         if (this._task) {
           const err = new Error("User launched a task while another one is still running. Forgot to use 'await' or '.then()'?");
           err.stack += `
@@ -65872,8 +65872,8 @@ Closing reason: ${this._closingError.stack}`;
             return;
           }
           this.socket.setTimeout(this.timeout);
-          if (command2) {
-            this.send(command2);
+          if (command3) {
+            this.send(command3);
           }
         });
       }
@@ -66932,20 +66932,20 @@ var require_Client = __commonJS({
       /**
        * Send an FTP command and handle the first response.
        */
-      send(command2, ignoreErrorCodesDEPRECATED = false) {
+      send(command3, ignoreErrorCodesDEPRECATED = false) {
         if (ignoreErrorCodesDEPRECATED) {
           this.ftp.log("Deprecated call using send(command, flag) with boolean flag to ignore errors. Use sendIgnoringError(command).");
-          return this.sendIgnoringError(command2);
+          return this.sendIgnoringError(command3);
         }
-        return this.ftp.request(command2);
+        return this.ftp.request(command3);
       }
       /**
        * Send an FTP command and ignore an FTP error response. Any other kind of error or timeout will still reject the Promise.
        *
        * @param command
        */
-      sendIgnoringError(command2) {
-        return this.ftp.handle(command2, (res, task) => {
+      sendIgnoringError(command3) {
+        return this.ftp.handle(command3, (res, task) => {
           if (res instanceof FtpContext_1.FTPError) {
             task.resolve({ code: res.code, message: res.message });
           } else if (res instanceof Error) {
@@ -66961,8 +66961,8 @@ var require_Client = __commonJS({
        * @param options  TLS options as in `tls.connect(options)`, optional.
        * @param command  Set the authentication command. Optional, default is "AUTH TLS".
        */
-      async useTLS(options = {}, command2 = "AUTH TLS") {
-        const ret = await this.send(command2);
+      async useTLS(options = {}, command3 = "AUTH TLS") {
+        const ret = await this.send(command3);
         this.ftp.socket = await (0, netUtils_1.upgradeSocket)(this.ftp.socket, options);
         this.ftp.tlsOptions = options;
         this.ftp.log(`Control socket is using: ${(0, netUtils_1.describeTLS)(this.ftp.socket)}`);
@@ -67096,11 +67096,11 @@ var require_Client = __commonJS({
        */
       async size(path30) {
         const validPath = await this.protectWhitespace(path30);
-        const command2 = `SIZE ${validPath}`;
-        const res = await this.send(command2);
+        const command3 = `SIZE ${validPath}`;
+        const res = await this.send(command3);
         const size = parseInt(res.message.slice(4), 10);
         if (Number.isNaN(size)) {
-          throw new Error(`Can't parse response to command '${command2}' as a numerical value: ${res.message}`);
+          throw new Error(`Can't parse response to command '${command3}' as a numerical value: ${res.message}`);
         }
         return size;
       }
@@ -67163,16 +67163,16 @@ var require_Client = __commonJS({
       /**
        * @protected
        */
-      async _uploadWithCommand(source2, remotePath, command2, options) {
+      async _uploadWithCommand(source2, remotePath, command3, options) {
         if (typeof source2 === "string") {
-          return this._uploadLocalFile(source2, remotePath, command2, options);
+          return this._uploadLocalFile(source2, remotePath, command3, options);
         }
-        return this._uploadFromStream(source2, remotePath, command2);
+        return this._uploadFromStream(source2, remotePath, command3);
       }
       /**
        * @protected
        */
-      async _uploadLocalFile(localPath, remotePath, command2, options) {
+      async _uploadLocalFile(localPath, remotePath, command3, options) {
         const fd = await fsOpen(localPath, "r");
         const source2 = (0, fs_1.createReadStream)("", {
           fd,
@@ -67181,7 +67181,7 @@ var require_Client = __commonJS({
           autoClose: false
         });
         try {
-          return await this._uploadFromStream(source2, remotePath, command2);
+          return await this._uploadFromStream(source2, remotePath, command3);
         } finally {
           await ignoreError(() => fsClose(fd));
         }
@@ -67189,7 +67189,7 @@ var require_Client = __commonJS({
       /**
        * @protected
        */
-      async _uploadFromStream(source2, remotePath, command2) {
+      async _uploadFromStream(source2, remotePath, command3) {
         const onError = (err) => this.ftp.closeWithError(err);
         source2.once("error", onError);
         try {
@@ -67198,7 +67198,7 @@ var require_Client = __commonJS({
           return await (0, transfer_1.uploadFrom)(source2, {
             ftp: this.ftp,
             tracker: this._progressTracker,
-            command: command2,
+            command: command3,
             remotePath: validPath,
             type: "upload"
           });
@@ -67281,10 +67281,10 @@ var require_Client = __commonJS({
         const validPath = await this.protectWhitespace(path30);
         let lastError;
         for (const candidate of this.availableListCommands) {
-          const command2 = validPath === "" ? candidate : `${candidate} ${validPath}`;
+          const command3 = validPath === "" ? candidate : `${candidate} ${validPath}`;
           await this.prepareTransfer(this.ftp);
           try {
-            const parsedList = await this._requestListWithCommand(command2);
+            const parsedList = await this._requestListWithCommand(command3);
             this.availableListCommands = [candidate];
             return parsedList;
           } catch (err) {
@@ -67300,12 +67300,12 @@ var require_Client = __commonJS({
       /**
        * @protected
        */
-      async _requestListWithCommand(command2) {
+      async _requestListWithCommand(command3) {
         const buffer = new StringWriter_1.StringWriter();
         await (0, transfer_1.downloadTo)(buffer, {
           ftp: this.ftp,
           tracker: this._progressTracker,
-          command: command2,
+          command: command3,
           remotePath: "",
           type: "list"
         });
@@ -69075,7 +69075,7 @@ var require_util2 = __commonJS({
       return path30;
     }
     exports2.normalize = normalize3;
-    function join23(aRoot, aPath) {
+    function join24(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -69107,7 +69107,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports2.join = join23;
+    exports2.join = join24;
     exports2.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -69280,7 +69280,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join23(urlGenerate(parsed), sourceURL);
+        sourceURL = join24(urlGenerate(parsed), sourceURL);
       }
       return normalize3(sourceURL);
     }
@@ -71082,7 +71082,7 @@ var require_escodegen = __commonJS({
       function noEmptySpace() {
         return space ? space : " ";
       }
-      function join23(left2, right2) {
+      function join24(left2, right2) {
         var leftSource, rightSource, leftCharCode, rightCharCode;
         leftSource = toSourceNodeWhenNeeded(left2).toString();
         if (leftSource.length === 0) {
@@ -71413,8 +71413,8 @@ var require_escodegen = __commonJS({
           } else {
             result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
           }
-          result = join23(result, operator);
-          result = [join23(
+          result = join24(result, operator);
+          result = [join24(
             result,
             that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)
           ), ")"];
@@ -71557,11 +71557,11 @@ var require_escodegen = __commonJS({
           var result, fragment;
           result = ["class"];
           if (stmt.id) {
-            result = join23(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+            result = join24(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
           }
           if (stmt.superClass) {
-            fragment = join23("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-            result = join23(result, fragment);
+            fragment = join24("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+            result = join24(result, fragment);
           }
           result.push(space);
           result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -71574,9 +71574,9 @@ var require_escodegen = __commonJS({
           return escapeDirective(stmt.directive) + this.semicolon(flags);
         },
         DoWhileStatement: function(stmt, flags) {
-          var result = join23("do", this.maybeBlock(stmt.body, S_TFFF));
+          var result = join24("do", this.maybeBlock(stmt.body, S_TFFF));
           result = this.maybeBlockSuffix(stmt.body, result);
-          return join23(result, [
+          return join24(result, [
             "while" + space + "(",
             this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
             ")" + this.semicolon(flags)
@@ -71612,11 +71612,11 @@ var require_escodegen = __commonJS({
         ExportDefaultDeclaration: function(stmt, flags) {
           var result = ["export"], bodyFlags;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-          result = join23(result, "default");
+          result = join24(result, "default");
           if (isStatement(stmt.declaration)) {
-            result = join23(result, this.generateStatement(stmt.declaration, bodyFlags));
+            result = join24(result, this.generateStatement(stmt.declaration, bodyFlags));
           } else {
-            result = join23(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+            result = join24(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
           }
           return result;
         },
@@ -71624,15 +71624,15 @@ var require_escodegen = __commonJS({
           var result = ["export"], bodyFlags, that = this;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
           if (stmt.declaration) {
-            return join23(result, this.generateStatement(stmt.declaration, bodyFlags));
+            return join24(result, this.generateStatement(stmt.declaration, bodyFlags));
           }
           if (stmt.specifiers) {
             if (stmt.specifiers.length === 0) {
-              result = join23(result, "{" + space + "}");
+              result = join24(result, "{" + space + "}");
             } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-              result = join23(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+              result = join24(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
             } else {
-              result = join23(result, "{");
+              result = join24(result, "{");
               withIndent(function(indent2) {
                 var i, iz;
                 result.push(newline);
@@ -71650,7 +71650,7 @@ var require_escodegen = __commonJS({
               result.push(base + "}");
             }
             if (stmt.source) {
-              result = join23(result, [
+              result = join24(result, [
                 "from" + space,
                 // ModuleSpecifier
                 this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -71738,7 +71738,7 @@ var require_escodegen = __commonJS({
           ];
           cursor = 0;
           if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-            result = join23(result, [
+            result = join24(result, [
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
             ++cursor;
@@ -71748,7 +71748,7 @@ var require_escodegen = __commonJS({
               result.push(",");
             }
             if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-              result = join23(result, [
+              result = join24(result, [
                 space,
                 this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
               ]);
@@ -71777,7 +71777,7 @@ var require_escodegen = __commonJS({
               }
             }
           }
-          result = join23(result, [
+          result = join24(result, [
             "from" + space,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -71831,7 +71831,7 @@ var require_escodegen = __commonJS({
           return result;
         },
         ThrowStatement: function(stmt, flags) {
-          return [join23(
+          return [join24(
             "throw",
             this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
           ), this.semicolon(flags)];
@@ -71842,7 +71842,7 @@ var require_escodegen = __commonJS({
           result = this.maybeBlockSuffix(stmt.block, result);
           if (stmt.handlers) {
             for (i = 0, iz = stmt.handlers.length; i < iz; ++i) {
-              result = join23(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+              result = join24(result, this.generateStatement(stmt.handlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
               }
@@ -71850,7 +71850,7 @@ var require_escodegen = __commonJS({
           } else {
             guardedHandlers = stmt.guardedHandlers || [];
             for (i = 0, iz = guardedHandlers.length; i < iz; ++i) {
-              result = join23(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+              result = join24(result, this.generateStatement(guardedHandlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
               }
@@ -71858,13 +71858,13 @@ var require_escodegen = __commonJS({
             if (stmt.handler) {
               if (Array.isArray(stmt.handler)) {
                 for (i = 0, iz = stmt.handler.length; i < iz; ++i) {
-                  result = join23(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                  result = join24(result, this.generateStatement(stmt.handler[i], S_TFFF));
                   if (stmt.finalizer || i + 1 !== iz) {
                     result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                   }
                 }
               } else {
-                result = join23(result, this.generateStatement(stmt.handler, S_TFFF));
+                result = join24(result, this.generateStatement(stmt.handler, S_TFFF));
                 if (stmt.finalizer) {
                   result = this.maybeBlockSuffix(stmt.handler.body, result);
                 }
@@ -71872,7 +71872,7 @@ var require_escodegen = __commonJS({
             }
           }
           if (stmt.finalizer) {
-            result = join23(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+            result = join24(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
           }
           return result;
         },
@@ -71906,7 +71906,7 @@ var require_escodegen = __commonJS({
           withIndent(function() {
             if (stmt.test) {
               result = [
-                join23("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+                join24("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
                 ":"
               ];
             } else {
@@ -71954,9 +71954,9 @@ var require_escodegen = __commonJS({
             result.push(this.maybeBlock(stmt.consequent, S_TFFF));
             result = this.maybeBlockSuffix(stmt.consequent, result);
             if (stmt.alternate.type === Syntax.IfStatement) {
-              result = join23(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+              result = join24(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
             } else {
-              result = join23(result, join23("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+              result = join24(result, join24("else", this.maybeBlock(stmt.alternate, bodyFlags)));
             }
           } else {
             result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -72057,7 +72057,7 @@ var require_escodegen = __commonJS({
         },
         ReturnStatement: function(stmt, flags) {
           if (stmt.argument) {
-            return [join23(
+            return [join24(
               "return",
               this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
             ), this.semicolon(flags)];
@@ -72146,14 +72146,14 @@ var require_escodegen = __commonJS({
           if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
             result = [fragment, noEmptySpace(), expr.operator];
           } else {
-            result = join23(fragment, expr.operator);
+            result = join24(fragment, expr.operator);
           }
           fragment = this.generateExpression(expr.right, rightPrecedence, flags);
           if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") {
             result.push(noEmptySpace());
             result.push(fragment);
           } else {
-            result = join23(result, fragment);
+            result = join24(result, fragment);
           }
           if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
             return ["(", result, ")"];
@@ -72193,7 +72193,7 @@ var require_escodegen = __commonJS({
           var result, length, i, iz, itemFlags;
           length = expr["arguments"].length;
           itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF;
-          result = join23(
+          result = join24(
             "new",
             this.generateExpression(expr.callee, Precedence.New, itemFlags)
           );
@@ -72243,11 +72243,11 @@ var require_escodegen = __commonJS({
           var result, fragment, rightCharCode, leftSource, leftCharCode;
           fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
           if (space === "") {
-            result = join23(expr.operator, fragment);
+            result = join24(expr.operator, fragment);
           } else {
             result = [expr.operator];
             if (expr.operator.length > 2) {
-              result = join23(result, fragment);
+              result = join24(result, fragment);
             } else {
               leftSource = toSourceNodeWhenNeeded(result).toString();
               leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -72270,7 +72270,7 @@ var require_escodegen = __commonJS({
             result = "yield";
           }
           if (expr.argument) {
-            result = join23(
+            result = join24(
               result,
               this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
             );
@@ -72278,7 +72278,7 @@ var require_escodegen = __commonJS({
           return parenthesize(result, Precedence.Yield, precedence);
         },
         AwaitExpression: function(expr, precedence, flags) {
-          var result = join23(
+          var result = join24(
             expr.all ? "await*" : "await",
             this.generateExpression(expr.argument, Precedence.Await, E_TTT)
           );
@@ -72361,11 +72361,11 @@ var require_escodegen = __commonJS({
           var result, fragment;
           result = ["class"];
           if (expr.id) {
-            result = join23(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+            result = join24(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
           }
           if (expr.superClass) {
-            fragment = join23("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-            result = join23(result, fragment);
+            fragment = join24("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+            result = join24(result, fragment);
           }
           result.push(space);
           result.push(this.generateStatement(expr.body, S_TFFT));
@@ -72380,7 +72380,7 @@ var require_escodegen = __commonJS({
           }
           if (expr.kind === "get" || expr.kind === "set") {
             fragment = [
-              join23(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+              join24(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
               this.generateFunctionBody(expr.value)
             ];
           } else {
@@ -72390,7 +72390,7 @@ var require_escodegen = __commonJS({
               this.generateFunctionBody(expr.value)
             ];
           }
-          return join23(result, fragment);
+          return join24(result, fragment);
         },
         Property: function(expr, precedence, flags) {
           if (expr.kind === "get" || expr.kind === "set") {
@@ -72585,7 +72585,7 @@ var require_escodegen = __commonJS({
               for (i = 0, iz = expr.blocks.length; i < iz; ++i) {
                 fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT);
                 if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
-                  result = join23(result, fragment);
+                  result = join24(result, fragment);
                 } else {
                   result.push(fragment);
                 }
@@ -72593,13 +72593,13 @@ var require_escodegen = __commonJS({
             });
           }
           if (expr.filter) {
-            result = join23(result, "if" + space);
+            result = join24(result, "if" + space);
             fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-            result = join23(result, ["(", fragment, ")"]);
+            result = join24(result, ["(", fragment, ")"]);
           }
           if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
             fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-            result = join23(result, fragment);
+            result = join24(result, fragment);
           }
           result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
           return result;
@@ -72615,8 +72615,8 @@ var require_escodegen = __commonJS({
           } else {
             fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
           }
-          fragment = join23(fragment, expr.of ? "of" : "in");
-          fragment = join23(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+          fragment = join24(fragment, expr.of ? "of" : "in");
+          fragment = join24(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
           return ["for" + space + "(", fragment, ")"];
         },
         SpreadElement: function(expr, precedence, flags) {
@@ -87434,9 +87434,9 @@ async function syncPreferences(options) {
     }),
     backupFile(prefsPath)
   ]);
-  for (const command2 of result) {
-    if (command2.status === "rejected") {
-      throw command2.reason;
+  for (const command3 of result) {
+    if (command3.status === "rejected") {
+      throw command3.reason;
     }
   }
 }
@@ -95356,15 +95356,15 @@ var init_command = __esm({
           if (isCommandAndAliases(cmd)) {
             [cmd, ...aliases] = cmd;
           } else {
-            for (const command2 of cmd) {
-              this.addHandler(command2);
+            for (const command3 of cmd) {
+              this.addHandler(command3);
             }
           }
         } else if (isCommandHandlerDefinition(cmd)) {
-          let command2 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd);
+          let command3 = Array.isArray(cmd.command) || typeof cmd.command === "string" ? cmd.command : this.moduleName(cmd);
           if (cmd.aliases)
-            command2 = [].concat(command2).concat(cmd.aliases);
-          this.addHandler(command2, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
+            command3 = [].concat(command3).concat(cmd.aliases);
+          this.addHandler(command3, this.extractDesc(cmd), cmd.builder, cmd.handler, cmd.middlewares, cmd.deprecated);
           return;
         } else if (isCommandBuilderDefinition(builder)) {
           this.addHandler([cmd].concat(aliases), description, builder.builder, builder.handler, builder.middlewares, builder.deprecated);
@@ -95417,13 +95417,13 @@ var init_command = __esm({
       hasDefaultCommand() {
         return !!this.defaultCommand;
       }
-      runCommand(command2, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
-        const commandHandler = this.handlers[command2] || this.handlers[this.aliasMap[command2]] || this.defaultCommand;
+      runCommand(command3, yargs, parsed, commandIndex, helpOnly, helpOrVersionSet) {
+        const commandHandler = this.handlers[command3] || this.handlers[this.aliasMap[command3]] || this.defaultCommand;
         const currentContext = yargs.getInternalMethods().getContext();
         const parentCommands = currentContext.commands.slice();
-        const isDefaultCommand = !command2;
-        if (command2) {
-          currentContext.commands.push(command2);
+        const isDefaultCommand = !command3;
+        if (command3) {
+          currentContext.commands.push(command3);
           currentContext.fullCommands.push(commandHandler.original);
         }
         const builderResult = this.applyBuilderUpdateUsageAndParse(isDefaultCommand, commandHandler, yargs, parsed.aliases, parentCommands, commandIndex, helpOnly, helpOrVersionSet);
@@ -95814,7 +95814,7 @@ function usage(yargs, shim3) {
     examples.push([cmd, description || ""]);
   };
   let commands = [];
-  self2.command = function command2(cmd, description, isDefault, aliases, deprecated = false) {
+  self2.command = function command3(cmd, description, isDefault, aliases, deprecated = false) {
     if (isDefault) {
       commands = commands.map((cmdArray) => {
         cmdArray[2] = false;
@@ -95916,22 +95916,22 @@ function usage(yargs, shim3) {
         commands = commands.sort((a, b) => a[0].localeCompare(b[0]));
       }
       const prefix = base$0 ? `${base$0} ` : "";
-      commands.forEach((command2) => {
-        const commandString = `${prefix}${parentCommands}${command2[0].replace(/^\$0 ?/, "")}`;
+      commands.forEach((command3) => {
+        const commandString = `${prefix}${parentCommands}${command3[0].replace(/^\$0 ?/, "")}`;
         ui2.span({
           text: commandString,
           padding: [0, 2, 0, 2],
           width: maxWidth(commands, theWrap, `${base$0}${parentCommands}`) + 4
-        }, { text: command2[1] });
+        }, { text: command3[1] });
         const hints = [];
-        if (command2[2])
+        if (command3[2])
           hints.push(`[${__("default")}]`);
-        if (command2[3] && command2[3].length) {
-          hints.push(`[${__("aliases:")} ${command2[3].join(", ")}]`);
+        if (command3[3] && command3[3].length) {
+          hints.push(`[${__("aliases:")} ${command3[3].join(", ")}]`);
         }
-        if (command2[4]) {
-          if (typeof command2[4] === "string") {
-            hints.push(`[${__("deprecated: %s", command2[4])}]`);
+        if (command3[4]) {
+          if (typeof command3[4] === "string") {
+            hints.push(`[${__("deprecated: %s", command3[4])}]`);
           } else {
             hints.push(`[${__("deprecated")}]`);
           }
@@ -96312,8 +96312,8 @@ compdef _{{app_name}}_yargs_completions {{app_name}}
 });
 
 // ../../node_modules/.pnpm/yargs@17.7.2/node_modules/yargs/build/lib/completion.js
-function completion(yargs, usage2, command2, shim3) {
-  return new Completion(yargs, usage2, command2, shim3);
+function completion(yargs, usage2, command3, shim3) {
+  return new Completion(yargs, usage2, command3, shim3);
 }
 function isSyncCompletionFunction(completionFunction) {
   return completionFunction.length < 3;
@@ -96330,11 +96330,11 @@ var init_completion = __esm({
     init_is_promise();
     init_parse_command();
     Completion = class {
-      constructor(yargs, usage2, command2, shim3) {
+      constructor(yargs, usage2, command3, shim3) {
         var _a4, _b2, _c2;
         this.yargs = yargs;
         this.usage = usage2;
-        this.command = command2;
+        this.command = command3;
         this.shim = shim3;
         this.completionKey = "get-yargs-completions";
         this.aliases = null;
@@ -100169,8 +100169,8 @@ function findChromePath() {
     for (const p8 of paths) {
       if (p8) {
         try {
-          const { existsSync: existsSync19 } = __require("node:fs");
-          if (existsSync19(p8))
+          const { existsSync: existsSync21 } = __require("node:fs");
+          if (existsSync21(p8))
             return p8;
         } catch {
         }
@@ -100186,8 +100186,8 @@ function findChromePath() {
     ];
     for (const p8 of paths) {
       try {
-        const { existsSync: existsSync19 } = __require("node:fs");
-        if (existsSync19(p8))
+        const { existsSync: existsSync21 } = __require("node:fs");
+        if (existsSync21(p8))
           return p8;
       } catch {
       }
@@ -100203,8 +100203,8 @@ function findChromePath() {
   ];
   for (const p8 of linuxPaths) {
     try {
-      const { existsSync: existsSync19 } = __require("node:fs");
-      if (existsSync19(p8))
+      const { existsSync: existsSync21 } = __require("node:fs");
+      if (existsSync21(p8))
         return p8;
     } catch {
     }
@@ -100808,10 +100808,10 @@ function getOrCreateSandbox(context3, timeoutMs) {
   }
   return sandbox;
 }
-async function executeInDocker(command2, context3, timeoutMs) {
+async function executeInDocker(command3, context3, timeoutMs) {
   const sandbox = getOrCreateSandbox(context3, timeoutMs);
   try {
-    const result = await sandbox.execute("/bin/sh", ["-c", command2]);
+    const result = await sandbox.execute("/bin/sh", ["-c", command3]);
     const output = [
       `Exit code: ${result.exitCode}`,
       result.timedOut ? " (timed out)" : "",
@@ -100834,8 +100834,8 @@ ${result.stderr.slice(0, 1e4)}` : ""
     };
   }
 }
-function executeOnHost(command2, workDir, timeoutMs, signal) {
-  if (DANGEROUS_METACHARACTERS.test(command2)) {
+function executeOnHost(command3, workDir, timeoutMs, signal) {
+  if (DANGEROUS_METACHARACTERS.test(command3)) {
     return Promise.resolve({
       output: "Command rejected: contains dangerous shell metacharacters. Use the Docker sandbox for complex shell commands.",
       isError: true
@@ -100843,7 +100843,7 @@ function executeOnHost(command2, workDir, timeoutMs, signal) {
   }
   const isWin = process.platform === "win32";
   const shellCmd = isWin ? "cmd" : "/bin/sh";
-  const shellArgs = isWin ? ["/c", command2] : ["-c", command2];
+  const shellArgs = isWin ? ["/c", command3] : ["-c", command3];
   return new Promise((resolvePromise) => {
     const child = execFile6(shellCmd, shellArgs, {
       cwd: workDir,
@@ -100888,10 +100888,10 @@ ${stderr.slice(0, 1e4)}` : ""
     }
   });
 }
-async function executeViaSSH(command2, sshConfig, opts) {
+async function executeViaSSH(command3, sshConfig, opts) {
   const executor = new SSHExecutor(sshConfig);
   try {
-    const result = await executor.execute(command2, {
+    const result = await executor.execute(command3, {
       cwd: opts?.cwd,
       timeout: opts?.timeout
     });
@@ -100910,10 +100910,10 @@ ${result.stderr.slice(0, 1e4)}` : ""
     return { output: `SSH execution error: ${message}`, isError: true };
   }
 }
-async function executeViaK8s(command2, k8sConfig, opts) {
+async function executeViaK8s(command3, k8sConfig, opts) {
   const executor = new K8sExecutor(k8sConfig);
   try {
-    const result = await executor.execute(command2, { timeout: opts?.timeout });
+    const result = await executor.execute(command3, { timeout: opts?.timeout });
     const output = [
       `[K8s \u2192 ${k8sConfig.namespace ?? "nestor"}] Exit code: ${result.exitCode}`,
       result.stdout ? `
@@ -100930,19 +100930,19 @@ ${result.stderr.slice(0, 1e4)}` : ""
   }
 }
 async function shellExecHandler(input, context3) {
-  const { command: command2, cwd, timeout: timeout2 } = input;
+  const { command: command3, cwd, timeout: timeout2 } = input;
   const workDir = cwd ? resolve9(context3.workingDir, cwd) : context3.workingDir;
   const timeoutMs = timeout2 ?? 3e4;
   const execBackend = context3.executionBackend ?? "local";
   if (execBackend === "ssh" && context3.sshConfig) {
-    return executeViaSSH(command2, context3.sshConfig, { cwd: workDir, timeout: timeoutMs });
+    return executeViaSSH(command3, context3.sshConfig, { cwd: workDir, timeout: timeoutMs });
   }
   if (execBackend === "k8s" && context3.k8sConfig) {
-    return executeViaK8s(command2, context3.k8sConfig, { timeout: timeoutMs });
+    return executeViaK8s(command3, context3.k8sConfig, { timeout: timeoutMs });
   }
   if (context3.sandboxManager) {
     try {
-      const result = await context3.sandboxManager.execute(command2, {
+      const result = await context3.sandboxManager.execute(command3, {
         cwd: workDir,
         timeoutMs,
         signal: context3.signal
@@ -100964,7 +100964,7 @@ ${result.stderr.slice(0, 1e4)}` : ""
   }
   const sandboxMode = context3.sandbox?.mode ?? "none";
   if (sandboxMode === "docker") {
-    return executeInDocker(command2, context3, timeoutMs);
+    return executeInDocker(command3, context3, timeoutMs);
   }
   if (sandboxMode === "namespace" || sandboxMode === "wasm") {
     try {
@@ -100972,12 +100972,12 @@ ${result.stderr.slice(0, 1e4)}` : ""
       const dockerAvailable = await probe.isAvailable();
       await probe.destroy();
       if (dockerAvailable) {
-        return executeInDocker(command2, context3, timeoutMs);
+        return executeInDocker(command3, context3, timeoutMs);
       }
     } catch {
     }
   }
-  return executeOnHost(command2, workDir, timeoutMs, context3.signal);
+  return executeOnHost(command3, workDir, timeoutMs, context3.signal);
 }
 async function fileReadHandler(input, context3) {
   const { path: filePath, encoding, maxBytes } = input;
@@ -101360,12 +101360,12 @@ var init_builtin = __esm({
 });
 
 // ../agent/dist/dry-run/planner.js
-function assessCommandRisk(command2) {
-  if (CRITICAL_PATTERNS.test(command2))
+function assessCommandRisk(command3) {
+  if (CRITICAL_PATTERNS.test(command3))
     return "critical";
-  if (HIGH_PATTERNS.test(command2))
+  if (HIGH_PATTERNS.test(command3))
     return "high";
-  if (MEDIUM_PATTERNS.test(command2))
+  if (MEDIUM_PATTERNS.test(command3))
     return "medium";
   return "low";
 }
@@ -110753,16 +110753,16 @@ var init_guardrail_service = __esm({
       matchCommandPattern(pattern, toolName, args2) {
         if (toolName !== "shell_exec")
           return null;
-        const command2 = String(args2.command || args2.cmd || "");
-        if (!command2)
+        const command3 = String(args2.command || args2.cmd || "");
+        if (!command3)
           return null;
         try {
           const regex = new RegExp(pattern, "i");
-          if (regex.test(command2)) {
+          if (regex.test(command3)) {
             return `Command matches guardrail pattern: ${pattern}`;
           }
         } catch {
-          if (command2.toLowerCase().includes(pattern.toLowerCase())) {
+          if (command3.toLowerCase().includes(pattern.toLowerCase())) {
             return `Command matches guardrail pattern: ${pattern}`;
           }
         }
@@ -118699,12 +118699,12 @@ var require_getMachineId_win = __commonJS({
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const args2 = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid";
-      let command2 = "%windir%\\System32\\REG.exe";
+      let command3 = "%windir%\\System32\\REG.exe";
       if (process3.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process3.env) {
-        command2 = "%windir%\\sysnative\\cmd.exe /c " + command2;
+        command3 = "%windir%\\sysnative\\cmd.exe /c " + command3;
       }
       try {
-        const result = await (0, execAsync_1.execAsync)(`${command2} ${args2}`);
+        const result = await (0, execAsync_1.execAsync)(`${command3} ${args2}`);
         const parts = result.stdout.split("REG_SZ");
         if (parts.length === 2) {
           return parts[1].trim();
@@ -127260,12 +127260,12 @@ var require_getMachineId_win2 = __commonJS({
     var api_1 = (init_esm2(), __toCommonJS(esm_exports));
     async function getMachineId() {
       const args2 = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid";
-      let command2 = "%windir%\\System32\\REG.exe";
+      let command3 = "%windir%\\System32\\REG.exe";
       if (process3.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process3.env) {
-        command2 = "%windir%\\sysnative\\cmd.exe /c " + command2;
+        command3 = "%windir%\\sysnative\\cmd.exe /c " + command3;
       }
       try {
-        const result = await (0, execAsync_1.execAsync)(`${command2} ${args2}`);
+        const result = await (0, execAsync_1.execAsync)(`${command3} ${args2}`);
         const parts = result.stdout.split("REG_SZ");
         if (parts.length === 2) {
           return parts[1].trim();
@@ -142894,6 +142894,7 @@ var init_knowledge2 = __esm({
 // ../server/dist/app.js
 import express, {} from "express";
 import { resolve as resolve12, join as join16 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
 import compression from "compression";
 import cors from "cors";
 function getStudioState() {
@@ -143091,11 +143092,20 @@ function createApp(config2) {
     });
   });
   let studioDistDir = null;
+  const candidateDirs = [];
   if (config2.studioDir) {
-    studioDistDir = config2.studioDir;
-  } else {
+    candidateDirs.push(config2.studioDir);
+  }
+  try {
+    candidateDirs.push(resolve12(__dirname, "../../ui/dist"));
+  } catch {
+  }
+  for (const dir of candidateDirs) {
     try {
-      studioDistDir = resolve12(__dirname, "../../ui/dist");
+      if (existsSync11(join16(dir, "index.html"))) {
+        studioDistDir = dir;
+        break;
+      }
     } catch {
     }
   }
@@ -143125,6 +143135,23 @@ function createApp(config2) {
       }
       res.sendFile(join16(studioDistDir, "index.html"));
     });
+  } else {
+    app.get("/studio", (_req, res) => {
+      res.status(404).json({
+        error: {
+          code: "STUDIO_NOT_FOUND",
+          message: "Studio UI files not found. Rebuild with: cd packages/ui && npm run build, then restart the server."
+        }
+      });
+    });
+    app.get("/studio/*", (_req, res) => {
+      res.status(404).json({
+        error: {
+          code: "STUDIO_NOT_FOUND",
+          message: "Studio UI files not found. Rebuild with: cd packages/ui && npm run build, then restart the server."
+        }
+      });
+    });
   }
   app.use(errorHandler());
   return app;
@@ -143193,7 +143220,7 @@ var init_app = __esm({
 });
 
 // ../server/dist/services/config-watcher.js
-import { watch, existsSync as existsSync11 } from "node:fs";
+import { watch, existsSync as existsSync12 } from "node:fs";
 import { readFile as readFile2 } from "node:fs/promises";
 var ConfigWatcher;
 var init_config_watcher = __esm({
@@ -143218,7 +143245,7 @@ var init_config_watcher = __esm({
        */
       async start() {
         await this.reload();
-        if (existsSync11(this.configPath)) {
+        if (existsSync12(this.configPath)) {
           this.watcher = watch(this.configPath, { persistent: false }, (eventType) => {
             if (eventType === "change") {
               if (this.debounceTimer)
@@ -143255,7 +143282,7 @@ var init_config_watcher = __esm({
       // ─── Internal ───────────────────────────────────────────────────────
       async reload() {
         try {
-          if (!existsSync11(this.configPath)) {
+          if (!existsSync12(this.configPath)) {
             console.warn("[config-watcher] Config file not found, keeping current config.");
             return;
           }
@@ -143299,7 +143326,7 @@ __export(telemetry_exports, {
   resetTelemetry: () => resetTelemetry
 });
 import { randomUUID as randomUUID33 } from "node:crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync8, appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync8, appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "node:fs";
 import { join as join17, dirname as dirname8 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function getTelemetry(config2) {
@@ -143413,7 +143440,7 @@ var init_telemetry2 = __esm({
       // ─── Private ─────────────────────────────────────────────────────────
       getOrCreateInstallId() {
         try {
-          if (existsSync12(TELEMETRY_ID_FILE)) {
+          if (existsSync13(TELEMETRY_ID_FILE)) {
             const id = readFileSync15(TELEMETRY_ID_FILE, "utf-8").trim();
             if (id.length > 0)
               return id;
@@ -143429,7 +143456,7 @@ var init_telemetry2 = __esm({
         return newId;
       }
       ensureDataDir() {
-        if (!existsSync12(DATA_DIR3)) {
+        if (!existsSync13(DATA_DIR3)) {
           mkdirSync6(DATA_DIR3, { recursive: true });
         }
       }
@@ -155229,7 +155256,7 @@ var init_yaml_loader = __esm({
 });
 
 // ../skill-tester/dist/runner.js
-import { readFileSync as readFileSync17, readdirSync as readdirSync4, statSync as statSync5, existsSync as existsSync14, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, rmSync as rmSync2 } from "node:fs";
+import { readFileSync as readFileSync17, readdirSync as readdirSync4, statSync as statSync5, existsSync as existsSync15, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, rmSync as rmSync2 } from "node:fs";
 import { join as join19, resolve as resolve13, extname as extname4 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 import { randomUUID as randomUUID35 } from "node:crypto";
@@ -155314,7 +155341,7 @@ var init_runner2 = __esm({
             const tools = new agentModule.ToolRegistry();
             const toolExecutor = new agentModule.ToolExecutor();
             let instructions = "You are a helpful AI assistant.";
-            if (test.skill && existsSync14(test.skill)) {
+            if (test.skill && existsSync15(test.skill)) {
               instructions = readFileSync17(test.skill, "utf-8");
             } else if (test.skill) {
               const skillPaths = [
@@ -155323,7 +155350,7 @@ var init_runner2 = __esm({
                 join19(process.cwd(), "skills-registry", test.skill, "SKILL.md")
               ];
               for (const p8 of skillPaths) {
-                if (existsSync14(p8)) {
+                if (existsSync15(p8)) {
                   instructions = readFileSync17(p8, "utf-8");
                   break;
                 }
@@ -155533,7 +155560,7 @@ var init_runner2 = __esm({
       discoverTestFiles(dir) {
         const files = [];
         const resolvedDir = resolve13(dir);
-        if (!existsSync14(resolvedDir))
+        if (!existsSync15(resolvedDir))
           return files;
         const stat = statSync5(resolvedDir);
         if (!stat.isDirectory()) {
@@ -156830,7 +156857,7 @@ when the agent determines it needs the capabilities described above.
                 type: "text",
                 text: JSON.stringify({
                   skillMd,
-                  instructions: "Save this content as SKILL.md in a directory, then install with nestor_install_skill or `nestor skill install <path>`."
+                  instructions: "Save this content as SKILL.md in a directory, then install with nestor_install_skill or `npx nestor-sh skill install <path>`."
                 }, null, 2)
               }
             ]
@@ -157576,7 +157603,7 @@ __export(shell_exports, {
   registerShellCommand: () => registerShellCommand
 });
 import * as readline3 from "node:readline";
-import { existsSync as existsSync15, readFileSync as readFileSync18, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, appendFileSync as appendFileSync3 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync18, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, appendFileSync as appendFileSync3 } from "node:fs";
 import { join as join20, resolve as resolve14, dirname as dirname9, basename as basename4 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { readdirSync as readdirSync5 } from "node:fs";
@@ -157610,7 +157637,7 @@ async function startShell() {
     currentRouter: null,
     verbose: false
   };
-  if (!existsSync15(NESTOR_DIR)) {
+  if (!existsSync16(NESTOR_DIR)) {
     mkdirSync9(NESTOR_DIR, { recursive: true });
   }
   refreshAgentNameCache(session);
@@ -158042,7 +158069,7 @@ async function cmdListSkills() {
   try {
     const skills = store.listSkills();
     if (skills.length === 0) {
-      console.log(chalk11.yellow("No skills installed. Use `nestor skill install` to add one."));
+      console.log(chalk11.yellow("No skills installed. Use `npx nestor-sh skill install` to add one."));
       return;
     }
     const headers = ["Name", "Version", "Author", "Trust"];
@@ -158059,7 +158086,7 @@ async function cmdListWorkflows() {
   try {
     const workflows = store.listWorkflows();
     if (workflows.length === 0) {
-      console.log(chalk11.yellow("No workflows defined. Use `nestor workflow create` to add one."));
+      console.log(chalk11.yellow("No workflows defined. Use `npx nestor-sh workflow create` to add one."));
       return;
     }
     const headers = ["Name", "Version", "Created"];
@@ -158075,7 +158102,7 @@ function cmdShowConfig() {
   const config2 = readConfigFile();
   if (!config2) {
     console.log(chalk11.yellow("No configuration file found."));
-    console.log(chalk11.dim("Run `nestor install` to create one."));
+    console.log(chalk11.dim("Run `npx nestor-sh install` to create one."));
     return;
   }
   console.log("");
@@ -159343,7 +159370,7 @@ function refreshAgentNameCache(session) {
 }
 function loadHistory() {
   try {
-    if (existsSync15(HISTORY_FILE)) {
+    if (existsSync16(HISTORY_FILE)) {
       const raw = readFileSync18(HISTORY_FILE, "utf-8");
       return raw.split("\n").filter((l) => l.trim().length > 0).slice(-MAX_HISTORY);
     }
@@ -159355,7 +159382,7 @@ function saveHistory(rl) {
 }
 function appendToHistoryFile(line) {
   try {
-    if (!existsSync15(NESTOR_DIR)) {
+    if (!existsSync16(NESTOR_DIR)) {
       mkdirSync9(NESTOR_DIR, { recursive: true });
     }
     appendFileSync3(HISTORY_FILE, line + "\n", "utf-8");
@@ -159751,6 +159778,9 @@ var init_shell = __esm({
 
 // src/index.ts
 import { Command } from "commander";
+import { existsSync as existsSync20, readFileSync as readFileSync22 } from "node:fs";
+import { join as join23 } from "node:path";
+import { homedir as homedir8 } from "node:os";
 
 // src/commands/start.ts
 init_config2();
@@ -159811,9 +159841,27 @@ function registerStartCommand(program2) {
     try {
       const { createNestorServer: createNestorServer2 } = await Promise.resolve().then(() => (init_dist5(), dist_exports3));
       const __cli_dirname = path21.dirname(fileURLToPath4(import.meta.url));
-      const bundledStudio = path21.resolve(__cli_dirname, "studio");
-      const monorepoStudio = path21.resolve(__cli_dirname, "../../ui/dist");
-      const studioDir = fs20.existsSync(bundledStudio) ? bundledStudio : fs20.existsSync(monorepoStudio) ? monorepoStudio : void 0;
+      const studioCandidates = [
+        path21.resolve(__cli_dirname, "studio"),
+        // npm: dist/studio/
+        path21.resolve(__cli_dirname, "..", "studio"),
+        // npm: studio/ next to dist/
+        path21.resolve(__cli_dirname, "../../ui/dist"),
+        // monorepo dev mode
+        path21.resolve(__cli_dirname, "../../../packages/ui/dist")
+        // dev alt
+      ];
+      let studioDir;
+      for (const candidate of studioCandidates) {
+        if (fs20.existsSync(path21.join(candidate, "index.html"))) {
+          studioDir = candidate;
+          break;
+        }
+      }
+      if (studioEnabled && !studioDir) {
+        console.log(chalk.yellow("  [warn]"), "Studio UI files not found \u2014 /studio will not be available");
+        console.log(chalk.dim(`         Searched: ${studioCandidates[0]}`));
+      }
       serverHandle = createNestorServer2({
         host,
         port,
@@ -159876,12 +159924,24 @@ init_config();
 init_config2();
 import * as p from "@clack/prompts";
 import chalk2 from "chalk";
-import { mkdirSync as mkdirSync7, existsSync as existsSync13 } from "node:fs";
+import { mkdirSync as mkdirSync7, existsSync as existsSync14 } from "node:fs";
 import { join as join18 } from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 function generateApiKey() {
   return `nst_${randomBytes6(32).toString("hex")}`;
 }
+function randomSegment() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let result = "";
+  const bytes = randomBytes6(4);
+  for (let i = 0; i < 4; i++) {
+    result += chars[bytes[i] % chars.length];
+  }
+  return result;
+}
+function generateBetaKey() {
+  return `NESTOR-BETA-${randomSegment()}-${randomSegment()}-${randomSegment()}`;
+}
 async function initializeDatabase(dataDir) {
   const { NestorStore: NestorStore2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
   const dbPath = join18(dataDir, "nestor.db");
@@ -159932,13 +159992,13 @@ async function runNonInteractiveInstall() {
   console.log();
   const config2 = buildConfigFromDefaults();
   const dataDir = expandPath(config2.server.dataDir);
-  if (!existsSync13(dataDir)) {
+  if (!existsSync14(dataDir)) {
     mkdirSync7(dataDir, { recursive: true });
     console.log(chalk2.green("  Created data directory:"), dataDir);
   }
   for (const sub of ["adapters", "skills", "plugins", "logs"]) {
     const subDir = join18(dataDir, sub);
-    if (!existsSync13(subDir)) {
+    if (!existsSync14(subDir)) {
       mkdirSync7(subDir, { recursive: true });
     }
   }
@@ -159955,12 +160015,15 @@ async function runNonInteractiveInstall() {
   const { writeFileSync: writeFileSync13 } = await import("node:fs");
   writeFileSync13(apiKeyPath, JSON.stringify({ admin: apiKey }, null, 2) + "\n", "utf-8");
   console.log(chalk2.green("  Admin API key created"));
+  const betaKey = generateBetaKey();
+  writeFileSync13(join18(dataDir, "license.key"), betaKey, "utf-8");
+  console.log(chalk2.green("  Beta key created"));
   console.log();
   console.log(chalk2.bold("Admin API Key:"), chalk2.yellow(apiKey));
+  console.log(chalk2.bold("Beta key:"), chalk2.yellow(betaKey));
   console.log(chalk2.dim("  Save this key \u2014 it won't be shown again."));
   console.log();
-  console.log(chalk2.green("Setup complete! Start Nestor with:"));
-  console.log(chalk2.cyan("  npx nestor-sh start"));
+  console.log(chalk2.green("Nestor is ready! Run: ") + chalk2.cyan("npx nestor-sh start"));
 }
 async function runInteractiveInstall() {
   p.intro(chalk2.bgCyan(" Nestor Setup Wizard "));
@@ -160050,7 +160113,7 @@ async function runInteractiveInstall() {
   const spinner3 = p.spinner();
   spinner3.start("Creating directories...");
   for (const dir of [dataDir, join18(dataDir, "adapters"), join18(dataDir, "skills"), join18(dataDir, "plugins"), join18(dataDir, "logs")]) {
-    if (!existsSync13(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync7(dir, { recursive: true });
     }
   }
@@ -160080,11 +160143,17 @@ async function runInteractiveInstall() {
   const { writeFileSync: writeFileSync13 } = await import("node:fs");
   writeFileSync13(apiKeyPath, JSON.stringify({ admin: apiKey }, null, 2) + "\n", "utf-8");
   spinner4.stop("Admin API key created!");
+  const spinner5 = p.spinner();
+  spinner5.start("Generating beta key...");
+  const betaKey = generateBetaKey();
+  writeFileSync13(join18(dataDir, "license.key"), betaKey, "utf-8");
+  spinner5.stop("Beta key created!");
   p.note(
     `Config file:     ${getConfigPath()}
 Data directory:  ${dataDir}
 API port:        ${config2.server.port}
 Admin API key:   ${apiKey}
+Beta key:        ${betaKey}
 
 ${chalk2.dim("Save this key \u2014 it won't be shown again.")}`,
     "Setup complete"
@@ -160188,7 +160257,7 @@ function registerAgentCommand(program2) {
       const agents = store.listAgents();
       if (agents.length === 0) {
         console.log(chalk3.yellow("No agents registered yet."));
-        console.log(chalk3.dim("Use `nestor agent create` to add an agent."));
+        console.log(chalk3.dim("Use `npx nestor-sh agent create` to add an agent."));
         return;
       }
       if (options.json) {
@@ -160360,7 +160429,7 @@ function registerSkillCommand(program2) {
       const skills = store.listSkills();
       if (skills.length === 0) {
         console.log(chalk4.yellow("No skills installed yet."));
-        console.log(chalk4.dim("Use `nestor skill install <source>` to add a skill."));
+        console.log(chalk4.dim("Use `npx nestor-sh skill install <source>` to add a skill."));
         return;
       }
       if (options.json) {
@@ -160932,7 +161001,7 @@ function registerWorkflowCommand(program2) {
       const workflows = store.listWorkflows();
       if (workflows.length === 0) {
         console.log(chalk5.yellow("No workflows created yet."));
-        console.log(chalk5.dim("Use `nestor workflow create` to add a workflow."));
+        console.log(chalk5.dim("Use `npx nestor-sh workflow create` to add a workflow."));
         return;
       }
       if (options.json) {
@@ -160988,7 +161057,7 @@ function registerWorkflowCommand(program2) {
       };
       store.createRun(run);
       console.log(chalk5.green(`Workflow '${name}' started (run: ${runId})`));
-      console.log(chalk5.dim("Track progress with: nestor workflow status " + runId));
+      console.log(chalk5.dim("Track progress with: npx nestor-sh workflow status " + runId));
     } finally {
       store.close();
     }
@@ -161149,7 +161218,7 @@ function registerConfigCommand(program2) {
     const cfg = readConfigFile();
     if (!cfg) {
       console.log(chalk6.yellow("No configuration found."));
-      console.log(chalk6.dim("Run `nestor install` or `nestor config init` to create one."));
+      console.log(chalk6.dim("Run `npx nestor-sh install` or `npx nestor-sh config init` to create one."));
       return;
     }
     if (options.json) {
@@ -161198,7 +161267,7 @@ function registerConfigCommand(program2) {
   config2.command("set <key> <value>").description("Set a configuration value (dot notation, e.g., security.sandboxMode none)").action((key, value) => {
     const configPath = getConfigPath();
     if (!fs24.existsSync(configPath)) {
-      console.error(chalk6.red("No config file found. Run `nestor config init` first."));
+      console.error(chalk6.red("No config file found. Run `npx nestor-sh config init` first."));
       process.exit(1);
     }
     try {
@@ -161295,7 +161364,7 @@ function registerDoctorCommand(program2) {
           });
         }
       } else {
-        checks.push({ name: "SQLite database", status: "warn", message: "Database not created yet (run nestor start)" });
+        checks.push({ name: "SQLite database", status: "warn", message: "Database not created yet (run npx nestor-sh start)" });
       }
     } else {
       checks.push({ name: "SQLite database", status: "warn", message: "No config to check" });
@@ -161370,7 +161439,7 @@ init_db();
 init_spinner();
 init_table();
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   readFileSync as readFileSync19,
   writeFileSync as writeFileSync11,
   mkdirSync as mkdirSync10,
@@ -161411,7 +161480,7 @@ async function startForeground() {
   const existingPid = readPid();
   if (existingPid && isProcessAlive(existingPid)) {
     console.log(chalk12.yellow(`Daemon is already running (PID: ${existingPid}).`));
-    console.log(chalk12.dim("Use `nestor daemon stop` to stop it first."));
+    console.log(chalk12.dim("Use `npx nestor-sh daemon stop` to stop it first."));
     return;
   }
   ensureDirs();
@@ -161443,7 +161512,7 @@ async function startDetached() {
   const existingPid = readPid();
   if (existingPid && isProcessAlive(existingPid)) {
     console.log(chalk12.yellow(`Daemon is already running (PID: ${existingPid}).`));
-    console.log(chalk12.dim("Use `nestor daemon stop` to stop it first."));
+    console.log(chalk12.dim("Use `npx nestor-sh daemon stop` to stop it first."));
     return;
   }
   ensureDirs();
@@ -161459,7 +161528,7 @@ async function startDetached() {
     writePid(child.pid);
     console.log(chalk12.green(`Daemon started in background (PID: ${child.pid}).`));
     console.log(chalk12.dim(`  Logs: ${LOG_FILE}`));
-    console.log(chalk12.dim(`  Stop: nestor daemon stop`));
+    console.log(chalk12.dim(`  Stop: npx nestor-sh daemon stop`));
   } else {
     console.error(chalk12.red("Failed to start daemon process."));
     process.exit(1);
@@ -161554,7 +161623,7 @@ async function showStatus() {
   console.log("");
 }
 async function showLogs(follow, lineCount) {
-  if (!existsSync16(LOG_FILE)) {
+  if (!existsSync17(LOG_FILE)) {
     console.log(chalk12.yellow("No daemon log file found."));
     console.log(chalk12.dim(`Expected at: ${LOG_FILE}`));
     return;
@@ -161574,7 +161643,7 @@ async function showLogs(follow, lineCount) {
   }
   console.log(chalk12.dim(`Following ${LOG_FILE}... (Ctrl+C to stop)`));
   console.log("");
-  if (existsSync16(LOG_FILE)) {
+  if (existsSync17(LOG_FILE)) {
     const content = readFileSync19(LOG_FILE, "utf-8");
     const lines = content.split("\n").filter((l) => l.length > 0);
     const lastLines = lines.slice(-10);
@@ -161582,10 +161651,10 @@ async function showLogs(follow, lineCount) {
       console.log(colorizeLogLine(line));
     }
   }
-  let lastSize = existsSync16(LOG_FILE) ? readFileSync19(LOG_FILE).length : 0;
+  let lastSize = existsSync17(LOG_FILE) ? readFileSync19(LOG_FILE).length : 0;
   const watcher = setInterval(() => {
     try {
-      if (!existsSync16(LOG_FILE)) return;
+      if (!existsSync17(LOG_FILE)) return;
       const content = readFileSync19(LOG_FILE, "utf-8");
       if (content.length > lastSize) {
         const newContent = content.substring(lastSize);
@@ -161914,7 +161983,7 @@ async function importDaemonAgentModule() {
 }
 function readHeartbeat() {
   try {
-    if (existsSync16(HEARTBEAT_FILE)) {
+    if (existsSync17(HEARTBEAT_FILE)) {
       const raw = readFileSync19(HEARTBEAT_FILE, "utf-8");
       return JSON.parse(raw);
     }
@@ -161924,7 +161993,7 @@ function readHeartbeat() {
 }
 function readPid() {
   try {
-    if (existsSync16(PID_FILE)) {
+    if (existsSync17(PID_FILE)) {
       const raw = readFileSync19(PID_FILE, "utf-8").trim();
       const pid = parseInt(raw, 10);
       return isNaN(pid) ? null : pid;
@@ -161939,7 +162008,7 @@ function writePid(pid) {
 }
 function cleanupPid() {
   try {
-    if (existsSync16(PID_FILE)) {
+    if (existsSync17(PID_FILE)) {
       unlinkSync(PID_FILE);
     }
   } catch {
@@ -161979,10 +162048,10 @@ function colorizeLogLine(line) {
   return line;
 }
 function ensureDirs() {
-  if (!existsSync16(NESTOR_DIR2)) {
+  if (!existsSync17(NESTOR_DIR2)) {
     mkdirSync10(NESTOR_DIR2, { recursive: true });
   }
-  if (!existsSync16(LOG_DIR)) {
+  if (!existsSync17(LOG_DIR)) {
     mkdirSync10(LOG_DIR, { recursive: true });
   }
 }
@@ -162024,7 +162093,7 @@ if (process.argv[2] === "__daemon_child__" || process.env.NESTOR_DAEMON_MODE ===
 
 // src/commands/watch.ts
 init_db();
-import { existsSync as existsSync17, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync20 } from "node:fs";
 import { join as join22 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 import chalk13 from "chalk";
@@ -162098,7 +162167,7 @@ async function refreshData(state) {
   } catch {
   }
   try {
-    if (existsSync17(HEARTBEAT_FILE2)) {
+    if (existsSync18(HEARTBEAT_FILE2)) {
       const raw = readFileSync20(HEARTBEAT_FILE2, "utf-8");
       const heartbeat = JSON.parse(raw);
       state.daemonRunning = isDaemonAlive(heartbeat.pid);
@@ -162116,7 +162185,7 @@ async function refreshData(state) {
 }
 function loadRecentEvents(state) {
   try {
-    if (!existsSync17(LOG_FILE2)) return;
+    if (!existsSync18(LOG_FILE2)) return;
     const content = readFileSync20(LOG_FILE2, "utf-8");
     const lines = content.split("\n").filter((l) => l.length > 0);
     const recent = lines.slice(-MAX_EVENTS);
@@ -162369,7 +162438,7 @@ function registerStudioCommand(program2) {
       const data = apiResult.data?.data;
       if (data && !data.enabled) {
         console.log(chalk14.yellow("  Studio is currently disabled on the running server."));
-        console.log(chalk14.dim("  Use `nestor studio enable` to enable it first."));
+        console.log(chalk14.dim("  Use `npx nestor-sh studio enable` to enable it first."));
         return;
       }
     }
@@ -162417,7 +162486,7 @@ function registerTelemetryCommand(program2) {
     console.log(chalk15.dim("  What we NEVER collect:"));
     console.log(chalk15.dim("    - API keys, file contents, prompts, personal data"));
     console.log("");
-    console.log(chalk15.dim("  Run `nestor telemetry off` to disable at any time."));
+    console.log(chalk15.dim("  Run `npx nestor-sh telemetry off` to disable at any time."));
     console.log("");
   });
   telemetry.command("off").description("Disable anonymous telemetry").action(() => {
@@ -162434,7 +162503,7 @@ function registerTelemetryCommand(program2) {
     console.log(chalk15.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
     if (!config2) {
       console.log(`  ${chalk15.dim("Enabled:")}   ${chalk15.yellow("unknown")} (no config file)`);
-      console.log(chalk15.dim("  Run `nestor config init` to create a configuration."));
+      console.log(chalk15.dim("  Run `npx nestor-sh config init` to create a configuration."));
     } else {
       const enabled = config2.telemetry?.enabled ?? false;
       console.log(`  ${chalk15.dim("Enabled:")}   ${enabled ? chalk15.green("true") : chalk15.dim("false (default)")}`);
@@ -162443,10 +162512,10 @@ function registerTelemetryCommand(program2) {
       }
       console.log(`  ${chalk15.dim("Flush:")}     every ${(config2.telemetry?.flushIntervalMs ?? 6e4) / 1e3}s`);
     }
-    const { join: join23 } = __require("node:path");
-    const { homedir: homedir8 } = __require("node:os");
-    const telemetryFile = join23(homedir8(), ".nestor", "telemetry.jsonl");
-    const idFile = join23(homedir8(), ".nestor", "telemetry-id");
+    const { join: join24 } = __require("node:path");
+    const { homedir: homedir9 } = __require("node:os");
+    const telemetryFile = join24(homedir9(), ".nestor", "telemetry.jsonl");
+    const idFile = join24(homedir9(), ".nestor", "telemetry-id");
     if (fs28.existsSync(idFile)) {
       const installId = fs28.readFileSync(idFile, "utf-8").trim();
       console.log(`  ${chalk15.dim("Install ID:")} ${installId.slice(0, 8)}...`);
@@ -162796,7 +162865,7 @@ async function cmdSandboxTest() {
       sshSpinner.fail(`SSH connection failed: ${sshResult.error}`);
     }
   } else {
-    console.log(chalk17.dim("  SSH: not configured (use `nestor sandbox ssh <host>`)"));
+    console.log(chalk17.dim("  SSH: not configured (use `npx nestor-sh sandbox ssh <host>`)"));
   }
   console.log(chalk17.green("\u2714") + " Local execution: always available");
   console.log("");
@@ -162805,7 +162874,7 @@ async function cmdSandboxTest() {
     console.log(chalk17.dim('Consider switching to "none" or "auto" in your config.'));
   } else if (sandboxMode === "ssh" && !sshConfig) {
     console.log(chalk17.yellow('Warning: Sandbox mode is "ssh" but no SSH config found.'));
-    console.log(chalk17.dim("Run `nestor sandbox ssh <host>` to configure."));
+    console.log(chalk17.dim("Run `npx nestor-sh sandbox ssh <host>` to configure."));
   } else {
     console.log(chalk17.green("Sandbox configuration looks good."));
   }
@@ -162842,7 +162911,7 @@ async function cmdSandboxSSH(host, opts) {
     testSpinner.succeed("SSH connection successful");
   } else {
     testSpinner.fail(`SSH connection failed: ${result.error}`);
-    console.log(chalk17.yellow("Configuration saved anyway. Fix the connection issue and run `nestor sandbox test`."));
+    console.log(chalk17.yellow("Configuration saved anyway. Fix the connection issue and run `npx nestor-sh sandbox test`."));
   }
   try {
     const config2 = readConfigFile() ?? {};
@@ -163154,7 +163223,7 @@ function registerRagCommand(program2) {
         filePath: opts.file
       });
       if (results.length === 0) {
-        console.log(chalk19.yellow("No results found. Try indexing first: nestor rag index"));
+        console.log(chalk19.yellow("No results found. Try indexing first: npx nestor-sh rag index"));
         return;
       }
       console.log(chalk19.bold(`
@@ -163218,7 +163287,7 @@ ${results.length} results for "${query}":
 
 // src/commands/test.ts
 import { resolve as resolve16, relative as relative5 } from "node:path";
-import { readdirSync as readdirSync6, statSync as statSync6, existsSync as existsSync18 } from "node:fs";
+import { readdirSync as readdirSync6, statSync as statSync6, existsSync as existsSync19 } from "node:fs";
 import chalk20 from "chalk";
 var TEST_FILE_PATTERNS = [
   ".nestor-test.yaml",
@@ -163231,7 +163300,7 @@ function registerTestCommand(program2) {
   program2.command("test [path]").description("Run skill and agent test suites").option("-l, --list", "List discovered test files", false).option("-f, --file <file>", "Run a specific test file").option("-r, --record <file>", "Record LLM responses to a fixture file").option("-p, --prompt <prompt>", "Prompt for recording mode").option("-v, --verbose", "Show detailed test output", false).option("-j, --json", "Output results as JSON (for CI)", false).action(async (path30, opts) => {
     if (opts.file) {
       const filePath = resolve16(opts.file);
-      if (!existsSync18(filePath)) {
+      if (!existsSync19(filePath)) {
         console.error(chalk20.red(`File not found: ${opts.file}`));
         process.exit(1);
       }
@@ -163262,7 +163331,7 @@ function registerTestCommand(program2) {
     ];
     const allFiles = [];
     for (const testDir of defaultTestDirs) {
-      if (existsSync18(testDir)) {
+      if (existsSync19(testDir)) {
         allFiles.push(...discoverTestFiles(testDir));
       }
     }
@@ -163305,7 +163374,7 @@ function discoverTestFiles(dir) {
       }
     }
   }
-  if (existsSync18(dir) && !statSync6(dir).isDirectory()) {
+  if (existsSync19(dir) && !statSync6(dir).isDirectory()) {
     return [dir];
   }
   walk(dir);
@@ -163314,7 +163383,7 @@ function discoverTestFiles(dir) {
 async function listTestFiles(dir) {
   const files = discoverTestFiles(dir);
   const nestorTestDir = resolve16(dir, ".nestor", "tests");
-  if (existsSync18(nestorTestDir)) {
+  if (existsSync19(nestorTestDir)) {
     files.push(...discoverTestFiles(nestorTestDir));
   }
   const unique = [...new Set(files)];
@@ -163370,7 +163439,7 @@ async function runSkillTestsByName(skillName, verbose, json) {
   ];
   const matchingFiles = [];
   for (const dir of searchDirs) {
-    if (!existsSync18(dir)) continue;
+    if (!existsSync19(dir)) continue;
     const files = discoverTestFiles(dir);
     for (const file of files) {
       if (file.includes(skillName)) {
@@ -163474,7 +163543,7 @@ function registerGuardrailCommand(program2) {
     const guardrails = store.listGuardrails();
     if (guardrails.length === 0) {
       console.log(chalk21.dim("No guardrails configured."));
-      console.log(chalk21.dim("Add one with: nestor guardrail add"));
+      console.log(chalk21.dim("Add one with: npx nestor-sh guardrail add"));
       return;
     }
     printTable(
@@ -163567,8 +163636,30 @@ function registerGuardrailCommand(program2) {
 }
 
 // src/index.ts
+function checkBetaAccess() {
+  const licenseFile = join23(homedir8(), ".nestor", "license.key");
+  if (!existsSync20(licenseFile)) return false;
+  const key = readFileSync22(licenseFile, "utf-8").trim();
+  return /^NESTOR-BETA-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/.test(key);
+}
+var command2 = process.argv[2];
+if (command2 && !["--help", "-h", "--version", "-V", "install"].includes(command2)) {
+  if (!checkBetaAccess()) {
+    console.log(`
+  \u26A1 Nestor is currently in private beta.
+
+  Visit https://nestor.sh to request access.
+
+  If you have a beta key, save it to:
+    ~/.nestor/license.key
+
+  Then run: npx nestor-sh install
+`);
+    process.exit(0);
+  }
+}
 var program = new Command();
-program.name("nestor").description("Nestor AI Agent Platform \u2014 orchestrate, secure and monitor AI agents").version("0.1.0");
+program.name("nestor-sh").description("Nestor AI Agent Platform \u2014 orchestrate, secure and monitor AI agents").version("2.0.4");
 registerStartCommand(program);
 registerInstallCommand(program);
 registerAgentCommand(program);
@@ -163591,7 +163682,7 @@ registerGuardrailCommand(program);
 var args = process.argv.slice(2);
 if (args.length === 0) {
   Promise.resolve().then(() => (init_shell(), shell_exports)).then(({ registerShellCommand: _ }) => {
-    program.parse(["node", "nestor", "shell"]);
+    program.parse(["node", "nestor-sh", "shell"]);
   });
 } else {
   program.parse();