@kashdao/cli 0.1.0

package/dist/config-XJL5TSYK.js

@@ -0,0 +1,690 @@
+#!/usr/bin/env node
+import {
+  createTable,
+  redact
+} from "./chunk-BRK7KJ4O.js";
+import {
+  cliConfigSchema,
+  cliFileSchema,
+  deleteConfig,
+  deleteProfile,
+  listProfiles,
+  readConfig,
+  readWholeFile,
+  resolveConfigPathsForOverride,
+  setCurrentProfile,
+  updateConfig,
+  writeWholeFile
+} from "./chunk-KMBMQIZ7.js";
+import "./chunk-YHCG2SUC.js";
+import {
+  readGlobals
+} from "./chunk-LBIRQHX5.js";
+import {
+  log,
+  print,
+  printJson,
+  style
+} from "./chunk-VIADBYFY.js";
+import "./chunk-MIXOZU2S.js";
+import {
+  CliError,
+  CliValidationError,
+  toCliError
+} from "./chunk-UZNSYATZ.js";
+
+// src/commands/config/index.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/config/export.ts
+import { writeFile } from "fs/promises";
+import { Command } from "commander";
+var REDACTED = "<redacted>";
+var exportConfigCommand = new Command("export").description("Dump the entire multi-profile config (API keys redacted by default).").option("-o, --out <path>", "write to a file instead of stdout (mode 0600)").option("--include-secrets", "include raw API keys in the export (round-trippable)").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config export                                    # safe-by-default; redacted JSON to stdout
+  $ kash config export --out kash-config.json             # write to a file (mode 0600)
+  $ kash config export --include-secrets --out kash.json  # round-trippable (DO NOT commit)
+
+Notes:
+  - Without --include-secrets, every \`apiKey\` is replaced with \`${REDACTED}\` \u2014
+    safe to commit and share for debugging without leaking credentials.
+  - The output is the canonical input for \`kash config import\`. Imports
+    refuse to apply a profile whose apiKey is still \`${REDACTED}\`.
+  - Use --out to route to a file the CLI can write at mode 0600. Stdout
+    inherits whatever umask the parent shell has.
+`
+).action(async (options, cmd) => {
+  const globals = readGlobals(cmd);
+  try {
+    const file = await readWholeFile({
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+    const sanitized = {
+      ...file,
+      profiles: Object.fromEntries(
+        Object.entries(file.profiles).map(([name, profile]) => [
+          name,
+          sanitizeProfile(profile, options.includeSecrets ?? false)
+        ])
+      )
+    };
+    const payload = JSON.stringify(sanitized, null, 2);
+    if (options.out) {
+      try {
+        await writeFile(options.out, `${payload}
+`, { encoding: "utf8", mode: 384 });
+        if (!globals.json) {
+          log.success(`Wrote ${options.out} (mode 0600).`);
+          if (!options.includeSecrets) {
+            log.info(
+              `Secrets redacted. Pass --include-secrets to produce a round-trippable export.`
+            );
+          }
+        }
+      } catch (cause) {
+        throw new CliError(`Failed to write ${options.out}.`, {
+          code: "CONFIGURATION",
+          recoverable: true,
+          suggestion: "Verify the path is writable and the parent directory exists.",
+          cause
+        });
+      }
+      return;
+    }
+    if (globals.json) {
+      printJson(sanitized);
+    } else {
+      if (!options.includeSecrets) {
+        log.info(`API keys redacted. Pass --include-secrets for round-trippable export.`);
+      }
+      print(payload);
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+function sanitizeProfile(profile, includeSecrets) {
+  if (includeSecrets) return profile;
+  if (profile.apiKey === void 0) return profile;
+  return { ...profile, apiKey: REDACTED };
+}
+
+// src/commands/config/import.ts
+import { readFile } from "fs/promises";
+import { Command as Command2 } from "commander";
+var importConfigCommand = new Command2("import").description("Merge a `kash config export` bundle into the local config (mode 0600).").argument("[file]", "path to a JSON bundle (omit to read from stdin)").option("--no-overwrite", "skip profiles whose name already exists locally").option("--dry-run", "preview the merge without writing to disk").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config import kash.json
+  $ kash config export --include-secrets | ssh prod-host kash config import
+  $ kash config import kash.json --no-overwrite       # never replace existing profiles
+  $ kash config import kash.json --dry-run --json     # preview the merged result
+
+Notes:
+  - The input format is exactly what \`kash config export\` produces.
+  - Profiles whose apiKey is still \`${REDACTED}\` are refused \u2014 re-export
+    with --include-secrets to get a round-trippable bundle.
+  - --dry-run emits the merged file shape without persisting it. Useful
+    for diffing against the on-disk file before committing to a write.
+`
+).action(async (file, options, cmd) => {
+  const globals = readGlobals(cmd);
+  try {
+    const raw = await readSource(file);
+    validateRedactionRaw(raw);
+    const parsed = parseAndValidate(raw);
+    const existing = await readWholeFile({
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+    const merged = mergeFiles(existing, parsed, options.overwrite === false);
+    if (options.dryRun === true) {
+      if (globals.json) {
+        printJson({ merged, written: false });
+      } else {
+        log.info("Dry run \u2014 no changes written.");
+        print(JSON.stringify(merged, null, 2));
+      }
+      return;
+    }
+    await writeWholeFile(merged, {
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+    if (globals.json) {
+      printJson({
+        merged,
+        written: true,
+        profiles: Object.keys(merged.profiles).sort(),
+        currentProfile: merged.currentProfile ?? null
+      });
+      return;
+    }
+    const importedNames = Object.keys(parsed.profiles);
+    const merged_n = Object.keys(merged.profiles).length;
+    log.success(
+      `Imported ${String(importedNames.length)} profile(s); local config now has ${String(merged_n)} profile(s).`
+    );
+    if (merged.currentProfile) {
+      log.info(`Active profile: ${style.bold(merged.currentProfile)}`);
+    }
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+});
+async function readSource(file) {
+  if (file !== void 0) {
+    try {
+      return await readFile(file, "utf8");
+    } catch (cause) {
+      throw new CliError(`Failed to read ${file}.`, {
+        code: "CONFIGURATION",
+        recoverable: true,
+        suggestion: "Verify the path exists and is readable.",
+        cause
+      });
+    }
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    if (typeof chunk === "string") {
+      chunks.push(Buffer.from(chunk));
+    } else if (chunk instanceof Buffer) {
+      chunks.push(chunk);
+    } else {
+      chunks.push(Buffer.from(chunk));
+    }
+  }
+  if (chunks.length === 0) {
+    throw new CliError("No input received on stdin.", {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion: "Pass a path argument or pipe a `kash config export` bundle into stdin."
+    });
+  }
+  const { stripBom } = await import("./stdin-YW2CEQXU.js");
+  return stripBom(Buffer.concat(chunks).toString("utf8"));
+}
+function parseAndValidate(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new CliError("Input is not valid JSON.", {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion: "The bundle must match the output of `kash config export`. Re-run that command and pipe the result.",
+      cause
+    });
+  }
+  const result = cliFileSchema.safeParse(parsed);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    throw new CliError(
+      `Input does not match the config file shape${first ? `: ${first.path.join(".")}: ${first.message}` : "."}`,
+      {
+        code: "INVALID_INPUT",
+        recoverable: true,
+        suggestion: "Re-export from a known-good machine via `kash config export`."
+      }
+    );
+  }
+  return result.data;
+}
+function validateRedactionRaw(raw) {
+  if (raw.includes(`"apiKey": "${REDACTED}"`)) {
+    throw new CliError("Bundle contains redacted API keys \u2014 cannot import.", {
+      code: "INVALID_INPUT",
+      recoverable: true,
+      suggestion: "Re-run `kash config export --include-secrets` on the source machine to produce a round-trippable bundle."
+    });
+  }
+}
+function mergeFiles(existing, incoming, noOverwrite) {
+  const profiles = { ...existing.profiles };
+  for (const [name, profile] of Object.entries(incoming.profiles)) {
+    if (noOverwrite && name in profiles) continue;
+    profiles[name] = profile;
+  }
+  let currentProfile = existing.currentProfile;
+  if (incoming.currentProfile && incoming.currentProfile in profiles) {
+    currentProfile = incoming.currentProfile;
+  }
+  return {
+    version: 1,
+    ...currentProfile === void 0 ? {} : { currentProfile },
+    profiles
+  };
+}
+
+// src/commands/config/profiles.ts
+import { Command as Command3 } from "commander";
+var profilesCommand = new Command3("profiles").description("List configured profiles in the config file.").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config profiles
+  $ kash config profiles --json --quiet | jq -r '.profiles[]'
+`
+).action(async (_opts, cmd) => {
+  const globals = readGlobals(cmd);
+  let result;
+  try {
+    result = await listProfiles({
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (globals.json) {
+    printJson(result);
+    return;
+  }
+  if (result.profiles.length === 0) {
+    log.info("No profiles configured.");
+    log.detail("Hint", "Run 'kash auth set-key <key>' to create the default profile.");
+    return;
+  }
+  const table = createTable(["Active", "Profile"]);
+  for (const name of result.profiles) {
+    table.push([name === result.current ? style.success("\u2022") : " ", name]);
+  }
+  print(table.toString());
+});
+
+// src/commands/config/remove.ts
+import { Command as Command4 } from "commander";
+var removeProfileCommand = new Command4("remove").description("Delete a named profile from the config file.").argument("<profile>", "profile name to remove").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config remove staging
+  $ kash config remove old-profile --json --quiet
+`
+).action(async (profile, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  let updated;
+  try {
+    updated = await deleteProfile(profile, {
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (globals.json) {
+    printJson({
+      ok: true,
+      removed: profile,
+      profiles: Object.keys(updated.profiles).sort()
+    });
+    return;
+  }
+  log.success(`Profile "${profile}" removed.`);
+});
+
+// src/commands/config/reset.ts
+import readline from "readline/promises";
+import { Command as Command5 } from "commander";
+var resetConfigCommand = new Command5("reset").description("Delete ~/.kash/config.json.").option("-y, --yes", "skip the interactive confirmation").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config reset
+  $ kash config reset --yes --json --quiet
+`
+).action(async (options, cmd) => {
+  const globals = readGlobals(cmd);
+  const paths = resolveConfigPathsForOverride(globals.configPath);
+  const interactive = process.stdin.isTTY && !globals.quiet && !globals.json;
+  const confirmed = options.yes || !interactive ? true : await confirm(paths.file);
+  if (!confirmed) {
+    log.info("Aborted.");
+    return;
+  }
+  try {
+    await deleteConfig({
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (globals.json) {
+    printJson({ ok: true, deleted: paths.file });
+    return;
+  }
+  log.success(`Deleted ${paths.file}.`);
+});
+async function confirm(path) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question(`Delete ${path}? [y/N] `);
+    return answer.trim().toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/config/set.ts
+import { Command as Command6 } from "commander";
+var TOP_LEVEL_KEYS = [
+  // Kash-orchestrated
+  "apiKey",
+  "baseUrl",
+  "defaultChainId",
+  // Direct mode
+  "rpcUrl",
+  "smartAccount",
+  "bundlerUrl",
+  "bundlerProvider",
+  "signerKeyRef"
+];
+var CUSTOM_CHAIN_LEAVES = [
+  "name",
+  "factoryAddress",
+  "usdcAddress",
+  "oracleAddress",
+  "vaultAddress",
+  "tokens1155Address",
+  "paramRegistryAddress"
+];
+var CUSTOM_CHAIN_SA_LEAVES = [
+  "factoryAddress",
+  "implementationAddress",
+  "entryPointAddress"
+];
+var ALL_KEYS_FOR_HELP = [
+  ...TOP_LEVEL_KEYS,
+  ...CUSTOM_CHAIN_LEAVES.map((l) => `customChain.${l}`),
+  ...CUSTOM_CHAIN_SA_LEAVES.map((l) => `customChain.smartAccount.${l}`)
+];
+var setConfigCommand = new Command6("set").description("Set a single config field.").argument(
+  "<key>",
+  "top-level key OR `customChain.<leaf>` / `customChain.smartAccount.<leaf>` dot-path"
+).argument("<value>", "value to set").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config set baseUrl https://api-staging.kash.bot/v1 --profile staging
+  $ kash config set defaultChainId 84532 --profile staging
+
+Direct-mode (kash protocol \u2026):
+  $ kash config set rpcUrl https://base-mainnet.g.alchemy.com/v2/... --profile mm
+  $ kash config set smartAccount 0xabc... --profile mm
+  $ kash config set signerKeyRef file:~/.kash/keys/mm-owner.key --profile mm
+  $ kash config set bundlerProvider flashbots --profile mm
+
+Custom chain (local Anvil / forks / sidechains, bypasses static registry):
+  $ kash config set defaultChainId 31337 --profile anvil
+  $ kash config set rpcUrl http://localhost:8545 --profile anvil
+  $ kash config set customChain.name "Anvil local" --profile anvil
+  $ kash config set customChain.factoryAddress 0xCf7Ed... --profile anvil
+  $ kash config set customChain.usdcAddress 0x5FbDB... --profile anvil
+  $ kash config set customChain.smartAccount.factoryAddress 0x3Aa5e... --profile anvil
+`
+).action(async (key, value, _opts, cmd) => {
+  const globals = readGlobals(cmd);
+  let patch;
+  try {
+    patch = await buildPatchForKey(key, value, {
+      ...globals.profile === void 0 ? {} : { profile: globals.profile },
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  let result;
+  try {
+    result = await updateConfig(patch, {
+      ...globals.profile === void 0 ? {} : { profile: globals.profile },
+      ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+    });
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (globals.json) {
+    const top = key.split(".", 1)[0];
+    printJson({
+      ok: true,
+      key,
+      value: result.stored[top] ?? null,
+      profile: result.profile
+    });
+    return;
+  }
+  log.success(`Set ${key} on profile "${result.profile}".`);
+});
+function isTopLevelKey(value) {
+  return TOP_LEVEL_KEYS.includes(value);
+}
+function isCustomChainLeaf(value) {
+  return CUSTOM_CHAIN_LEAVES.includes(value);
+}
+function isCustomChainSaLeaf(value) {
+  return CUSTOM_CHAIN_SA_LEAVES.includes(value);
+}
+async function buildPatchForKey(key, value, readOpts) {
+  if (isTopLevelKey(key)) {
+    return buildTopLevelPatch(key, value);
+  }
+  if (key.startsWith("customChain.")) {
+    const existing = await readConfig(readOpts);
+    const existingChain = existing.customChain ?? {};
+    const merged = mergeCustomChainLeaf(existingChain, key, value);
+    const candidate = { customChain: merged };
+    cliConfigSchema.parse(candidate);
+    return candidate;
+  }
+  throw new CliValidationError(
+    `Unknown config key "${key}".`,
+    `Allowed keys: ${ALL_KEYS_FOR_HELP.join(", ")}.`
+  );
+}
+function buildTopLevelPatch(key, value) {
+  switch (key) {
+    case "apiKey":
+    case "baseUrl":
+    case "rpcUrl":
+    case "smartAccount":
+    case "bundlerUrl":
+    case "bundlerProvider":
+    case "signerKeyRef": {
+      const candidate = { [key]: value };
+      cliConfigSchema.parse(candidate);
+      return candidate;
+    }
+    case "defaultChainId": {
+      const n = Number.parseInt(value, 10);
+      if (!Number.isFinite(n) || n <= 0) {
+        throw new CliValidationError(
+          "defaultChainId must be a positive integer.",
+          void 0,
+          "defaultChainId"
+        );
+      }
+      const candidate = { defaultChainId: n };
+      cliConfigSchema.parse(candidate);
+      return candidate;
+    }
+  }
+}
+function mergeCustomChainLeaf(existing, key, value) {
+  const path = key.slice("customChain.".length);
+  if (path.startsWith("smartAccount.")) {
+    const leaf = path.slice("smartAccount.".length);
+    if (!isCustomChainSaLeaf(leaf)) {
+      throw new CliValidationError(
+        `Unknown customChain.smartAccount leaf "${leaf}".`,
+        `Allowed: ${CUSTOM_CHAIN_SA_LEAVES.map((l) => `customChain.smartAccount.${l}`).join(", ")}.`
+      );
+    }
+    const sa = existing.smartAccount ?? {};
+    return {
+      ...existing,
+      smartAccount: { ...sa, [leaf]: value }
+    };
+  }
+  if (!isCustomChainLeaf(path)) {
+    throw new CliValidationError(
+      `Unknown customChain leaf "${path}".`,
+      `Allowed: ${CUSTOM_CHAIN_LEAVES.map((l) => `customChain.${l}`).join(", ")}, customChain.smartAccount.<leaf>.`
+    );
+  }
+  return {
+    ...existing,
+    [path]: value
+  };
+}
+
+// src/commands/config/show.ts
+import { Command as Command7 } from "commander";
+var showConfigCommand = new Command7("show").description("Print the resolved CLI configuration.").addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config show
+  $ kash config show --profile staging
+  $ kash config show --json --quiet | jq -r '.baseUrl'
+`
+).action(async (_opts, cmd) => {
+  const globals = readGlobals(cmd);
+  const config = await readConfig({
+    ...globals.profile === void 0 ? {} : { profile: globals.profile },
+    ...globals.configPath === void 0 ? {} : { configPath: globals.configPath }
+  });
+  if (globals.json) {
+    printJson({
+      profile: config.profile,
+      authenticated: Boolean(config.apiKey),
+      apiKey: config.apiKey ? redact(config.apiKey) : null,
+      baseUrl: config.baseUrl,
+      defaultChainId: config.defaultChainId,
+      rpcUrl: config.rpcUrl ?? null,
+      smartAccount: config.smartAccount ?? null,
+      bundlerUrl: config.bundlerUrl ?? null,
+      bundlerProvider: config.bundlerProvider ?? null,
+      signerKeyRef: config.signerKeyRef ?? null,
+      customChain: config.customChain ?? null,
+      sources: config.sources
+    });
+    return;
+  }
+  print("");
+  print(`  ${style.dim("Profile        ")} ${config.profile} (${config.sources.profile})`);
+  print(
+    `  ${style.dim("API key        ")} ${config.apiKey ? redact(config.apiKey) : "(unset)"} (${config.sources.apiKey})`
+  );
+  print(`  ${style.dim("Base URL       ")} ${config.baseUrl} (${config.sources.baseUrl})`);
+  print(
+    `  ${style.dim("Default chain  ")} ${String(config.defaultChainId)} (${config.sources.defaultChainId})`
+  );
+  const hasDirectMode = config.rpcUrl !== void 0 || config.smartAccount !== void 0 || config.bundlerUrl !== void 0 || config.bundlerProvider !== void 0 || config.signerKeyRef !== void 0;
+  if (hasDirectMode) {
+    print("");
+    print(`  ${style.dim("Direct mode    ")}`);
+    print(
+      `  ${style.dim("  RPC URL      ")} ${config.rpcUrl ?? "(unset)"} (${config.sources.rpcUrl})`
+    );
+    print(
+      `  ${style.dim("  Smart account")} ${config.smartAccount ?? "(unset)"} (${config.sources.smartAccount})`
+    );
+    print(
+      `  ${style.dim("  Bundler URL  ")} ${config.bundlerUrl ?? "(unset)"} (${config.sources.bundlerUrl})`
+    );
+    print(
+      `  ${style.dim("  Bundler kind ")} ${config.bundlerProvider ?? "(unset)"} (${config.sources.bundlerProvider})`
+    );
+    print(
+      `  ${style.dim("  Signer ref   ")} ${config.signerKeyRef ?? "(unset)"} (${config.sources.signerKeyRef})`
+    );
+  }
+  if (config.customChain !== void 0) {
+    const cc = config.customChain;
+    print("");
+    print(`  ${style.dim("Custom chain   ")} (${config.sources.customChain})`);
+    print(`  ${style.dim("  Name         ")} ${cc.name}`);
+    print(`  ${style.dim("  Factory      ")} ${cc.factoryAddress}`);
+    print(`  ${style.dim("  USDC         ")} ${cc.usdcAddress}`);
+    if (cc.oracleAddress) print(`  ${style.dim("  Oracle       ")} ${cc.oracleAddress}`);
+    if (cc.vaultAddress) print(`  ${style.dim("  Vault        ")} ${cc.vaultAddress}`);
+    if (cc.tokens1155Address) print(`  ${style.dim("  Tokens1155   ")} ${cc.tokens1155Address}`);
+    if (cc.paramRegistryAddress)
+      print(`  ${style.dim("  ParamRegistry")} ${cc.paramRegistryAddress}`);
+    if (cc.smartAccount) {
+      print(`  ${style.dim("  Smart account")}`);
+      print(`  ${style.dim("    Factory    ")} ${cc.smartAccount.factoryAddress}`);
+      print(`  ${style.dim("    Implement. ")} ${cc.smartAccount.implementationAddress}`);
+      print(`  ${style.dim("    EntryPoint ")} ${cc.smartAccount.entryPointAddress}`);
+    }
+  }
+});
+
+// src/commands/config/use.ts
+import { Command as Command8 } from "commander";
+var useProfileCommand = new Command8("use").description("Switch the active profile (writes currentProfile to the config file).").argument("<profile>", "profile name").option(
+  "--allow-new",
+  "permit switching to a profile that does not yet exist (you must populate it via `kash auth set-key --profile <name>` afterwards)"
+).addHelpText(
+  "after",
+  `
+Examples:
+  $ kash config use staging
+  $ kash config use prod --json --quiet
+  $ kash config use newprofile --allow-new   # explicitly create a fresh profile
+
+Notes:
+  - By default \`kash config use\` refuses unknown profile names and
+    lists the known ones \u2014 a typo of an existing profile name would
+    otherwise surface later as a confusing AUTH_REQUIRED.
+  - Use \`--allow-new\` for the bootstrapping flow when you genuinely
+    want to switch to a not-yet-populated profile.
+`
+).action(async (profile, options, cmd) => {
+  const globals = readGlobals(cmd);
+  const configPathOpt = globals.configPath === void 0 ? {} : { configPath: globals.configPath };
+  let knownProfiles;
+  try {
+    const file = await readWholeFile(configPathOpt);
+    knownProfiles = Object.keys(file.profiles).sort();
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (!knownProfiles.includes(profile) && options.allowNew !== true) {
+    const known = knownProfiles.length === 0 ? "(none yet)" : knownProfiles.join(", ");
+    throw new CliValidationError(
+      `Profile "${profile}" does not exist.`,
+      `Known profiles: ${known}. Pass --allow-new to create + switch to a fresh profile (you'll then need to populate it with \`kash auth set-key --profile ${profile}\`).`,
+      "profile"
+    );
+  }
+  let updated;
+  try {
+    updated = await setCurrentProfile(profile, configPathOpt);
+  } catch (cause) {
+    throw toCliError(cause);
+  }
+  if (globals.json) {
+    printJson({
+      ok: true,
+      currentProfile: updated.currentProfile,
+      profiles: Object.keys(updated.profiles).sort(),
+      // Surface whether this was a new-profile switch — agents can
+      // pipe to `kash auth set-key --profile <p>` automatically when
+      // `created` is true.
+      created: !knownProfiles.includes(profile)
+    });
+    return;
+  }
+  log.success(`Active profile is now "${profile}".`);
+  if (!knownProfiles.includes(profile)) {
+    log.info(`Profile is empty. Populate it with: kash auth set-key --profile ${profile} <key>`);
+  }
+});
+
+// src/commands/config/index.ts
+var configCommand = new Command9("config").description("Inspect and edit ~/.kash/config.json (multi-profile).").addCommand(showConfigCommand).addCommand(setConfigCommand).addCommand(profilesCommand).addCommand(useProfileCommand).addCommand(removeProfileCommand).addCommand(resetConfigCommand).addCommand(exportConfigCommand).addCommand(importConfigCommand);
+export {
+  configCommand
+};
+//# sourceMappingURL=config-XJL5TSYK.js.map