@vm0/cli 9.237.4 → 9.238.0

package/org-QLHP7UVC.js

@@ -0,0 +1,922 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  isInteractive,
+  promptConfirm,
+  promptPassword,
+  require_prompts
+} from "./chunk-JFY6GK7Y.js";
+import {
+  MODEL_PROVIDER_TYPES,
+  deleteZeroOrg,
+  deleteZeroOrgModelProvider,
+  deleteZeroOrgSecret,
+  deleteZeroOrgVariable,
+  getAuthMethodsForType,
+  getDefaultAuthMethod,
+  getSecretsForAuthMethod,
+  getSelectableProviderTypes,
+  getZeroOrg,
+  getZeroOrgMembers,
+  hasAuthMethods,
+  inviteZeroOrgMember,
+  leaveZeroOrg,
+  listZeroOrgModelProviders,
+  listZeroOrgSecrets,
+  listZeroOrgVariables,
+  listZeroOrgs,
+  removeZeroOrgMember,
+  setZeroOrgSecret,
+  setZeroOrgVariable,
+  switchZeroOrg,
+  updateZeroOrg,
+  upsertZeroOrgModelProvider
+} from "./chunk-ANSRPVAG.js";
+import "./chunk-LTDQISD7.js";
+import {
+  ApiRequestError,
+  getActiveOrg,
+  saveConfig,
+  withErrorHandler
+} from "./chunk-P7KBTYPU.js";
+import {
+  source_default
+} from "./chunk-JUTUEPIR.js";
+import "./chunk-LRHXR7JT.js";
+import {
+  Command
+} from "./chunk-B3W2RUBP.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-DIRAZ3YX.js";
+
+// src/commands/zero/org/index.ts
+init_esm_shims();
+
+// src/commands/zero/org/status.ts
+init_esm_shims();
+var statusCommand = new Command().name("status").description("View current organization status").action(
+  withErrorHandler(async () => {
+    try {
+      const org = await getZeroOrg();
+      console.log(source_default.bold("Organization Information:"));
+      console.log(`  Slug: ${source_default.green(org.slug)}`);
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) {
+        throw new Error("No organization configured", {
+          cause: new Error("Set your organization with: zero org set <slug>")
+        });
+      }
+      throw error;
+    }
+  })
+);
+
+// src/commands/zero/org/set.ts
+init_esm_shims();
+var setCommand = new Command().name("set").description("Rename your organization slug").argument("<slug>", "The new organization slug").option(
+  "--force",
+  "Force change existing organization (may break references)"
+).action(
+  withErrorHandler(async (slug, options) => {
+    try {
+      const existingOrg = await getZeroOrg();
+      if (!options.force) {
+        throw new Error(
+          `You already have an organization: ${existingOrg.slug}`,
+          {
+            cause: new Error(`To change, use: zero org set ${slug} --force`)
+          }
+        );
+      }
+      const org = await updateZeroOrg({ slug, force: true });
+      const result = await switchZeroOrg(org.slug);
+      await saveConfig({
+        token: result.access_token
+      });
+      console.log(source_default.green(`\u2713 Organization updated to ${org.slug}`));
+      console.log();
+      console.log("Your agents will now be namespaced as:");
+      console.log(source_default.cyan(`  ${org.slug}/<agent-name>`));
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("already exists")) {
+        throw new Error(
+          `Organization "${slug}" is already taken. Please choose a different slug.`
+        );
+      }
+      throw error;
+    }
+  })
+);
+
+// src/commands/zero/org/list.ts
+init_esm_shims();
+var listCommand = new Command().name("list").description("List all accessible organizations").action(
+  withErrorHandler(async () => {
+    const result = await listZeroOrgs();
+    const activeOrg = await getActiveOrg();
+    console.log(source_default.bold("Available organizations:"));
+    for (const org of result.orgs) {
+      const isCurrent = org.slug === activeOrg;
+      const marker = isCurrent ? source_default.green("* ") : "  ";
+      const roleLabel = org.role ? ` (${org.role})` : "";
+      const currentLabel = isCurrent ? source_default.dim(" \u2190 current") : "";
+      console.log(`${marker}${org.slug}${roleLabel}${currentLabel}`);
+    }
+  })
+);
+
+// src/commands/zero/org/use.ts
+init_esm_shims();
+var useCommand = new Command().name("use").description("Switch to a different organization").argument("<slug>", "Organization slug to switch to").action(
+  withErrorHandler(async (slug) => {
+    const orgList = await listZeroOrgs();
+    const target = orgList.orgs.find((s) => {
+      return s.slug === slug;
+    });
+    if (!target) {
+      throw new Error(`Organization '${slug}' not found or not accessible.`);
+    }
+    const result = await switchZeroOrg(slug);
+    await saveConfig({
+      token: result.access_token
+    });
+    console.log(source_default.green(`\u2713 Switched to organization: ${slug}`));
+  })
+);
+
+// src/commands/zero/org/members.ts
+init_esm_shims();
+var membersCommand = new Command().name("members").description("View organization members").action(
+  withErrorHandler(async () => {
+    const status = await getZeroOrgMembers();
+    console.log(source_default.bold(`Organization: ${status.slug}`));
+    console.log(`  Role: ${status.role}`);
+    console.log(
+      `  Created: ${new Date(status.createdAt).toLocaleDateString()}`
+    );
+    console.log();
+    console.log(source_default.bold("Members:"));
+    for (const member of status.members) {
+      const roleTag = member.role === "admin" ? source_default.yellow(` (${member.role})`) : source_default.dim(` (${member.role})`);
+      console.log(`  ${member.email}${roleTag}`);
+    }
+  })
+);
+
+// src/commands/zero/org/invite.ts
+init_esm_shims();
+var inviteCommand = new Command().name("invite").description("Invite a member to the current organization").requiredOption("--email <email>", "Email address of the member to invite").option(
+  "--role <role>",
+  "Role for the invited member (member or admin)",
+  "member"
+).action(
+  withErrorHandler(async (options) => {
+    if (options.role !== "member" && options.role !== "admin") {
+      throw new Error(
+        `Invalid role "${options.role}". Must be "member" or "admin".`
+      );
+    }
+    await inviteZeroOrgMember(options.email, options.role);
+    console.log(
+      source_default.green(`\u2713 Invitation sent to ${options.email} as ${options.role}`)
+    );
+  })
+);
+
+// src/commands/zero/org/remove.ts
+init_esm_shims();
+var removeCommand = new Command().name("remove").description("Remove a member from the current organization").argument("<email>", "Email address of the member to remove").action(
+  withErrorHandler(async (email) => {
+    await removeZeroOrgMember(email);
+    console.log(source_default.green(`\u2713 Removed ${email} from organization`));
+  })
+);
+
+// src/commands/zero/org/leave.ts
+init_esm_shims();
+var leaveCommand = new Command().name("leave").description("Leave the current organization").action(
+  withErrorHandler(async () => {
+    await leaveZeroOrg();
+    const { orgs } = await listZeroOrgs();
+    if (orgs.length === 0) {
+      await saveConfig({ token: void 0 });
+      console.log(source_default.green("\u2713 Left organization."));
+      console.log(
+        source_default.yellow("No remaining organizations. Run: vm0 auth login")
+      );
+      return;
+    }
+    const nextOrg = orgs[0].slug;
+    const result = await switchZeroOrg(nextOrg);
+    await saveConfig({
+      token: result.access_token
+    });
+    console.log(source_default.green(`\u2713 Left organization. Switched to: ${nextOrg}`));
+  })
+);
+
+// src/commands/zero/org/delete.ts
+init_esm_shims();
+var deleteCommand = new Command().name("delete").description("Delete the current organization (admin only)").argument("<slug>", "Organization slug to confirm deletion").action(
+  withErrorHandler(async (slug) => {
+    await deleteZeroOrg(slug);
+    console.log(source_default.green(`\u2713 Organization '${slug}' has been deleted.`));
+  })
+);
+
+// src/commands/zero/org/secret/index.ts
+init_esm_shims();
+
+// src/commands/zero/org/secret/list.ts
+init_esm_shims();
+var listCommand2 = new Command().name("list").alias("ls").description("List all org-level secrets").action(
+  withErrorHandler(async () => {
+    const result = await listZeroOrgSecrets();
+    if (result.secrets.length === 0) {
+      console.log(source_default.dim("No org secrets found"));
+      console.log();
+      console.log("To add an org secret:");
+      console.log(
+        source_default.cyan("  zero org secret set MY_API_KEY --body <value>")
+      );
+      return;
+    }
+    console.log(source_default.bold("Org Secrets:"));
+    console.log();
+    for (const secret of result.secrets) {
+      console.log(`  ${source_default.cyan(secret.name)}`);
+      if (secret.description) {
+        console.log(`    ${source_default.dim(secret.description)}`);
+      }
+      console.log(
+        `    ${source_default.dim(`Updated: ${new Date(secret.updatedAt).toLocaleString()}`)}`
+      );
+      console.log();
+    }
+    console.log(source_default.dim(`Total: ${result.secrets.length} secret(s)`));
+  })
+);
+
+// src/commands/zero/org/secret/set.ts
+init_esm_shims();
+var setCommand2 = new Command().name("set").description("Create or update an org-level secret (admin only)").argument("<name>", "Secret name (uppercase, e.g., MY_API_KEY)").option(
+  "-b, --body <value>",
+  "Secret value (required in non-interactive mode)"
+).option("-d, --description <description>", "Optional description").action(
+  withErrorHandler(
+    async (name, options) => {
+      let value;
+      if (options.body !== void 0) {
+        value = options.body;
+      } else if (isInteractive()) {
+        const prompted = await promptPassword("Enter secret value:");
+        if (prompted === void 0) {
+          console.log(source_default.dim("Cancelled"));
+          return;
+        }
+        value = prompted;
+      } else {
+        throw new Error("--body is required in non-interactive mode", {
+          cause: new Error(
+            `Usage: zero org secret set ${name} --body "your-secret-value"`
+          )
+        });
+      }
+      let secret;
+      try {
+        secret = await setZeroOrgSecret({
+          name,
+          value,
+          description: options.description
+        });
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("must contain only uppercase")) {
+          throw new Error(error.message, {
+            cause: new Error(
+              "Examples of valid secret names: MY_API_KEY, GITHUB_TOKEN, AWS_ACCESS_KEY_ID"
+            )
+          });
+        }
+        throw error;
+      }
+      console.log(source_default.green(`\u2713 Org secret "${secret.name}" saved`));
+    }
+  )
+);
+
+// src/commands/zero/org/secret/remove.ts
+init_esm_shims();
+var removeCommand2 = new Command().name("remove").description("Delete an org-level secret (admin only)").argument("<name>", "Secret name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+  withErrorHandler(async (name, options) => {
+    if (!options.yes) {
+      if (!isInteractive()) {
+        throw new Error("--yes flag is required in non-interactive mode");
+      }
+      const confirmed = await promptConfirm(
+        `Are you sure you want to delete org secret "${name}"?`,
+        false
+      );
+      if (!confirmed) {
+        console.log(source_default.dim("Cancelled"));
+        return;
+      }
+    }
+    await deleteZeroOrgSecret(name);
+    console.log(source_default.green(`\u2713 Org secret "${name}" deleted`));
+  })
+);
+
+// src/commands/zero/org/secret/index.ts
+var zeroOrgSecretCommand = new Command().name("secret").description("Manage org-level secrets (admin)").addCommand(listCommand2).addCommand(setCommand2).addCommand(removeCommand2);
+
+// src/commands/zero/org/variable/index.ts
+init_esm_shims();
+
+// src/commands/zero/org/variable/list.ts
+init_esm_shims();
+function truncateValue(value, maxLength = 60) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return value.slice(0, maxLength - 15) + "... [truncated]";
+}
+var listCommand3 = new Command().name("list").alias("ls").description("List all org-level variables").action(
+  withErrorHandler(async () => {
+    const result = await listZeroOrgVariables();
+    if (result.variables.length === 0) {
+      console.log(source_default.dim("No org variables found"));
+      console.log();
+      console.log("To add an org variable:");
+      console.log(source_default.cyan("  zero org variable set MY_VAR <value>"));
+      return;
+    }
+    console.log(source_default.bold("Org Variables:"));
+    console.log();
+    for (const variable of result.variables) {
+      const displayValue = truncateValue(variable.value);
+      console.log(`  ${source_default.cyan(variable.name)} = ${displayValue}`);
+      if (variable.description) {
+        console.log(`    ${source_default.dim(variable.description)}`);
+      }
+      console.log(
+        `    ${source_default.dim(`Updated: ${new Date(variable.updatedAt).toLocaleString()}`)}`
+      );
+      console.log();
+    }
+    console.log(source_default.dim(`Total: ${result.variables.length} variable(s)`));
+  })
+);
+
+// src/commands/zero/org/variable/set.ts
+init_esm_shims();
+var setCommand3 = new Command().name("set").description("Create or update an org-level variable (admin only)").argument("<name>", "Variable name (uppercase, e.g., MY_VAR)").argument("<value>", "Variable value").option("-d, --description <description>", "Optional description").action(
+  withErrorHandler(
+    async (name, value, options) => {
+      let variable;
+      try {
+        variable = await setZeroOrgVariable({
+          name,
+          value,
+          description: options.description
+        });
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("must contain only uppercase")) {
+          throw new Error(error.message, {
+            cause: new Error(
+              "Examples of valid variable names: MY_VAR, API_URL, DEBUG_MODE"
+            )
+          });
+        }
+        throw error;
+      }
+      console.log(source_default.green(`\u2713 Org variable "${variable.name}" saved`));
+    }
+  )
+);
+
+// src/commands/zero/org/variable/remove.ts
+init_esm_shims();
+var removeCommand3 = new Command().name("remove").description("Delete an org-level variable (admin only)").argument("<name>", "Variable name to delete").option("-y, --yes", "Skip confirmation prompt").action(
+  withErrorHandler(async (name, options) => {
+    if (!options.yes) {
+      if (!isInteractive()) {
+        throw new Error("--yes flag is required in non-interactive mode");
+      }
+      const confirmed = await promptConfirm(
+        `Are you sure you want to delete org variable "${name}"?`,
+        false
+      );
+      if (!confirmed) {
+        console.log(source_default.dim("Cancelled"));
+        return;
+      }
+    }
+    await deleteZeroOrgVariable(name);
+    console.log(source_default.green(`\u2713 Org variable "${name}" deleted`));
+  })
+);
+
+// src/commands/zero/org/variable/index.ts
+var zeroOrgVariableCommand = new Command().name("variable").description("Manage org-level variables (admin)").addCommand(listCommand3).addCommand(setCommand3).addCommand(removeCommand3);
+
+// src/commands/zero/org/model-provider/index.ts
+init_esm_shims();
+
+// src/commands/zero/org/model-provider/list.ts
+init_esm_shims();
+function createListCommand(options = {}) {
+  const scopeLabel = options.scopeLabel ?? "org-level";
+  const title = options.title ?? "Org Model Providers";
+  const setupCommand2 = options.setupCommand ?? "zero org model-provider setup";
+  return new Command().name("list").alias("ls").description(`List all ${scopeLabel} model providers`).action(
+    withErrorHandler(async () => {
+      const result = await listZeroOrgModelProviders();
+      if (result.modelProviders.length === 0) {
+        console.log(source_default.dim(`No ${scopeLabel} model providers configured`));
+        console.log();
+        console.log(`To add a ${scopeLabel} model provider:`);
+        console.log(source_default.cyan(`  ${setupCommand2}`));
+        return;
+      }
+      const byFramework = result.modelProviders.reduce(
+        (acc, p) => {
+          const fw = p.framework;
+          if (!acc[fw]) {
+            acc[fw] = [];
+          }
+          acc[fw].push(p);
+          return acc;
+        },
+        {}
+      );
+      console.log(source_default.bold(`${title}:`));
+      console.log();
+      for (const [framework, providers] of Object.entries(byFramework)) {
+        console.log(`  ${source_default.cyan(framework)}:`);
+        for (const provider of providers) {
+          console.log(`    ${provider.type}`);
+          console.log(source_default.dim(`      ID: ${provider.id}`));
+          console.log(
+            source_default.dim(
+              `      Updated: ${new Date(provider.updatedAt).toLocaleString()}`
+            )
+          );
+        }
+        console.log();
+      }
+      console.log(
+        source_default.dim(`Total: ${result.modelProviders.length} provider(s)`)
+      );
+    })
+  );
+}
+var listCommand4 = createListCommand();
+
+// src/commands/zero/org/model-provider/setup.ts
+init_esm_shims();
+var import_prompts2 = __toESM(require_prompts(), 1);
+
+// src/lib/domain/model-provider/shared.ts
+init_esm_shims();
+var import_prompts = __toESM(require_prompts(), 1);
+function validateProviderType(typeStr) {
+  if (!Object.keys(MODEL_PROVIDER_TYPES).includes(typeStr)) {
+    const validTypes = Object.keys(MODEL_PROVIDER_TYPES).join(", ");
+    throw new Error(`Invalid type "${typeStr}"`, {
+      cause: new Error(`Valid types: ${validTypes}`)
+    });
+  }
+  return typeStr;
+}
+function validateAuthMethod(type, authMethodStr) {
+  const authMethods = getAuthMethodsForType(type);
+  if (!authMethods || !(authMethodStr in authMethods)) {
+    const validMethods = authMethods ? Object.keys(authMethods).join(", ") : "none";
+    throw new Error(`Invalid auth method "${authMethodStr}"`, {
+      cause: new Error(`Valid auth methods: ${validMethods}`)
+    });
+  }
+  return authMethodStr;
+}
+function parseSecrets(type, authMethod, secretArgs) {
+  const secretsConfig = getSecretsForAuthMethod(type, authMethod);
+  if (!secretsConfig) {
+    throw new Error(`Invalid auth method "${authMethod}"`);
+  }
+  const secretNames = Object.keys(secretsConfig);
+  const firstArg = secretArgs[0];
+  if (secretArgs.length === 1 && firstArg && !firstArg.includes("=")) {
+    if (secretNames.length !== 1) {
+      throw new Error(
+        "Must use KEY=VALUE format for multi-secret auth methods",
+        { cause: new Error(`Required secrets: ${secretNames.join(", ")}`) }
+      );
+    }
+    const firstSecretName = secretNames[0];
+    if (!firstSecretName) {
+      throw new Error("No secrets defined for this auth method");
+    }
+    return { [firstSecretName]: firstArg };
+  }
+  const secrets = {};
+  for (const arg of secretArgs) {
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex === -1) {
+      throw new Error(`Invalid secret format "${arg}"`, {
+        cause: new Error("Use KEY=VALUE format (e.g., AWS_REGION=us-east-1)")
+      });
+    }
+    const key = arg.slice(0, eqIndex);
+    const value = arg.slice(eqIndex + 1);
+    secrets[key] = value;
+  }
+  return secrets;
+}
+function validateSecrets(type, authMethod, secrets) {
+  const secretsConfig = getSecretsForAuthMethod(type, authMethod);
+  if (!secretsConfig) {
+    throw new Error(`Invalid auth method "${authMethod}"`);
+  }
+  for (const [name, fieldConfig] of Object.entries(secretsConfig)) {
+    if (fieldConfig.required && !secrets[name]) {
+      const requiredNames = Object.entries(secretsConfig).filter(([, fc]) => {
+        return fc.required;
+      }).map(([n]) => {
+        return n;
+      }).join(", ");
+      throw new Error(`Missing required secret: ${name}`, {
+        cause: new Error(`Required secrets: ${requiredNames}`)
+      });
+    }
+  }
+  for (const name of Object.keys(secrets)) {
+    if (!(name in secretsConfig)) {
+      const validNames = Object.keys(secretsConfig).join(", ");
+      throw new Error(`Unknown secret: ${name}`, {
+        cause: new Error(`Valid secrets: ${validNames}`)
+      });
+    }
+  }
+}
+function handleNonInteractiveMode(options) {
+  const type = validateProviderType(options.type);
+  const cmdPrefix = options.commandPrefix ?? "zero org model-provider setup";
+  if (hasAuthMethods(type)) {
+    let authMethod;
+    if (options.authMethod) {
+      authMethod = validateAuthMethod(type, options.authMethod);
+    } else {
+      const defaultAuthMethod = getDefaultAuthMethod(type);
+      const authMethods = getAuthMethodsForType(type);
+      if (!defaultAuthMethod || !authMethods) {
+        throw new Error(`Provider "${type}" requires --auth-method`);
+      }
+      const authMethodNames = Object.keys(authMethods);
+      if (authMethodNames.length === 1) {
+        authMethod = authMethodNames[0];
+      } else {
+        const methods = authMethodNames.join(", ");
+        throw new Error(
+          `--auth-method is required for "${type}" (multiple auth methods available)`,
+          {
+            cause: new Error(
+              `Available: ${methods}. Example: ${cmdPrefix} --type ${type} --auth-method ${authMethodNames[0]} --secret KEY=VALUE`
+            )
+          }
+        );
+      }
+    }
+    const secrets = parseSecrets(type, authMethod, options.secret);
+    validateSecrets(type, authMethod, secrets);
+    return {
+      type,
+      authMethod,
+      secrets,
+      isInteractiveMode: false
+    };
+  }
+  const secretArgs = options.secret;
+  const firstArg = secretArgs[0];
+  if (!firstArg) {
+    throw new Error("Secret is required");
+  }
+  let secret;
+  if (firstArg.includes("=")) {
+    secret = firstArg.slice(firstArg.indexOf("=") + 1);
+  } else {
+    secret = firstArg;
+  }
+  return {
+    type,
+    secret,
+    isInteractiveMode: false
+  };
+}
+async function promptForAuthMethod(type) {
+  const authMethods = getAuthMethodsForType(type);
+  const defaultAuthMethod = getDefaultAuthMethod(type);
+  if (!authMethods) {
+    return "default";
+  }
+  const choices = Object.entries(authMethods).map(([method, config]) => {
+    return {
+      title: method === defaultAuthMethod ? `${config.label} (Recommended)` : config.label,
+      value: method
+    };
+  });
+  const response = await (0, import_prompts.default)(
+    {
+      type: "select",
+      name: "authMethod",
+      message: "Select authentication method:",
+      choices
+    },
+    {
+      onCancel: () => {
+        return process.exit(0);
+      }
+    }
+  );
+  return response.authMethod;
+}
+function isSensitiveSecret(name) {
+  const nonSecretPatterns = ["REGION", "ENDPOINT", "URL"];
+  return !nonSecretPatterns.some((pattern) => {
+    return name.toUpperCase().includes(pattern);
+  });
+}
+async function promptForSecrets(type, authMethod) {
+  const secretsConfig = getSecretsForAuthMethod(type, authMethod);
+  if (!secretsConfig) {
+    throw new Error(`Invalid auth method "${authMethod}"`);
+  }
+  const secrets = {};
+  for (const [name, fieldConfig] of Object.entries(secretsConfig)) {
+    if (fieldConfig.helpText) {
+      console.log(source_default.dim(fieldConfig.helpText));
+    }
+    const isSensitive = isSensitiveSecret(name);
+    const placeholder = "placeholder" in fieldConfig ? fieldConfig.placeholder : "";
+    if (fieldConfig.required) {
+      const response = await (0, import_prompts.default)(
+        {
+          type: isSensitive ? "password" : "text",
+          name: "value",
+          message: `${fieldConfig.label}:`,
+          initial: placeholder ? "" : void 0,
+          validate: (value) => {
+            return value.length > 0 || `${fieldConfig.label} is required`;
+          }
+        },
+        {
+          onCancel: () => {
+            return process.exit(0);
+          }
+        }
+      );
+      secrets[name] = response.value;
+    } else {
+      const response = await (0, import_prompts.default)(
+        {
+          type: isSensitive ? "password" : "text",
+          name: "value",
+          message: `${fieldConfig.label} (optional):`
+        },
+        {
+          onCancel: () => {
+            return process.exit(0);
+          }
+        }
+      );
+      const value = response.value;
+      if (value && value.trim()) {
+        secrets[name] = value.trim();
+      }
+    }
+  }
+  return secrets;
+}
+function collectSecrets(value, previous) {
+  return previous.concat([value]);
+}
+
+// src/commands/zero/org/model-provider/setup.ts
+async function handleInteractiveMode(commandPrefix) {
+  if (!isInteractive()) {
+    throw new Error("Interactive mode requires a TTY", {
+      cause: new Error(
+        `Use non-interactive mode: ${commandPrefix} --type <type> --secret "<value>"`
+      )
+    });
+  }
+  let cancelled = false;
+  const onCancel = () => {
+    cancelled = true;
+    return false;
+  };
+  const { modelProviders: configuredProviders } = await listZeroOrgModelProviders();
+  const configuredTypes = new Set(
+    configuredProviders.map((p) => {
+      return p.type;
+    })
+  );
+  const annotatedChoices = getSelectableProviderTypes().map((type2) => {
+    const config2 = MODEL_PROVIDER_TYPES[type2];
+    const isConfigured = configuredTypes.has(type2);
+    const isExperimental = hasAuthMethods(type2);
+    let title = config2.label;
+    if (isConfigured) {
+      title = `${title} \u2713`;
+    }
+    if (isExperimental) {
+      title = `${title} ${source_default.dim("(experimental)")}`;
+    }
+    return {
+      title,
+      value: type2
+    };
+  });
+  const typeResponse = await (0, import_prompts2.default)(
+    {
+      type: "select",
+      name: "type",
+      message: "Select provider type:",
+      choices: annotatedChoices
+    },
+    { onCancel }
+  );
+  if (cancelled) {
+    console.log(source_default.dim("Cancelled"));
+    return null;
+  }
+  const type = typeResponse.type;
+  const existingProvider = configuredProviders.find((p) => {
+    return p.type === type;
+  });
+  if (existingProvider) {
+    console.log();
+    console.log(`"${type}" is already configured`);
+    console.log();
+    const actionResponse = await (0, import_prompts2.default)(
+      {
+        type: "select",
+        name: "action",
+        message: "",
+        choices: [
+          { title: "Keep existing secret", value: "keep" },
+          { title: "Update secret", value: "update" }
+        ]
+      },
+      { onCancel }
+    );
+    if (cancelled) {
+      console.log(source_default.dim("Cancelled"));
+      return null;
+    }
+    if (actionResponse.action === "keep") {
+      return {
+        type,
+        keepExistingSecret: true,
+        isInteractiveMode: true
+      };
+    }
+  }
+  const config = MODEL_PROVIDER_TYPES[type];
+  console.log();
+  if ("helpText" in config) {
+    console.log(source_default.dim(config.helpText));
+  }
+  console.log();
+  if (hasAuthMethods(type)) {
+    const authMethod = await promptForAuthMethod(type);
+    const secrets = await promptForSecrets(type, authMethod);
+    return {
+      type,
+      authMethod,
+      secrets,
+      isInteractiveMode: true
+    };
+  }
+  const secretLabel = "secretLabel" in config ? config.secretLabel : "secret";
+  const secretResponse = await (0, import_prompts2.default)(
+    {
+      type: "password",
+      name: "secret",
+      message: `Enter your ${secretLabel}:`,
+      validate: (value) => {
+        return value.length > 0 || `${secretLabel} is required`;
+      }
+    },
+    { onCancel }
+  );
+  if (cancelled) {
+    console.log(source_default.dim("Cancelled"));
+    return null;
+  }
+  const secret = secretResponse.secret;
+  return { type, secret, isInteractiveMode: true };
+}
+function createSetupCommand(options = {}) {
+  const commandPrefix = options.commandPrefix ?? "zero org model-provider setup";
+  const description = options.description ?? "Configure an org-level model provider";
+  const scopeLabel = options.scopeLabel ?? "Org";
+  return new Command().name("setup").description(description).option("-t, --type <type>", "Provider type (for non-interactive mode)").option(
+    "-s, --secret <value>",
+    "Secret value (can be used multiple times, supports VALUE or KEY=VALUE format)",
+    collectSecrets,
+    []
+  ).option(
+    "-a, --auth-method <method>",
+    "Auth method (required for multi-auth providers like aws-bedrock)"
+  ).action(
+    withErrorHandler(
+      async (options2) => {
+        let input;
+        const secretArgs = options2.secret ?? [];
+        if (options2.type && secretArgs.length > 0) {
+          input = handleNonInteractiveMode({
+            type: options2.type,
+            secret: secretArgs,
+            authMethod: options2.authMethod,
+            commandPrefix
+          });
+        } else if (options2.type || secretArgs.length > 0) {
+          throw new Error("Both --type and --secret are required");
+        } else {
+          const result = await handleInteractiveMode(commandPrefix);
+          if (result === null) {
+            return;
+          }
+          input = result;
+        }
+        if (input.keepExistingSecret) {
+          console.log(
+            source_default.green(
+              `\u2713 ${scopeLabel} model provider "${input.type}" unchanged`
+            )
+          );
+          return;
+        }
+        const { created } = await upsertZeroOrgModelProvider({
+          type: input.type,
+          secret: input.secret,
+          authMethod: input.authMethod,
+          secrets: input.secrets
+        });
+        const action = created ? "created" : "updated";
+        console.log(
+          source_default.green(
+            `\u2713 ${scopeLabel} model provider "${input.type}" ${action}`
+          )
+        );
+      }
+    )
+  );
+}
+var setupCommand = createSetupCommand();
+
+// src/commands/zero/org/model-provider/remove.ts
+init_esm_shims();
+function createRemoveCommand(options = {}) {
+  const scopeLabel = options.scopeLabel ?? "Org";
+  return new Command().name("remove").description(`Remove a ${scopeLabel.toLowerCase()} model provider`).argument("<type>", "Model provider type to remove").action(
+    withErrorHandler(async (type) => {
+      if (!Object.keys(MODEL_PROVIDER_TYPES).includes(type)) {
+        const validTypes = Object.keys(MODEL_PROVIDER_TYPES).join(", ");
+        throw new Error(`Invalid type "${type}"`, {
+          cause: new Error(`Valid types: ${validTypes}`)
+        });
+      }
+      await deleteZeroOrgModelProvider(type);
+      console.log(
+        source_default.green(`\u2713 ${scopeLabel} model provider "${type}" removed`)
+      );
+    })
+  );
+}
+var removeCommand4 = createRemoveCommand();
+
+// src/commands/zero/org/model-provider/index.ts
+var zeroOrgModelProviderCommand = new Command().name("model-provider").description("Manage org-level model providers").addCommand(
+  createListCommand({
+    scopeLabel: "org-level",
+    title: "Org Model Providers",
+    setupCommand: "zero org model-provider setup"
+  })
+).addCommand(
+  createSetupCommand({
+    commandPrefix: "zero org model-provider setup",
+    description: "Configure an org-level model provider",
+    scopeLabel: "Org"
+  })
+).addCommand(createRemoveCommand({ scopeLabel: "Org" }));
+
+// src/commands/zero/org/index.ts
+var zeroOrgCommand = new Command().name("org").description("Manage organization settings, members, and providers").addCommand(statusCommand).addCommand(setCommand).addCommand(listCommand).addCommand(useCommand).addCommand(membersCommand).addCommand(inviteCommand).addCommand(removeCommand).addCommand(leaveCommand).addCommand(deleteCommand).addCommand(zeroOrgSecretCommand).addCommand(zeroOrgVariableCommand).addCommand(zeroOrgModelProviderCommand);
+export {
+  zeroOrgCommand
+};
+//# sourceMappingURL=org-QLHP7UVC.js.map