@moda-ai/cli 1.55.10 → 1.55.11

package/dist/cli-g7ferymy.js

@@ -0,0 +1,496 @@
+import {
+  ApiError,
+  callControlAPI,
+  callDataAPI
+} from "./cli-tmqd1f0m.js";
+import {
+  isPlatformApiKey,
+  setPlatformTenantOverride
+} from "./cli-m16taf4z.js";
+import {
+  CliAccessError,
+  CliInputError,
+  embeddedTenantIdFromApiKey,
+  resolveApiKey,
+  resolveApiTenantId
+} from "./cli-429zt7g4.js";
+
+// src/parity-commands.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var WINDOWS = ["24h", "7d", "30d", "90d"];
+function profileOptions(context) {
+  return { profile: context.profile, env: context.env };
+}
+function requireKey(context) {
+  if (!resolveApiKey(profileOptions(context))) {
+    throw new CliInputError(`No Moda API key found for moda ${context.command}.`, "Set MODA_API_KEY, run `moda auth login --api-key`, or select a profile with an API key.");
+  }
+}
+function requireTenant(context) {
+  const key = resolveApiKey(profileOptions(context));
+  const keyTenant = key ? embeddedTenantIdFromApiKey(key) : undefined;
+  const flagTenant = context.flags["tenant-id"];
+  if (flagTenant && keyTenant && flagTenant !== keyTenant) {
+    throw new CliInputError(`--tenant-id=${flagTenant} does not match this API key's tenant (${keyTenant}), so nothing was sent.`, "Drop --tenant-id (the key names its tenant) or use a key for that tenant.");
+  }
+  const tenantId = flagTenant || resolveApiTenantId(profileOptions(context));
+  if (!tenantId) {
+    throw new CliInputError("Could not determine the tenant.", "Use a signed API key (it names its tenant), set MODA_TENANT_ID, or pass --tenant-id=<id>.");
+  }
+  if (isPlatformApiKey(key))
+    setPlatformTenantOverride(tenantId);
+  return tenantId;
+}
+function assertFlags(command, flags, allowed) {
+  if (command.startsWith("signals "))
+    allowed = [...allowed, "tenant-id"];
+  const globals = [
+    "agent",
+    "json",
+    "human",
+    "prose",
+    "quiet",
+    "verbose",
+    "yes",
+    "profile",
+    "progress",
+    "format",
+    "no-telemetry",
+    "no-update-check",
+    "help",
+    "version",
+    "json-schemas",
+    "stream",
+    "no-stream",
+    "tui",
+    "no-tui"
+  ];
+  const known = new Set([...allowed, ...globals]);
+  const unknown = Object.keys(flags).filter((flag) => !known.has(flag));
+  if (unknown.includes("dry-run")) {
+    throw new CliInputError(`'moda ${command}' has no dry-run mode, so nothing was sent.`, "Remove --dry-run to run it for real.");
+  }
+  if (unknown.length > 0) {
+    throw new CliInputError(`Unknown flag${unknown.length > 1 ? "s" : ""} ${unknown.map((flag) => `--${flag}`).join(", ")} for 'moda ${command}'.`, `Valid flags: ${allowed.map((flag) => `--${flag}`).join(", ") || "(none)"}.`);
+  }
+}
+function assertPositionals(command, positionals, max, usage) {
+  if (positionals.length > max) {
+    throw new CliInputError(`Unexpected argument${positionals.length - max > 1 ? "s" : ""} '${positionals.slice(max).join(" ")}' for 'moda ${command}', so nothing was sent.`, `Usage: ${usage}`);
+  }
+}
+function oneOf(name, value, allowed) {
+  if (value === undefined)
+    return;
+  if (!allowed.includes(value)) {
+    throw new CliInputError(`--${name} must be one of ${allowed.join(", ")} (got '${value}').`);
+  }
+  return value;
+}
+function csv(value) {
+  if (value === undefined)
+    return;
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+function readBodyFile(flags, cwd) {
+  if (!flags.file)
+    return {};
+  if (flags.file === "true")
+    throw new CliInputError("Missing path for --file.");
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolve(cwd, flags.file), "utf8"));
+  } catch (error) {
+    throw new CliInputError(`Could not read --file ${flags.file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliInputError("--file must contain a JSON object (the request body).");
+  }
+  return parsed;
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+var LLM_WRITE_TIMEOUT_MS = 180000;
+async function send(context, plane, method, endpoint, body, options = {}) {
+  const init = { method, ...body !== undefined ? { body: JSON.stringify(body) } : {} };
+  if (method !== "GET" && context.dryRun) {
+    context.output.writeData({
+      dryRun: true,
+      planned: { method, endpoint: plane === "data" ? `/api/v1/data${endpoint}` : `/api${endpoint}`, ...body !== undefined ? { body } : {} }
+    }, { summary: { text: `Dry run: would ${method} ${endpoint}. Nothing was sent.`, confidence: "high" } });
+    return;
+  }
+  const requestOptions = method === "GET" ? {} : { retries: 0, ...options.slow ? { timeoutMs: LLM_WRITE_TIMEOUT_MS } : {} };
+  const data = plane === "data" ? await callDataAPI(endpoint, init, requestOptions) : await callControlAPI(endpoint, init, profileOptions(context), requestOptions);
+  context.output.writeData(data ?? { ok: true });
+}
+var USER_COHORTS = ["all", "power_users", "heavy_tool_users", "frustrated", "at_risk", "new_this_week", "silent_sufferers"];
+var USER_SORTS = ["last_seen", "health_score", "conversation_count", "frustration_max"];
+var HEALTH = ["healthy", "at_risk", "frustrated"];
+async function runUsersCommand(context) {
+  const flags = context.flags;
+  assertFlags("users", flags, [
+    "window",
+    "page",
+    "page-size",
+    "limit",
+    "search",
+    "cohort",
+    "sort",
+    "order",
+    "health-status",
+    "min-health",
+    "max-health",
+    "min-conversations",
+    "min-tool-failures",
+    "tenant-id"
+  ]);
+  if (context.positionals.length > 0) {
+    throw new CliInputError(`'moda users' takes no arguments. For one user use 'moda user <user_id>'.`);
+  }
+  if (flags.limit !== undefined && flags["page-size"] !== undefined && flags.limit !== flags["page-size"]) {
+    throw new CliInputError(`Got --limit=${flags.limit} and --page-size=${flags["page-size"]}; they are the same flag for 'moda users', so nothing was sent.`, "Pass only one of --limit / --page-size.", "flag_conflict");
+  }
+  requireKey(context);
+  const tenantId = requireTenant(context);
+  const query = new URLSearchParams(compact({
+    window: oneOf("window", flags.window, WINDOWS),
+    page: flags.page,
+    pageSize: flags["page-size"] ?? flags.limit,
+    search: flags.search,
+    cohort: oneOf("cohort", flags.cohort, USER_COHORTS),
+    sortBy: oneOf("sort", flags.sort, USER_SORTS),
+    sortOrder: oneOf("order", flags.order, ["asc", "desc"]),
+    healthStatus: csv(flags["health-status"])?.map((value) => oneOf("health-status", value, HEALTH)).join(","),
+    minHealthScore: flags["min-health"],
+    maxHealthScore: flags["max-health"],
+    minConversations: flags["min-conversations"],
+    minToolFailures: flags["min-tool-failures"]
+  }));
+  const suffix = query.toString() ? `?${query.toString()}` : "";
+  await send(context, "control", "GET", `/tenants/${encodeURIComponent(tenantId)}/users${suffix}`);
+  return { exitCode: 0 };
+}
+async function runUserCommand(context) {
+  const flags = context.flags;
+  assertFlags("user", flags, ["window", "activity-cursor", "tenant-id"]);
+  assertPositionals("user", context.positionals, 1, "moda user <user_id> [--window=24h|7d|30d|90d]");
+  const userId = context.positionals[0];
+  if (!userId)
+    throw new CliInputError("<user_id> is required.", "Usage: moda user <user_id> [--window=24h|7d|30d|90d]");
+  requireKey(context);
+  const tenantId = requireTenant(context);
+  const query = new URLSearchParams(compact({
+    window: oneOf("window", flags.window, WINDOWS),
+    activityCursor: flags["activity-cursor"]
+  }));
+  const suffix = query.toString() ? `?${query.toString()}` : "";
+  await send(context, "control", "GET", `/tenants/${encodeURIComponent(tenantId)}/users/${encodeURIComponent(userId)}${suffix}`);
+  return { exitCode: 0 };
+}
+async function runProblemReopenCommand(context) {
+  assertFlags("problem-reopen", context.flags, ["reason", "dry-run"]);
+  assertPositionals("problem-reopen", context.positionals, 1, "moda problem-reopen <problem_id> [--reason=TEXT]");
+  const problemId = context.positionals[0];
+  const usage = "Usage: moda problem-reopen <problem_id> [--reason=TEXT]";
+  if (!problemId || !UUID_RE.test(problemId))
+    throw new CliInputError("<problem_id> (UUID) is required.", usage);
+  const reason = context.flags.reason;
+  if (reason !== undefined && reason.length > 500)
+    throw new CliInputError("--reason must be 500 characters or fewer.");
+  requireKey(context);
+  await send(context, "data", "POST", `/problems/${problemId}/reopen`, compact({ reason }));
+  return { exitCode: 0 };
+}
+var SIGNAL_FIELD_FLAGS = [
+  "name",
+  "description",
+  "pass-criteria",
+  "fail-criteria",
+  "polarity",
+  "locus",
+  "tool-names",
+  "keyword-hints",
+  "use-case-id",
+  "message-types",
+  "note",
+  "file"
+];
+function signalBody(flags, cwd) {
+  const fromFile = readBodyFile(flags, cwd);
+  const scope = compact({
+    toolNames: csv(flags["tool-names"]),
+    keywordHints: csv(flags["keyword-hints"]),
+    useCaseId: flags["use-case-id"],
+    messageTypes: csv(flags["message-types"])
+  });
+  return {
+    ...fromFile,
+    ...compact({
+      name: flags.name,
+      description: flags.description,
+      passCriteria: flags["pass-criteria"],
+      failCriteria: flags["fail-criteria"],
+      polarity: oneOf("polarity", flags.polarity, ["violation", "expectation"]),
+      locus: oneOf("locus", flags.locus, ["agent", "tool_output", "user_input"]),
+      note: flags.note
+    }),
+    ...Object.keys(scope).length > 0 ? { scope: { ...fromFile.scope ?? {}, ...scope } } : {}
+  };
+}
+var SIGNAL_USAGE = [
+  "moda signals                                   list custom signals",
+  'moda signals draft --note="…"                  AI-draft criteria from a description',
+  "moda signals create --name --description --pass-criteria --fail-criteria [--polarity --locus --tool-names=a,b] [--file=body.json]",
+  "moda signals update <id> [same flags]           edit a signal",
+  "moda signals activate|pause|delete <id>          (delete: drafts only; archive is dashboard-only)",
+  "moda signals examples <id> add|update|remove --conversation-id=ID [--label=fits|does_not_fit --note --msg-index]",
+  'moda signals refine <id> --request="…"          propose a criteria edit',
+  "moda signals revise <id> --conversation-ids=a,b re-derive criteria from labelled traces",
+  "moda signals proposals <id> | accept <id> <proposal_id> | reject <id> <proposal_id>",
+  "moda signals search <id> [--mode=wizard|full] | search-status <id> <search_id> | search-stop <id> <search_id>",
+  "moda signals preview --file=detector.json [--conversation-ids=a,b --max-examples=N]",
+  "All write subcommands accept --dry-run (prints the request, sends nothing)."
+].join(`
+  `);
+async function runSignalsManagementCommand(sub, context) {
+  const flags = context.flags;
+  const args = context.positionals.slice(1);
+  const arity = {
+    draft: 0,
+    create: 0,
+    preview: 0,
+    update: 1,
+    activate: 1,
+    pause: 1,
+    delete: 1,
+    examples: 2,
+    refine: 1,
+    revise: 1,
+    proposals: 1,
+    accept: 2,
+    reject: 2,
+    search: 1,
+    "search-status": 2,
+    "search-stop": 2
+  };
+  if (sub in arity)
+    assertPositionals(`signals ${sub}`, args, arity[sub], SIGNAL_USAGE.split(`
+`)[0]);
+  const base = () => `/tenants/${encodeURIComponent(requireTenant(context))}/custom-signals`;
+  const id = (index = 0, what = "a signal id") => {
+    const value = args[index];
+    if (!value)
+      throw new CliInputError(`moda signals ${sub} needs ${what}.`, `Usage:
+  ${SIGNAL_USAGE}`);
+    return encodeURIComponent(value);
+  };
+  const start = () => requireKey(context);
+  switch (sub) {
+    case "draft": {
+      assertFlags("signals draft", flags, ["note", "file", "dry-run"]);
+      const body = { ...readBodyFile(flags, context.cwd), ...compact({ note: flags.note }) };
+      if (!body.note)
+        throw new CliInputError("--note is required (describe what the signal should catch).");
+      start();
+      await send(context, "control", "POST", `${base()}/draft`, body, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "create": {
+      assertFlags("signals create", flags, [...SIGNAL_FIELD_FLAGS, "dry-run"]);
+      const body = signalBody(flags, context.cwd);
+      const missing = ["name", "description", "passCriteria", "failCriteria"].filter((field) => !body[field]);
+      if (missing.length > 0) {
+        throw new CliInputError(`Missing ${missing.join(", ")} for signals create.`, 'Pass --name --description --pass-criteria --fail-criteria, or a --file with those fields. Tip: `moda signals draft --note="…"` drafts them.');
+      }
+      start();
+      await send(context, "control", "POST", base(), body);
+      return { exitCode: 0 };
+    }
+    case "update": {
+      assertFlags("signals update", flags, [...SIGNAL_FIELD_FLAGS, "dry-run"]);
+      const signalId = id();
+      const body = signalBody(flags, context.cwd);
+      if (Object.keys(body).length === 0)
+        throw new CliInputError("Nothing to update: pass at least one field flag or --file.");
+      start();
+      await send(context, "control", "PATCH", `${base()}/${signalId}`, body);
+      return { exitCode: 0 };
+    }
+    case "activate":
+    case "pause": {
+      assertFlags(`signals ${sub}`, flags, ["dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/${sub}`);
+      return { exitCode: 0 };
+    }
+    case "delete": {
+      assertFlags("signals delete", flags, ["dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "DELETE", `${base()}/${signalId}`);
+      return { exitCode: 0 };
+    }
+    case "examples": {
+      const signalId = id();
+      const action = args[1];
+      const conversationId = flags["conversation-id"];
+      if (!action || !["add", "update", "remove"].includes(action)) {
+        throw new CliInputError("Usage: moda signals examples <id> add|update|remove --conversation-id=ID …");
+      }
+      if (!conversationId)
+        throw new CliInputError("--conversation-id is required.");
+      if (action === "add") {
+        assertFlags("signals examples add", flags, ["conversation-id", "label", "note", "msg-index", "msg-dedup-token", "criteria", "verdict", "dry-run"]);
+        const label = oneOf("label", flags.label, ["fits", "does_not_fit"]);
+        if (!label)
+          throw new CliInputError("--label=fits|does_not_fit is required.");
+        start();
+        await send(context, "control", "POST", `${base()}/${signalId}/examples`, compact({
+          conversationId,
+          label,
+          source: "api",
+          note: flags.note,
+          msgIndex: flags["msg-index"] !== undefined ? Number(flags["msg-index"]) : undefined,
+          msgDedupToken: flags["msg-dedup-token"],
+          criteria: oneOf("criteria", flags.criteria, ["pass", "fail"]),
+          verdict: oneOf("verdict", flags.verdict, ["accept", "reject"])
+        }));
+      } else if (action === "update") {
+        assertFlags("signals examples update", flags, ["conversation-id", "label", "note", "blurb", "dry-run"]);
+        const body = compact({ label: oneOf("label", flags.label, ["fits", "does_not_fit"]), note: flags.note, blurb: flags.blurb });
+        if (Object.keys(body).length === 0)
+          throw new CliInputError("Nothing to update: pass --label, --note, or --blurb.");
+        start();
+        await send(context, "control", "PATCH", `${base()}/${signalId}/examples/${encodeURIComponent(conversationId)}`, body);
+      } else {
+        assertFlags("signals examples remove", flags, ["conversation-id", "dry-run"]);
+        start();
+        await send(context, "control", "DELETE", `${base()}/${signalId}/examples/${encodeURIComponent(conversationId)}`);
+      }
+      return { exitCode: 0 };
+    }
+    case "refine": {
+      assertFlags("signals refine", flags, ["request", "dry-run"]);
+      const signalId = id();
+      const request = flags.request;
+      if (!request || request.length > 2000)
+        throw new CliInputError("--request (1–2000 characters) is required.");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/refine`, { request }, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "revise": {
+      assertFlags("signals revise", flags, ["conversation-ids", "dry-run"]);
+      const signalId = id();
+      const conversationIds = csv(flags["conversation-ids"]);
+      if (!conversationIds)
+        throw new CliInputError("--conversation-ids=a,b is required.");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/revise`, { conversationIds }, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "proposals": {
+      assertFlags("signals proposals", flags, []);
+      const signalId = id();
+      start();
+      await send(context, "control", "GET", `${base()}/${signalId}/proposals`);
+      return { exitCode: 0 };
+    }
+    case "accept":
+    case "reject": {
+      assertFlags(`signals ${sub}`, flags, ["dry-run"]);
+      const signalId = id();
+      const proposalId = id(1, "a proposal id (see `moda signals proposals <id>`)");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/proposals/${proposalId}/${sub}`);
+      return { exitCode: 0 };
+    }
+    case "search": {
+      assertFlags("signals search", flags, ["mode", "exclude-conversation-ids", "dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/search`, compact({
+        mode: oneOf("mode", flags.mode, ["wizard", "full"]),
+        excludeConversationIds: csv(flags["exclude-conversation-ids"])
+      }), { slow: true });
+      return { exitCode: 0 };
+    }
+    case "search-status":
+    case "search-stop": {
+      assertFlags(`signals ${sub}`, flags, sub === "search-stop" ? ["dry-run"] : []);
+      const signalId = id();
+      const searchId = id(1, "a search id (returned by `moda signals search <id>`)");
+      start();
+      await send(context, "control", sub === "search-stop" ? "POST" : "GET", `${base()}/${signalId}/searches/${searchId}${sub === "search-stop" ? "/stop" : ""}`);
+      return { exitCode: 0 };
+    }
+    case "preview": {
+      assertFlags("signals preview", flags, ["file", "conversation-ids", "max-examples"]);
+      const body = readBodyFile(flags, context.cwd);
+      if (!body.detector)
+        throw new CliInputError('--file must contain {"detector": {...}} (optionally scope).');
+      start();
+      try {
+        await send(context, "control", "POST", `${base()}/detector-preview`, {
+          ...body,
+          ...compact({
+            conversationIds: csv(flags["conversation-ids"]),
+            maxExamples: flags["max-examples"] !== undefined ? Number(flags["max-examples"]) : undefined
+          })
+        });
+      } catch (error) {
+        if (isTenantFeatureNotFound(error)) {
+          throw new CliAccessError("The signal builder is not enabled for this tenant, so `moda signals preview` is unavailable (the API answered 404).", { guidance: "Ask Moda to enable the signal-builder feature for this tenant. Other `moda signals` subcommands still work." });
+        }
+        throw error;
+      }
+      return { exitCode: 0 };
+    }
+    default:
+      throw unknownSignalsSubcommandError(sub, args);
+  }
+}
+function isTenantFeatureNotFound(error) {
+  if (!(error instanceof ApiError) || error.statusCode !== 404)
+    return false;
+  try {
+    const body = JSON.parse(error.responseBody);
+    return body.message === "Not Found" && body.error === undefined;
+  } catch {
+    return false;
+  }
+}
+var SIGNALS_MANAGEMENT_SUBCOMMANDS = new Set([
+  "draft",
+  "create",
+  "update",
+  "activate",
+  "pause",
+  "delete",
+  "examples",
+  "refine",
+  "revise",
+  "proposals",
+  "accept",
+  "reject",
+  "search",
+  "search-status",
+  "search-stop",
+  "preview"
+]);
+function unknownSignalsSubcommandError(sub, args = []) {
+  if (sub === "archive") {
+    const id = args[0] ?? "<signal_id>";
+    return new CliInputError(`Unknown signals subcommand 'archive': archiving a signal is dashboard-only, so nothing was sent.`, `To stop a signal from running, pause it: moda signals pause ${id}. Drafts can be deleted with moda signals delete ${id}.`);
+  }
+  return new CliInputError(`Unknown signals subcommand '${sub}', so nothing was sent. Valid subcommands: ${[...SIGNALS_MANAGEMENT_SUBCOMMANDS].join(", ")}.`, `Bare 'moda signals' lists custom signals; 'moda signal <signal_id>' opens one. Usage:
+  ${SIGNAL_USAGE}`);
+}
+
+export { requireTenant, assertFlags, assertPositionals, runUsersCommand, runUserCommand, runProblemReopenCommand, runSignalsManagementCommand, SIGNALS_MANAGEMENT_SUBCOMMANDS, unknownSignalsSubcommandError };

package/dist/cli-k5qqj2bp.js

@@ -0,0 +1,70 @@
+import {
+  createCliOutput,
+  outputModeFromFlags
+} from "./cli-429zt7g4.js";
+
+// src/command-context.ts
+function flagEnabled(flags, key) {
+  return flags[key] === "true";
+}
+var BOOLEAN_TRUE_WORDS = new Set(["true", "yes", "1", "on"]);
+var BOOLEAN_FALSE_WORDS = new Set(["false", "no", "0", "off"]);
+function parseBooleanFlagValue(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value === 1 ? true : value === 0 ? false : undefined;
+  if (typeof value !== "string")
+    return;
+  const text = value.trim().toLowerCase();
+  if (BOOLEAN_TRUE_WORDS.has(text))
+    return true;
+  if (BOOLEAN_FALSE_WORDS.has(text))
+    return false;
+  return;
+}
+function stringOption(value) {
+  if (value === undefined || value === null)
+    return;
+  const text = String(value).trim();
+  return text.length > 0 ? text : undefined;
+}
+function createCommandContext(input, options = {}) {
+  const flags = options.commandFlags ?? input.flags;
+  const rawFlags = options.rawFlags ?? input.flags;
+  const outputMode = options.outputMode ?? outputModeFromFlags(flags);
+  const quiet = flagEnabled(flags, "quiet");
+  const interactive = outputMode === "human" && !quiet && !flagEnabled(flags, "yes") && process.stdin.isTTY === true && process.stderr.isTTY === true;
+  const telemetryMeta = {};
+  return {
+    command: options.commandName ?? input.command,
+    positional: input.positional,
+    positionals: input.positionals,
+    flags,
+    rawFlags,
+    ...input.bareFlags ? { bareFlags: input.bareFlags } : {},
+    startedAt: options.startedAt ?? Date.now(),
+    cwd: options.cwd ?? process.cwd(),
+    env: options.env ?? process.env,
+    outputMode,
+    output: createCliOutput({
+      command: options.commandName ?? input.command,
+      mode: outputMode,
+      quiet
+    }),
+    profile: flags.profile,
+    dryRun: flagEnabled(flags, "dry-run"),
+    yes: flagEnabled(flags, "yes"),
+    quiet,
+    verbose: flagEnabled(flags, "verbose"),
+    interactive,
+    recordTelemetry(meta) {
+      Object.assign(telemetryMeta, meta);
+    },
+    getTelemetryMeta() {
+      return telemetryMeta;
+    }
+  };
+}
+
+export { parseBooleanFlagValue, stringOption, createCommandContext };

package/dist/cli-m16taf4z.js

@@ -0,0 +1,30 @@
+import {
+  resolveTenantId
+} from "./cli-429zt7g4.js";
+
+// src/api-key-headers.ts
+var PLATFORM_API_KEY_PREFIX = "moda_pk_";
+var TENANT_HEADER = "x-moda-tenant-id";
+function isPlatformApiKey(key) {
+  return Boolean(key?.startsWith(PLATFORM_API_KEY_PREFIX));
+}
+var platformTenantOverride;
+function setPlatformTenantOverride(tenantId) {
+  platformTenantOverride = tenantId;
+}
+var TENANT_PATH = /\/tenants\/([^/?#]+)/;
+function tenantFromUrl(url) {
+  const match = url ? TENANT_PATH.exec(url) : null;
+  return match ? decodeURIComponent(match[1]) : undefined;
+}
+function apiKeyHeaders(key, options = {}, url) {
+  const headers = { "x-api-key": key };
+  if (isPlatformApiKey(key)) {
+    const tenantId = tenantFromUrl(url) || platformTenantOverride || resolveTenantId(options);
+    if (tenantId)
+      headers[TENANT_HEADER] = tenantId;
+  }
+  return headers;
+}
+
+export { isPlatformApiKey, setPlatformTenantOverride, apiKeyHeaders };