@vm0/cli 9.238.6 → 9.238.8

package/doctor-RGD5Z6QS.js

@@ -0,0 +1,1194 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  findFirewallMetadataPermission
+} from "./chunk-2QGSFMHS.js";
+import {
+  getPlatformOrigin,
+  toPlatformUrl
+} from "./chunk-RNODSGZS.js";
+import {
+  UNKNOWN_PERMISSION_GRANT,
+  createComputerUseAuthorizationRequest,
+  diagnoseZeroConnectorCheck,
+  diagnoseZeroConnectorPermissionDeny,
+  getZeroAgentUserConnectors,
+  getZeroBillingStatus,
+  getZeroConnector,
+  getZeroConnectorCatalogPermissions,
+  getZeroOrg,
+  getZeroOrgMembers,
+  hasUnsafeFirewallPath
+} from "./chunk-IXT6G7VE.js";
+import "./chunk-LTDQISD7.js";
+import {
+  ApiRequestError,
+  getApiUrl,
+  source_default,
+  withErrorHandler
+} from "./chunk-53PEJLO7.js";
+import "./chunk-LRHXR7JT.js";
+import {
+  Command,
+  Option
+} from "./chunk-B3W2RUBP.js";
+import {
+  init_esm_shims
+} from "./chunk-DIRAZ3YX.js";
+
+// src/commands/zero/doctor/index.ts
+init_esm_shims();
+
+// src/commands/zero/doctor/check-connector.ts
+init_esm_shims();
+function stripUrlQueryAndFragment(url) {
+  const queryIndex = url.indexOf("?");
+  const fragmentIndex = url.indexOf("#");
+  let end = url.length;
+  if (queryIndex !== -1) end = Math.min(end, queryIndex);
+  if (fragmentIndex !== -1) end = Math.min(end, fragmentIndex);
+  return url.slice(0, end);
+}
+function rawUrlAuthorityHasUserinfo(url) {
+  const schemeEnd = url.indexOf("://");
+  if (schemeEnd === -1) return false;
+  const authorityStart = schemeEnd + 3;
+  let authorityEnd = url.length;
+  for (const delimiter of ["/", "?", "#"]) {
+    const delimiterIndex = url.indexOf(delimiter, authorityStart);
+    if (delimiterIndex !== -1) {
+      authorityEnd = Math.min(authorityEnd, delimiterIndex);
+    }
+  }
+  return url.slice(authorityStart, authorityEnd).includes("@");
+}
+function shellQuoteArg(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function connectorSelectionCommand(url, method, connectorRef) {
+  const args = [
+    `--url ${shellQuoteArg(url)}`,
+    `--connector ${shellQuoteArg(connectorRef)}`
+  ];
+  if (method !== "GET") {
+    args.push(`--method ${shellQuoteArg(method)}`);
+  }
+  return `zero doctor check-connector ${args.join(" ")}`;
+}
+function validateCheckConnectorOptions(opts, command) {
+  const hasUrl = opts.url !== void 0;
+  if (opts.url !== void 0 && rawUrlAuthorityHasUserinfo(opts.url)) {
+    throw unsafeInputError("invalid-url");
+  }
+  if (opts.connector !== void 0 && !hasUrl) {
+    throw new Error(
+      "--connector can only be used with --url. Add --url <URL> or remove --connector."
+    );
+  }
+  if (opts.checkPermission !== void 0 && hasUrl) {
+    throw new Error(
+      "--check-permission cannot be used with --url because the permission is derived from the request. Remove --check-permission."
+    );
+  }
+  if (opts.checkPermission?.trim() === "") {
+    throw new Error("--check-permission requires a non-empty permission name.");
+  }
+  if (!hasUrl && command.getOptionValueSource("method") === "cli") {
+    throw new Error(
+      "--method can only be used with --url. Add --url <URL> or remove --method."
+    );
+  }
+  if (opts.envName === void 0 && !hasUrl) {
+    throw new Error(
+      "Either --env-name or --url is required. Use --help for usage."
+    );
+  }
+}
+function buildDiagnosticRequest(opts, method) {
+  if (opts.url !== void 0) {
+    return {
+      mode: "url",
+      method,
+      url: stripUrlQueryAndFragment(opts.url),
+      ...opts.connector !== void 0 ? { connectorRef: opts.connector } : {},
+      ...opts.envName !== void 0 ? { environmentName: opts.envName } : {}
+    };
+  }
+  return {
+    mode: "environment",
+    environmentName: opts.envName,
+    ...opts.checkPermission !== void 0 ? { permission: opts.checkPermission } : {}
+  };
+}
+function requireUrlRequest(request) {
+  if (request.mode !== "url") {
+    throw new Error(
+      "Connector diagnostic returned a URL-only outcome for an environment request."
+    );
+  }
+  return request;
+}
+function requestedEnvironmentName(request) {
+  if (request.environmentName === void 0) {
+    throw new Error(
+      "Connector diagnostic returned an environment outcome without an environment name."
+    );
+  }
+  return request.environmentName;
+}
+function unsafeInputError(reason) {
+  switch (reason) {
+    case "invalid-method":
+      return new Error(
+        "check-connector requires --method to be a supported HTTP method."
+      );
+    case "invalid-url":
+      return new Error(
+        "check-connector requires --url to be a valid absolute http or https URL."
+      );
+    case "unsafe-path":
+      return new Error(
+        "check-connector cannot diagnose unsafe URL paths because they are blocked before permission policy evaluation."
+      );
+  }
+}
+function ambiguousConnectorError(request, result) {
+  const candidates = [...result.candidates].sort((left, right) => {
+    return left.connectorRef.localeCompare(right.connectorRef);
+  });
+  const commands = candidates.map((candidate) => {
+    return `  ${connectorSelectionCommand(request.url, request.method, candidate.connectorRef)}`;
+  });
+  return new Error(
+    `Multiple connectors match ${request.method} ${request.url}: ${candidates.map((candidate) => {
+      return candidate.connectorRef;
+    }).join(", ")}
+Select one explicitly:
+${commands.join("\n")}`
+  );
+}
+function unknownConnectorError(request) {
+  if (request.mode === "url" && request.connectorRef !== void 0) {
+    return new Error(
+      `Unknown connector type: ${request.connectorRef}
+Run: zero connector search ${shellQuoteArg(request.connectorRef)}`
+    );
+  }
+  return new Error("The requested connector is unknown.");
+}
+function noMatchError(result) {
+  return new Error(
+    result.scope === "run" ? "No connector found for provided URL \u2014 no connector configured for the current run matches this URL" : "No connector found for provided URL \u2014 no registered connector base URL matches this URL"
+  );
+}
+function connectorMismatchError(request, result) {
+  const requestedRef = request.connectorRef ?? "the requested connector";
+  return new Error(
+    `Connector ${requestedRef} does not own ${request.method} ${request.url}; the matching connector is ${result.connector.connectorRef}
+Run: ${connectorSelectionCommand(request.url, request.method, result.connector.connectorRef)}`
+  );
+}
+function environmentNotOwnedError(request, result) {
+  const environmentName = requestedEnvironmentName(request);
+  return new Error(
+    `${environmentName} is not an environment name for the ${result.connector.label} connector. Remove --env-name to use the matched route metadata.`
+  );
+}
+function environmentNotUsedError(request, result) {
+  const environmentName = requestedEnvironmentName(request);
+  return new Error(
+    `${environmentName} is not used by the matched API route. Expected one of: ${result.environmentNames.join(", ") || "none"}. Remove --env-name to use the matched route metadata.`
+  );
+}
+function resolvedDiagnostic(request, result) {
+  switch (result.outcome) {
+    case "resolved":
+      return result;
+    case "unsafe-input":
+      throw unsafeInputError(result.reason);
+    case "unknown-connector":
+      throw unknownConnectorError(request);
+    case "unknown-environment":
+      throw new Error(
+        `Unknown environment name: ${requestedEnvironmentName(request)} \u2014 not managed by any connector`
+      );
+    case "no-match":
+      throw noMatchError(result);
+    case "ambiguous":
+      throw ambiguousConnectorError(requireUrlRequest(request), result);
+    case "connector-mismatch":
+      throw connectorMismatchError(requireUrlRequest(request), result);
+    case "environment-not-owned":
+      throw environmentNotOwnedError(request, result);
+    case "environment-not-used":
+      throw environmentNotUsedError(request, result);
+    case "unresolved-dynamic-base":
+      throw new Error(
+        `No authoritative ${result.connector.label} base URL is available for this diagnostic. Verify the ${result.connector.connectorRef} connector configuration for the affected context and retry.`
+      );
+    case "run-context-unavailable":
+      throw new Error(
+        "The current run context is unavailable for connector diagnosis. Retry from an active run or start a new run."
+      );
+  }
+}
+function printDiagnosticSummary(request, result) {
+  if (result.mode === "url") {
+    const urlRequest = requireUrlRequest(request);
+    console.log(
+      `URL ${urlRequest.url} matches the ${result.connector.label} connector (type: ${result.connector.connectorRef}).`
+    );
+    console.log(`  Matched base URL: ${result.base}`);
+    console.log(`  Relative path:    ${result.relativePath}`);
+    if (result.environmentNames === null) {
+      console.log("  Environment names: unavailable");
+    } else {
+      console.log(
+        `  Environment names: [${result.environmentNames.join(", ")}]`
+      );
+    }
+    return;
+  }
+  console.log(
+    `${result.environmentName} is managed by the ${result.connector.label} connector (type: ${result.connector.connectorRef}).`
+  );
+}
+function diagnosticEnvironmentNames(result) {
+  return result.mode === "url" ? result.environmentNames : [result.environmentName];
+}
+function printConnectorConnectionStatus(ctx, isConnected, isExpired, hasPermission) {
+  console.log(
+    "### 2a: Connector status (user must configure via OAuth login or API key)"
+  );
+  console.log("");
+  if (!ctx.connectorAvailable) {
+    console.log(
+      `The ${ctx.label} connector is not available for this account.`
+    );
+  } else if (!isConnected) {
+    console.log(`The ${ctx.label} connector is not connected.`);
+    if (ctx.agentId && hasPermission) {
+      const connectUrl = `${ctx.platformOrigin}/connectors/${ctx.connectorRef}/connect?agentId=${ctx.agentId}`;
+      console.log(`Connect it at: [Connect ${ctx.label}](${connectUrl})`);
+    } else if (!ctx.agentId) {
+      const connectUrl = `${ctx.platformOrigin}/connectors/${ctx.connectorRef}/connect`;
+      console.log(`Connect it at: [Connect ${ctx.label}](${connectUrl})`);
+    }
+  } else if (isExpired) {
+    const url = `${ctx.platformOrigin}/connectors`;
+    console.log(
+      `The ${ctx.label} connector is connected but has expired and needs to be reconnected.`
+    );
+    console.log(`Reconnect it at: [Reconnect ${ctx.label}](${url})`);
+  } else {
+    console.log(`The ${ctx.label} connector is connected and active.`);
+  }
+  console.log("");
+}
+function printAgentAuthorizationStatus(ctx, isConnected, isExpired, hasPermission) {
+  if (!ctx.agentId) {
+    console.log("ZERO_AGENT_ID is not set \u2014 cannot check agent authorization.");
+  } else if (isExpired) {
+    console.log(
+      `Skipped \u2014 agent authorization can only be checked once the ${ctx.label} connector is reconnected (see 2a).`
+    );
+  } else if (hasPermission) {
+    console.log(
+      isConnected ? `The ${ctx.label} connector is authorized for this agent.` : `The ${ctx.label} connector is authorized for this agent, but it is not connected.`
+    );
+  } else {
+    const url = `${ctx.platformOrigin}/connectors/${ctx.connectorRef}/authorize?agentId=${ctx.agentId}`;
+    console.log(
+      isConnected ? `The ${ctx.label} connector is not authorized for this agent (${ctx.agentId}).` : `The ${ctx.label} connector needs to be connected and authorized for this agent (${ctx.agentId}).`
+    );
+    console.log(`Authorize it at: [Authorize ${ctx.label}](${url})`);
+  }
+}
+function printConnectorAuthorizationStatus(ctx, isConnected, isExpired, hasPermission) {
+  console.log(
+    "### 2b: Agent authorization (user must authorize agent to use this connector)"
+  );
+  console.log("");
+  if (!ctx.connectorAvailable) {
+    console.log(
+      `Skipped \u2014 the ${ctx.label} connector is not available for this account.`
+    );
+  } else {
+    printAgentAuthorizationStatus(ctx, isConnected, isExpired, hasPermission);
+  }
+  console.log(
+    `This run uses agent-scoped connector authorization for ${ctx.label} access.`
+  );
+  console.log("");
+}
+function checkEnvironmentNames(ctx) {
+  console.log("## Step 1: Sandbox environment name");
+  console.log("");
+  if (ctx.environmentNames === null) {
+    console.log(
+      "Environment metadata is unavailable for this run's sanitized firewall entry, so no environment name was guessed."
+    );
+    console.log("");
+    return;
+  }
+  if (ctx.environmentNames.length === 0) {
+    console.log(
+      "The matched API route does not use a sandbox environment name."
+    );
+    console.log("");
+    return;
+  }
+  let environmentPresent = false;
+  for (const environmentName of ctx.environmentNames) {
+    const present = Boolean(process.env[environmentName]);
+    environmentPresent ||= present;
+    console.log(
+      `Checking process.env.${environmentName}: ${present ? "present" : "not present"}`
+    );
+  }
+  if (environmentPresent) {
+    console.log(
+      "At least one connector value is present in the sandbox environment. These values may be non-secret connector settings or credential placeholders; real credentials are never injected and are resolved at the network boundary for registered base URLs."
+    );
+  } else {
+    console.log(
+      "No value found for these environment names. Note: credential replacement at the network boundary is independent of these names \u2014 the proxy injects auth headers based on the destination URL."
+    );
+  }
+  console.log("");
+}
+async function checkConnectorStatus(ctx) {
+  console.log("## Step 2: Connector configuration");
+  console.log("");
+  console.log(
+    "A Connector holds the real credentials (OAuth tokens or API keys) for an external service. These credentials are never injected into the sandbox. Instead, when the sandbox sends an HTTP request to a base URL registered by the Connector, the network boundary intercepts the request and replaces the auth headers with real credentials. For this to work, three conditions must be met:"
+  );
+  console.log("");
+  const [connector, enabledTypes] = await Promise.all([
+    getZeroConnector(ctx.connectorRef),
+    ctx.agentId ? getZeroAgentUserConnectors(ctx.agentId) : Promise.resolve(null)
+  ]);
+  const isConnected = connector !== null;
+  const isExpired = connector?.connectionStatus === "reconnect-required";
+  const hasPermission = enabledTypes !== null && enabledTypes.includes(ctx.connectorRef);
+  printConnectorConnectionStatus(ctx, isConnected, isExpired, hasPermission);
+  printConnectorAuthorizationStatus(ctx, isConnected, isExpired, hasPermission);
+  return { isConnected, isExpired, hasPermission };
+}
+function checkConnectorDomains(ctx) {
+  console.log(
+    "### 2c: Registered base URLs (credential replacement only applies to URLs matching these prefixes)"
+  );
+  console.log("");
+  switch (ctx.run.status) {
+    case "not-scoped":
+      console.log(
+        "This diagnostic is not scoped to a run \u2014 skipping the run base URL check."
+      );
+      console.log("");
+      return null;
+    case "not-configured":
+      console.log(
+        `No configuration found for the ${ctx.label} connector in this run.`
+      );
+      console.log(
+        "This means no base URLs are registered for credential replacement for this connector."
+      );
+      console.log("");
+      return false;
+    case "configured":
+      console.log(
+        `The ${ctx.label} connector is configured for this run with the following base URLs:`
+      );
+      for (const base of ctx.run.bases) {
+        console.log(`  - ${base}`);
+      }
+      console.log("");
+      if (ctx.credentialResolution === "network-boundary") {
+        console.log(
+          "Credentials are resolved at the network boundary for requests matching these registered base URLs."
+        );
+      }
+      console.log("");
+      return true;
+  }
+}
+function printUnavailablePolicy(policy) {
+  switch (policy.basis) {
+    case "not-run-scoped":
+      console.log(
+        "Result: Permission policy is unavailable because this diagnostic is not scoped to a run."
+      );
+      return;
+    case "policies-unavailable":
+      console.log(
+        "Result: Network policies are unavailable for this run, so the permission status cannot be determined."
+      );
+      return;
+    case "connector-not-configured":
+      console.log(
+        "Result: The connector is not configured for this run, so requests cannot receive credentials."
+      );
+      return;
+  }
+}
+function printNamedPolicyResult(permission, policy) {
+  switch (policy.outcome) {
+    case "allow": {
+      switch (policy.basis) {
+        case "allow-list":
+          console.log(
+            `Result: "${permission}" is in the allow list \u2014 allowed.`
+          );
+          return;
+        case "not-blocked":
+          console.log(
+            `Result: "${permission}" is not blocked by the deny or ask list \u2014 allowed.`
+          );
+          return;
+        case "no-policy":
+          console.log(
+            `Result: No policy entry exists for this connector \u2014 "${permission}" is allowed.`
+          );
+          return;
+        case "unknown-policy":
+          console.log(
+            `Result: The server policy allows "${permission}" through the unknown-endpoint policy.`
+          );
+          return;
+      }
+      break;
+    }
+    case "deny":
+      console.log(
+        policy.basis === "deny-list" ? `Result: "${permission}" is in the deny list \u2014 denied.` : `Result: The unknown-endpoint policy denies "${permission}".`
+      );
+      return;
+    case "ask":
+      console.log(
+        policy.basis === "ask-list" ? `Result: "${permission}" is in the ask list \u2014 blocked until approval.` : `Result: The unknown-endpoint policy blocks "${permission}" until approval.`
+      );
+      return;
+    case "unavailable":
+      printUnavailablePolicy(policy);
+      return;
+  }
+}
+function unknownPermissionChangeCommand(connectorRef) {
+  return `zero doctor permission-change ${connectorRef} --permission __unknown__ --enable --duration 1h`;
+}
+function printUnknownEndpointPolicy(connectorRef, policy) {
+  switch (policy.outcome) {
+    case "allow":
+      console.log(
+        policy.basis === "no-policy" ? "Result: No policy entry exists for this connector, so the request is allowed." : "Result: No permission matched. The unknown endpoint policy allows this request."
+      );
+      return;
+    case "deny":
+      console.log(
+        "Result: No permission matched. The unknown endpoint policy denies this request."
+      );
+      console.log(
+        `To allow unknown endpoints, run: ${unknownPermissionChangeCommand(connectorRef)}`
+      );
+      return;
+    case "ask":
+      console.log(
+        "Result: No permission matched. The unknown endpoint policy requires approval."
+      );
+      console.log(
+        `To allow unknown endpoints, run: ${unknownPermissionChangeCommand(connectorRef)}`
+      );
+      return;
+    case "unavailable":
+      printUnavailablePolicy(policy);
+      return;
+  }
+}
+function printUrlPermissionDiagnostic(result) {
+  console.log("## Step 3: Permission policy check (auto-detected from URL)");
+  console.log("");
+  console.log(
+    `Matching ${result.method} ${result.relativePath} (relative to base URL ${result.base}) against the ${result.connector.label} connector's permission rules.`
+  );
+  console.log("");
+  if (result.permission.kind === "matched") {
+    console.log(
+      `Matched permissions: [${result.permission.permissions.map((permission) => {
+        return permission.name;
+      }).join(", ")}]`
+    );
+    console.log("");
+    for (const permission of result.permission.permissions) {
+      printNamedPolicyResult(permission.name, permission.policy);
+    }
+  } else {
+    console.log(
+      `No named permission matches ${result.method} ${result.relativePath}. This request falls through to the unknown-endpoint policy.`
+    );
+    console.log("");
+    printUnknownEndpointPolicy(
+      result.connector.connectorRef,
+      result.permission.policy
+    );
+  }
+  console.log("");
+}
+function printEnvironmentPermissionDiagnostic(result, permissionName) {
+  if (result.permission === null) {
+    return;
+  }
+  if (permissionName === void 0) {
+    throw new Error(
+      "Connector diagnostic returned a permission outcome without a requested permission."
+    );
+  }
+  console.log("## Step 3: Permission policy check");
+  console.log("");
+  console.log(
+    `Checking permission: "${permissionName}" for the ${result.connector.label} connector.`
+  );
+  console.log("");
+  printNamedPolicyResult(permissionName, result.permission);
+  console.log("");
+}
+function printRediagnoseHint(opts, method) {
+  const args = [];
+  if (opts.url !== void 0) {
+    args.push(`--url ${shellQuoteArg(stripUrlQueryAndFragment(opts.url))}`);
+    if (opts.connector !== void 0) {
+      args.push(`--connector ${shellQuoteArg(opts.connector)}`);
+    }
+    if (opts.envName !== void 0) {
+      args.push(`--env-name ${shellQuoteArg(opts.envName)}`);
+    }
+    if (method !== "GET") {
+      args.push(`--method ${shellQuoteArg(method)}`);
+    }
+  } else if (opts.envName !== void 0) {
+    args.push(`--env-name ${shellQuoteArg(opts.envName)}`);
+  }
+  if (opts.checkPermission !== void 0) {
+    args.push(`--check-permission ${shellQuoteArg(opts.checkPermission)}`);
+  }
+  console.log(
+    `To re-diagnose after changes, run: zero doctor check-connector ${args.join(" ")}`
+  );
+}
+var checkConnectorCommand = new Command().name("check-connector").description(
+  "Diagnose connector health: environment names, connector configuration, and permission policies"
+).addOption(
+  new Option(
+    "--env-name <ENV_NAME>",
+    "The connector environment name to check (e.g. GITHUB_TOKEN)"
+  )
+).addOption(
+  new Option(
+    "--url <URL>",
+    "A full URL to diagnose \u2014 matches connector ownership, route environment names, and permission (e.g. https://api.github.com/repos/owner/repo)"
+  )
+).addOption(
+  new Option(
+    "--connector <type>",
+    "Select the connector when multiple connectors own the same URL route"
+  )
+).addOption(
+  new Option(
+    "--method <METHOD>",
+    "HTTP method to use when matching permissions with --url (default: GET)"
+  ).default("GET")
+).addOption(
+  new Option(
+    "--check-permission <name>",
+    "Check whether a specific permission is allowed or denied (e.g. contents:read)"
+  )
+).addHelpText(
+  "after",
+  `
+Examples:
+  zero doctor check-connector --env-name GITHUB_TOKEN
+  zero doctor check-connector --url https://api.github.com/repos/owner/repo
+  zero doctor check-connector --url https://api.accounts.nintendo.com/2.0.0/users/me --connector nintendo-store
+  zero doctor check-connector --url https://slack.com/api/chat.postMessage --method POST
+  zero doctor check-connector --env-name SLACK_TOKEN --check-permission chat:write
+
+How connectors work:
+  A Connector holds the real credentials for an external service. These credentials
+  are never injected into the sandbox. Instead, when the sandbox sends an HTTP
+  request to a base URL registered by the Connector, the network boundary intercepts
+  the request and replaces the auth headers with real credentials.
+
+  This command checks each part of that pipeline and reports what it finds.`
+).action(
+  withErrorHandler(async (opts, command) => {
+    validateCheckConnectorOptions(opts, command);
+    const method = opts.method.toUpperCase();
+    const request = buildDiagnosticRequest(opts, method);
+    const diagnostic = await diagnoseZeroConnectorCheck(request);
+    const result = resolvedDiagnostic(request, diagnostic);
+    printDiagnosticSummary(request, result);
+    console.log("");
+    const platformUrl = toPlatformUrl(await getApiUrl());
+    const ctx = {
+      environmentNames: diagnosticEnvironmentNames(result),
+      connectorRef: result.connector.connectorRef,
+      label: result.connector.label,
+      connectorAvailable: result.connector.visibility === "available",
+      credentialResolution: result.connector.credentialResolution,
+      run: result.run,
+      platformOrigin: platformUrl.origin,
+      agentId: process.env.ZERO_AGENT_ID || void 0
+    };
+    checkEnvironmentNames(ctx);
+    const { isConnected, isExpired, hasPermission } = await checkConnectorStatus(ctx);
+    const configuredForRun = checkConnectorDomains(ctx);
+    if (configuredForRun === false) {
+      console.log(
+        `Steps 1-2 summary: The ${ctx.label} connector is not configured for this run. Check the agent authorization settings, then start a new run after updating them.`
+      );
+    } else if (isConnected && !isExpired && hasPermission) {
+      console.log(
+        `Steps 1-2 summary: The ${ctx.label} connector is connected, active, and authorized. Outbound requests to the registered base URLs will have credentials injected at the network boundary.`
+      );
+    }
+    console.log("");
+    if (result.mode === "url") {
+      printUrlPermissionDiagnostic(result);
+    } else {
+      printEnvironmentPermissionDiagnostic(
+        result,
+        request.mode === "environment" ? request.permission : void 0
+      );
+    }
+    printRediagnoseHint(opts, method);
+  })
+);
+
+// src/commands/zero/doctor/permission-deny.ts
+init_esm_shims();
+
+// src/commands/zero/doctor/computer-use-guidance.ts
+init_esm_shims();
+var COMPUTER_USE_CONNECTOR_REF = "computer-use";
+var COMPUTER_USE_CAPABILITY = "computer-use:write";
+var COMPUTER_USE_PATH_PREFIX = "/computer-use";
+var COMPUTER_USE_PATH_PREFIX_WITH_SLASH = `${COMPUTER_USE_PATH_PREFIX}/`;
+function isComputerUsePermissionTarget(target) {
+  return target.connectorRef === COMPUTER_USE_CONNECTOR_REF || target.permission === COMPUTER_USE_CAPABILITY || target.path === COMPUTER_USE_PATH_PREFIX || target.path?.startsWith(COMPUTER_USE_PATH_PREFIX_WITH_SLASH) === true;
+}
+function printComputerUsePermissionGuidance() {
+  console.log("Computer Use access is not managed as a connector permission.");
+  console.log(
+    "The current run token needs computer-use:write, which is issued only when a Zero Desktop Computer Use host is selected for the chat or thread before the run starts."
+  );
+  console.log(
+    "Open Zero Desktop, make sure Computer Use is online, select the Computer Use host for this chat/thread, then start a new run. Existing run tokens cannot be upgraded in place."
+  );
+  console.log(
+    "Run `zero whoami` to confirm whether the current ZERO_TOKEN includes computer-use:write."
+  );
+}
+
+// src/commands/zero/doctor/permission-deny.ts
+var VALID_DENIED_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+function unknownPermissionChangeCommand2(connectorRef) {
+  return `zero doctor permission-change ${connectorRef} --permission ${UNKNOWN_PERMISSION_GRANT} --enable --duration 1h`;
+}
+function pathOnlyError() {
+  return new Error(
+    "permission-deny now requires --url because method/path alone can match the wrong API base."
+  );
+}
+function invalidUrlError() {
+  return new Error(
+    "permission-deny requires --url to be a valid absolute http or https URL."
+  );
+}
+function invalidMethodError() {
+  return new Error(
+    "permission-deny requires --method to be one of GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS."
+  );
+}
+function unsafePathError() {
+  return new Error(
+    "permission-deny cannot diagnose unsafe URL paths because they are blocked before permission policy evaluation."
+  );
+}
+function parseDeniedMethod(method) {
+  const upperMethod = method.toUpperCase();
+  if (!VALID_DENIED_METHODS.has(upperMethod)) {
+    throw invalidMethodError();
+  }
+  return upperMethod;
+}
+function rawAuthorityFromDeniedUrl(url) {
+  const schemeEnd = url.indexOf("://");
+  if (schemeEnd === -1) return null;
+  const authorityStart = schemeEnd + 3;
+  let authorityEnd = url.length;
+  for (const delimiter of ["/", "?", "#"]) {
+    const index = url.indexOf(delimiter, authorityStart);
+    if (index !== -1) authorityEnd = Math.min(authorityEnd, index);
+  }
+  return url.slice(authorityStart, authorityEnd);
+}
+function rawAuthorityHasUnsafeSyntax(url) {
+  const authority = rawAuthorityFromDeniedUrl(url);
+  if (authority === null) return false;
+  return authority === "" || authority.includes("\\") || authority.includes("%") || [...authority].some((char) => {
+    return char.charCodeAt(0) > 127;
+  });
+}
+function validateDeniedUrl(url) {
+  if (!url.includes("://") || /\s/.test(url) || rawAuthorityHasUnsafeSyntax(url)) {
+    throw invalidUrlError();
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw invalidUrlError();
+    }
+    if (parsed.username !== "" || parsed.password !== "") {
+      throw invalidUrlError();
+    }
+  } catch {
+    throw invalidUrlError();
+  }
+}
+function stripUrlQueryAndFragment2(url) {
+  const queryIndex = url.indexOf("?");
+  const fragmentIndex = url.indexOf("#");
+  let end = url.length;
+  if (queryIndex !== -1) end = Math.min(end, queryIndex);
+  if (fragmentIndex !== -1) end = Math.min(end, fragmentIndex);
+  return url.slice(0, end);
+}
+function rawPathFromDeniedUrl(url) {
+  const urlWithoutQuery = stripUrlQueryAndFragment2(url);
+  const schemeEnd = urlWithoutQuery.indexOf("://");
+  const authorityStart = schemeEnd === -1 ? 0 : schemeEnd + 3;
+  const pathStart = urlWithoutQuery.indexOf("/", authorityStart);
+  return pathStart === -1 ? "/" : urlWithoutQuery.slice(pathStart);
+}
+function printPermissionChangeGuidance(connectorRef, permissions) {
+  const sortedPermissions = [...permissions].sort();
+  if (sortedPermissions.length === 1) {
+    const permission = sortedPermissions[0];
+    console.log(`This is covered by the "${permission}" permission.`);
+    console.log(
+      `To allow this permission, run: zero doctor permission-change ${connectorRef} --permission ${permission} --enable --duration 1h`
+    );
+    return;
+  }
+  console.log(
+    `This is covered by these permissions: ${sortedPermissions.join(", ")}.`
+  );
+  for (const permission of sortedPermissions) {
+    console.log(
+      `To allow ${permission}, run: zero doctor permission-change ${connectorRef} --permission ${permission} --enable --duration 1h`
+    );
+  }
+}
+function printFilteredRequest(label, method, relativePath, base) {
+  console.log(
+    `The ${label} permission filtered ${method} ${relativePath} relative to base URL ${base}.`
+  );
+}
+function unsafeInputError2(reason) {
+  switch (reason) {
+    case "invalid-method":
+      return invalidMethodError();
+    case "invalid-url":
+      return invalidUrlError();
+    case "unsafe-path":
+      return unsafePathError();
+  }
+}
+function handleDiagnosticResult(connectorRef, method, result) {
+  switch (result.outcome) {
+    case "matched":
+      printFilteredRequest(
+        result.label,
+        method,
+        result.relativePath,
+        result.base
+      );
+      printPermissionChangeGuidance(connectorRef, result.permissions);
+      return;
+    case "unknown-endpoint":
+      printFilteredRequest(
+        result.label,
+        method,
+        result.relativePath,
+        result.base
+      );
+      console.log("No named permission was found covering this request.");
+      console.log("This request is governed by the unknown endpoint policy.");
+      console.log(
+        `To allow unknown endpoints, run: ${unknownPermissionChangeCommand2(connectorRef)}`
+      );
+      return;
+    case "unknown-connector":
+      throw new Error(`Unknown connector type: ${connectorRef}`);
+    case "no-matching-base":
+      throw new Error(
+        `No registered ${result.label} base URL matches the provided URL.`
+      );
+    case "unresolved-dynamic-base":
+      throw new Error(
+        `No authoritative ${result.label} base URL is available for this diagnostic. Verify the ${connectorRef} connector configuration for the affected context and retry.`
+      );
+    case "unsafe-input":
+      throw unsafeInputError2(result.reason);
+  }
+  const exhaustiveResult = result;
+  return exhaustiveResult;
+}
+var permissionDenyCommand = new Command().name("permission-deny").description(
+  "Diagnose a permission denial and find the permission that covers it"
+).argument("<connector-ref>", "The connector type (e.g. github)").addOption(
+  new Option(
+    "--method <method>",
+    "The denied HTTP method"
+  ).makeOptionMandatory()
+).addOption(
+  new Option(
+    "--url <url>",
+    "The denied request URL; query strings are ignored (required)"
+  )
+).addOption(new Option("--path <path>", "Deprecated: use --url").hideHelp()).addHelpText(
+  "after",
+  `
+Examples:
+  zero doctor permission-deny github --method GET --url https://api.github.com/repos/owner/repo/pulls
+  zero doctor permission-deny slack --method POST --url https://slack.com/api/chat.postMessage
+  zero doctor permission-deny youtube --method PUT --url https://youtube.googleapis.com/upload/youtube/v3/videos
+
+Notes:
+  - Identifies which named permission covers a denied request
+  - If the firewall denial response includes a url field, pass that value to --url
+  - Requires the denied URL origin and path because method/path alone can match the wrong API base
+  - Query strings and fragments are ignored for matching; omit them when they may contain secrets
+  - Use permission-change to request or enable the permission
+  - Permission-change enable requests default to --duration 1h; pick 24h, 7d, or always only when appropriate`
+).action(
+  withErrorHandler(
+    async (connectorRef, opts) => {
+      if (opts.path !== void 0) {
+        throw pathOnlyError();
+      }
+      if (!opts.url) {
+        throw pathOnlyError();
+      }
+      const method = parseDeniedMethod(opts.method);
+      validateDeniedUrl(opts.url);
+      const deniedPath = rawPathFromDeniedUrl(opts.url);
+      if (hasUnsafeFirewallPath(deniedPath)) {
+        throw unsafePathError();
+      }
+      if (isComputerUsePermissionTarget({
+        connectorRef,
+        path: deniedPath
+      })) {
+        printComputerUsePermissionGuidance();
+        return;
+      }
+      const result = await diagnoseZeroConnectorPermissionDeny(
+        connectorRef,
+        method,
+        stripUrlQueryAndFragment2(opts.url)
+      );
+      handleDiagnosticResult(connectorRef, method, result);
+    }
+  )
+);
+
+// src/commands/zero/doctor/permission-change.ts
+init_esm_shims();
+var DEFAULT_PERMISSION_GRANT_DURATION = "1h";
+var PERMISSION_GRANT_DURATIONS = [
+  "1h",
+  "24h",
+  "7d",
+  "always"
+];
+function permissionDescription(permission) {
+  return permission === UNKNOWN_PERMISSION_GRANT ? "unknown endpoints" : `the "${permission}" permission`;
+}
+function printSensitivePermissionGuidance(connectorRef, permission, action) {
+  if (action !== "enable") return;
+  if (connectorRef === "slack" && permission === "chat:write") {
+    console.log("");
+    console.log(
+      "IMPORTANT: Granting chat:write allows sending messages AS THE USER's identity, not as a bot."
+    );
+    console.log(
+      "Use `zero slack message send -c <channel> -t <text>` to send messages as the bot instead \u2014 this is the recommended approach for most use cases."
+    );
+    console.log(
+      "Only allow this permission below if acting as the user is specifically required."
+    );
+    console.log("");
+  }
+  if (connectorRef === "gmail" && (permission === "messages.send" || permission === "drafts.send")) {
+    console.log("");
+    console.log(
+      "IMPORTANT: Granting Gmail send permissions allows the agent to send emails directly as the user."
+    );
+    console.log(
+      "Consider keeping messages.send and drafts.send disabled and using drafts.write instead \u2014 the agent can create drafts for the user to review and send manually."
+    );
+    console.log(
+      "Only allow this permission below if direct sending is specifically required."
+    );
+    console.log("");
+  }
+}
+function printPermissionActionMessage(args) {
+  const grantAction = args.action === "enable" ? "allow" : "deny";
+  console.log(
+    `You can ${grantAction} ${permissionDescription(args.permission)} for your connector access: [Manage ${args.label} permissions](${args.url})`
+  );
+  if (args.duration) {
+    console.log(
+      `Requested duration: ${args.duration}. Use --duration 1h|24h|7d|always to choose a different grant lifetime.`
+    );
+  }
+}
+function printComputerUseAuthorizationLink(args) {
+  console.log(
+    "Computer Use needs a Zero Desktop host selected before a run starts."
+  );
+  console.log(
+    "Ask the user to authorize a host for future runs in this chat or Slack thread:"
+  );
+  console.log(args.authorizationUrl);
+  console.log(
+    `This link expires at ${args.expiresAt}. Existing run tokens cannot be upgraded in place; start a new run after authorization.`
+  );
+}
+async function printComputerUsePermissionChangeMessage(action) {
+  if (action !== "enable") {
+    printComputerUsePermissionGuidance();
+    return;
+  }
+  if (!process.env.ZERO_TOKEN) {
+    printComputerUsePermissionGuidance();
+    return;
+  }
+  try {
+    const request = await createComputerUseAuthorizationRequest();
+    printComputerUseAuthorizationLink({
+      authorizationUrl: request.authorizationUrl,
+      expiresAt: request.expiresAt
+    });
+  } catch (error) {
+    if (error instanceof ApiRequestError) {
+      console.log(
+        `Computer Use authorization link unavailable: ${error.message}`
+      );
+      printComputerUsePermissionGuidance();
+      return;
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(`Computer Use authorization link unavailable: ${message}`);
+    printComputerUsePermissionGuidance();
+  }
+}
+async function outputPermissionChangeMessage(connectorRef, label, permission, action, duration, agentId) {
+  const platformOrigin = await getPlatformOrigin();
+  const urlParams = new URLSearchParams({
+    ref: connectorRef,
+    permission,
+    action: action === "enable" ? "allow" : "deny"
+  });
+  if (action === "enable") {
+    urlParams.set("expiresIn", duration ?? DEFAULT_PERMISSION_GRANT_DURATION);
+  }
+  const pagePath = agentId ? `/agents/${agentId}/permissions` : "/agents";
+  const url = `${platformOrigin}${pagePath}?${urlParams.toString()}`;
+  printSensitivePermissionGuidance(connectorRef, permission, action);
+  printPermissionActionMessage({
+    action,
+    permission,
+    label,
+    url,
+    duration: action === "enable" ? duration ?? DEFAULT_PERMISSION_GRANT_DURATION : void 0
+  });
+}
+var permissionChangeCommand = new Command().name("permission-change").description("Change or request a permission (enable or disable)").argument("<connector-ref>", "The connector type (e.g. github)").addOption(
+  new Option(
+    "--permission <name>",
+    "The permission name to change"
+  ).makeOptionMandatory()
+).addOption(
+  new Option(
+    "--enable",
+    "Enable or request enabling the permission"
+  ).conflicts("disable")
+).addOption(
+  new Option(
+    "--disable",
+    "Disable or request disabling the permission"
+  ).conflicts("enable")
+).addOption(
+  new Option(
+    "--duration <duration>",
+    "Requested allow duration: 1h, 24h, 7d, or always (default: 1h)"
+  ).choices([...PERMISSION_GRANT_DURATIONS])
+).addOption(
+  new Option("--reason <text>", "Brief reason for the permission change")
+).addOption(
+  new Option(
+    "--agent <id>",
+    "Agent ID whose permission page should be opened (defaults to ZERO_AGENT_ID)"
+  )
+).addHelpText(
+  "after",
+  `
+Examples:
+  zero doctor permission-change github --permission contents:read --enable
+  zero doctor permission-change github --permission contents:write --enable --duration 24h
+  zero doctor permission-change gmail --permission messages.write --enable --agent <agent-id>
+  zero doctor permission-change slack --permission chat:write --disable
+  zero doctor permission-change cloudflare --permission __unknown__ --disable
+  zero doctor permission-change computer-use --permission computer-use:write --enable
+
+Notes:
+  - Outputs a platform URL for the user to adjust the permission
+  - Use --permission __unknown__ to change unknown endpoint policy
+  - Use --agent to request a permission for another agent; defaults to ZERO_AGENT_ID
+  - Enable requests default to --duration 1h; use 24h or 7d for longer user-approved work
+  - Use --duration always only when the user explicitly asks for persistent access
+  - Permission changes update the current user's connector grants`
+).action(
+  withErrorHandler(
+    async (connectorRef, opts) => {
+      if (!opts.enable && !opts.disable) {
+        throw new Error("Either --enable or --disable is required");
+      }
+      if (opts.disable && opts.duration !== void 0) {
+        throw new Error("--duration is only supported with --enable");
+      }
+      if (isComputerUsePermissionTarget({
+        connectorRef,
+        permission: opts.permission
+      })) {
+        await printComputerUsePermissionChangeMessage(
+          opts.enable ? "enable" : "disable"
+        );
+        return;
+      }
+      const metadata = await getZeroConnectorCatalogPermissions(connectorRef);
+      if (!metadata) {
+        throw new Error(`Unknown connector type: ${connectorRef}`);
+      }
+      if (opts.permission !== UNKNOWN_PERMISSION_GRANT && !findFirewallMetadataPermission(metadata, opts.permission)) {
+        throw new Error(
+          `Unknown permission "${opts.permission}" for ${connectorRef}`
+        );
+      }
+      const action = opts.enable ? "enable" : "disable";
+      await outputPermissionChangeMessage(
+        connectorRef,
+        metadata.label,
+        opts.permission,
+        action,
+        opts.duration,
+        opts.agent ?? process.env.ZERO_AGENT_ID
+      );
+    }
+  )
+);
+
+// src/commands/zero/doctor/credit.ts
+init_esm_shims();
+function memberName(member) {
+  const name = [member.firstName, member.lastName].filter(Boolean).join(" ");
+  return name ? `${name} <${member.email}>` : member.email;
+}
+var creditCommand = new Command().name("credit").description("Diagnose current organization credit and purchase access").action(
+  withErrorHandler(async () => {
+    const [org, billing, members] = await Promise.all([
+      getZeroOrg(),
+      getZeroBillingStatus(),
+      getZeroOrgMembers()
+    ]);
+    const admins = members.members.filter((member) => {
+      return member.role === "admin";
+    });
+    const isAdmin = members.role === "admin";
+    const canPurchaseCredits = isAdmin;
+    console.log(source_default.bold("Credit diagnostics:"));
+    console.log(`  Org: ${source_default.green(org.slug)}`);
+    console.log(`  Tier: ${source_default.cyan(billing.tier)}`);
+    console.log(
+      `  Available credits: ${source_default.cyan(billing.credits.toLocaleString())}`
+    );
+    console.log(`  Current user role: ${source_default.cyan(members.role)}`);
+    console.log(
+      `  Can purchase credits: ${canPurchaseCredits ? source_default.green("yes") : source_default.yellow("no")}`
+    );
+    console.log(
+      `  Auto-recharge: ${billing.autoRecharge.enabled ? source_default.green("enabled") : "disabled"}`
+    );
+    if (billing.autoRecharge.enabled) {
+      console.log(
+        `    Threshold: ${billing.autoRecharge.threshold?.toLocaleString() ?? "not set"}`
+      );
+      console.log(
+        `    Amount: ${billing.autoRecharge.amount?.toLocaleString() ?? "not set"}`
+      );
+    }
+    if (!isAdmin) {
+      console.log(source_default.bold("\nOrganization admins:"));
+      for (const admin of admins) {
+        console.log(`  - ${memberName(admin)}`);
+      }
+      console.log(
+        source_default.yellow(
+          "\nAsk an organization admin to buy credits or upgrade the plan."
+        )
+      );
+    } else if (billing.tier === "free") {
+      console.log(
+        "\nFree-tier admins can upgrade to Pro from billing or buy credits with `zero credit <credits>`."
+      );
+    } else {
+      console.log("\nUse `zero credit <credits>` to buy more credits.");
+    }
+  })
+);
+
+// src/commands/zero/doctor/index.ts
+var zeroDoctorCommand = new Command().name("doctor").description("Diagnose runtime issues (connector health, permission denials)").addCommand(checkConnectorCommand).addCommand(creditCommand).addCommand(permissionDenyCommand).addCommand(permissionChangeCommand).addHelpText(
+  "after",
+  `
+Examples:
+  Check a connector?     zero doctor check-connector --env-name GITHUB_TOKEN
+  Check a URL?           zero doctor check-connector --url https://api.github.com/repos/owner/repo
+  Check credits?         zero doctor credit
+  Check with permission? zero doctor check-connector --env-name SLACK_TOKEN --check-permission chat:write
+  Permission denied?     zero doctor permission-deny github --method GET --url https://api.github.com/repos/owner/repo
+  Change a permission?   zero doctor permission-change github --permission contents:read --enable --duration 1h
+  Disable unknown URLs?  zero doctor permission-change cloudflare --permission __unknown__ --disable
+
+Notes:
+  - Use zero doctor credit when a run or generation fails because the org has insufficient credits, when a user asks how to recharge, or before trying to buy credits
+  - Use this when your task fails due to a missing connector environment name or permission denial
+  - Use zero generate <type> (no --prompt) to see every provider available for a given generation type
+  - The doctor will identify the issue and give the user a link to resolve it`
+);
+export {
+  zeroDoctorCommand
+};
+//# sourceMappingURL=doctor-RGD5Z6QS.js.map