@order3000/cli 0.1.0 → 0.1.4

package/dist/cli.js

@@ -1,2537 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { defineCommand as defineCommand8, runCommand, showUsage as showUsage2 } from "citty";
-import { consola as consola7 } from "consola";
-import { ZodError } from "zod";
-
-// src/commands/auth/index.ts
-import { defineCommand as defineCommand6 } from "citty";
-
-// src/commands/auth/list.ts
-import { defineCommand } from "citty";
-import { consola } from "consola";
-
-// src/config/profile.ts
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
-import { dirname } from "path";
-
-// src/config/paths.ts
-import { homedir } from "os";
-import { join } from "path";
-var APP_NAME = "order3000";
-function xdgConfigHome() {
-  return process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-}
-function xdgCacheHome() {
-  return process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-}
-var paths = {
-  configDir: () => join(xdgConfigHome(), APP_NAME),
-  cacheDir: () => join(xdgCacheHome(), APP_NAME),
-  profilesFile: () => join(xdgConfigHome(), APP_NAME, "profiles.json"),
-  tokenCacheFile: () => join(xdgCacheHome(), APP_NAME, "tokens.json")
-};
-
-// src/config/schema.ts
-import { z } from "zod";
-var HTTPS_OR_LOCALHOST = /^https:\/\/|^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/;
-var profileSchema = z.object({
-  baseUrl: z.string().url().refine((url) => HTTPS_OR_LOCALHOST.test(url), {
-    message: "baseUrl must use HTTPS (or http://localhost for development)"
-  }),
-  clientId: z.string().min(1),
-  clientSecret: z.string().min(1).optional(),
-  useKeychain: z.boolean().optional(),
-  venueId: z.string().optional(),
-  venueAccessor: z.string().optional()
-}).refine((data) => Boolean(data.clientSecret) || data.useKeychain === true, {
-  message: "Profile must have a clientSecret on disk or useKeychain=true (secret in OS keychain)"
-});
-var profilesFileSchema = z.object({
-  profiles: z.record(z.string().min(1), profileSchema).default({}),
-  defaultProfile: z.string().optional()
-});
-
-// src/output/exit.ts
-var ExitCode = {
-  Ok: 0,
-  UserError: 1,
-  AuthError: 2,
-  NetworkError: 3,
-  ServerError: 4,
-  Unexpected: 99
-};
-
-// src/errors.ts
-var CLIError = class extends Error {
-  exitCode;
-  hint;
-  constructor(message, opts = {}) {
-    super(message);
-    this.name = "CLIError";
-    this.exitCode = opts.exitCode ?? ExitCode.UserError;
-    this.hint = opts.hint;
-  }
-};
-var AuthError = class extends CLIError {
-  constructor(message, hint) {
-    super(message, { exitCode: ExitCode.AuthError, hint });
-    this.name = "AuthError";
-  }
-};
-var NetworkError = class extends CLIError {
-  constructor(message, hint) {
-    super(message, { exitCode: ExitCode.NetworkError, hint });
-    this.name = "NetworkError";
-  }
-};
-var SECRET_LIKE_KEYS = /(secret|password|token|authorization|apikey|api_key)/i;
-function redactSecrets(value) {
-  if (Array.isArray(value)) {
-    return value.map(redactSecrets);
-  }
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = SECRET_LIKE_KEYS.test(k) ? "[redacted]" : redactSecrets(v);
-    }
-    return out;
-  }
-  return value;
-}
-
-// src/config/profile.ts
-var SECURE_FILE_MODE = 384;
-var SECURE_DIR_MODE = 448;
-var EMPTY = { profiles: {}, defaultProfile: void 0 };
-async function ensureSecureFile(path) {
-  const info = await stat(path);
-  const mode = info.mode & 511;
-  if (mode !== SECURE_FILE_MODE) {
-    throw new CLIError(
-      `Refusing to read ${path}: file mode is ${mode.toString(8)}, expected 600.`,
-      {
-        hint: `Run: chmod 600 ${path}`
-      }
-    );
-  }
-}
-async function readProfiles() {
-  const path = paths.profilesFile();
-  try {
-    await ensureSecureFile(path);
-  } catch (err) {
-    const e = err;
-    if (e.code === "ENOENT") return EMPTY;
-    throw err;
-  }
-  const raw = await readFile(path, "utf8");
-  const parsed = profilesFileSchema.safeParse(JSON.parse(raw));
-  if (!parsed.success) {
-    throw new CLIError(
-      `Invalid profiles file at ${path}: ${parsed.error.message}`,
-      {
-        hint: "Repair the file or run `order3000 auth login` to create a fresh profile."
-      }
-    );
-  }
-  return parsed.data;
-}
-async function writeProfiles(file) {
-  const path = paths.profilesFile();
-  await mkdir(dirname(path), { recursive: true, mode: SECURE_DIR_MODE });
-  const validated = profilesFileSchema.parse(file);
-  await writeFile(path, JSON.stringify(validated, null, 2), {
-    mode: SECURE_FILE_MODE
-  });
-}
-async function getProfile(name) {
-  const file = await readProfiles();
-  return file.profiles[name];
-}
-async function getDefaultProfileName() {
-  const file = await readProfiles();
-  return file.defaultProfile;
-}
-async function setProfile(name, profile) {
-  const file = await readProfiles();
-  const next = {
-    profiles: { ...file.profiles, [name]: profile },
-    defaultProfile: file.defaultProfile ?? name
-  };
-  await writeProfiles(next);
-}
-async function deleteProfile(name) {
-  const file = await readProfiles();
-  if (!file.profiles[name]) return;
-  const { [name]: _removed, ...rest } = file.profiles;
-  const nextDefault = file.defaultProfile === name ? Object.keys(rest)[0] : file.defaultProfile;
-  await writeProfiles({ profiles: rest, defaultProfile: nextDefault });
-}
-async function setDefaultProfile(name) {
-  const file = await readProfiles();
-  if (!file.profiles[name]) {
-    throw new CLIError(`Profile "${name}" does not exist.`);
-  }
-  await writeProfiles({ ...file, defaultProfile: name });
-}
-
-// src/commands/auth/list.ts
-var list_default = defineCommand({
-  meta: {
-    name: "list",
-    description: "List configured profiles"
-  },
-  args: {
-    json: {
-      type: "boolean",
-      description: "Emit JSON instead of pretty output",
-      default: false
-    }
-  },
-  async run({ args }) {
-    const file = await readProfiles();
-    const names = Object.keys(file.profiles);
-    if (args.json) {
-      process.stdout.write(
-        `${JSON.stringify(
-          {
-            defaultProfile: file.defaultProfile,
-            profiles: names.map((name) => ({
-              name,
-              isDefault: name === file.defaultProfile,
-              baseUrl: file.profiles[name].baseUrl,
-              venueId: file.profiles[name].venueId
-            }))
-          },
-          null,
-          2
-        )}
-`
-      );
-      return;
-    }
-    if (names.length === 0) {
-      consola.info(
-        "No profiles configured. Run `order3000 auth login` to create one."
-      );
-      return;
-    }
-    for (const name of names) {
-      const p = file.profiles[name];
-      const marker = name === file.defaultProfile ? "* " : "  ";
-      consola.log(
-        `${marker}${name}  ${p.baseUrl}${p.venueId ? `  venueId=${p.venueId}` : ""}`
-      );
-    }
-  }
-});
-
-// src/commands/auth/login.ts
-import { defineCommand as defineCommand2 } from "citty";
-import { consola as consola2 } from "consola";
-
-// src/auth/exchange.ts
-async function exchangeToken(creds) {
-  const url = `${creds.baseUrl}/auth/token`;
-  let res;
-  try {
-    res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        clientId: creds.clientId,
-        clientSecret: creds.clientSecret
-      }),
-      signal: AbortSignal.timeout(3e4)
-    });
-  } catch (err) {
-    throw new NetworkError(`Failed to reach ${url}: ${err.message}`);
-  }
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new AuthError(
-      `Token exchange failed: HTTP ${res.status} ${res.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`,
-      "Verify clientId/clientSecret and that the robot account is active."
-    );
-  }
-  return await res.json();
-}
-
-// src/auth/keychain.ts
-var SERVICE = "order3000-cli";
-var SECRET_PREFIX = "clientSecret:";
-var cached;
-async function load() {
-  if (cached && !("error" in cached)) return cached;
-  if (cached && "error" in cached) throw cached.error;
-  try {
-    cached = await import("@napi-rs/keyring");
-    return cached;
-  } catch (err) {
-    cached = { error: err };
-    throw new CLIError(`OS keychain unavailable: ${err.message}`, {
-      hint: "--keychain requires the npm install (`pnpm i -g @order3000/cli`); the Homebrew binary does not bundle native modules. Linux users also need libsecret (`apt install libsecret-1-dev gnome-keyring`). Otherwise, omit --keychain to use file-based storage."
-    });
-  }
-}
-function entryAccount(profile, kind) {
-  return `${SECRET_PREFIX === `${kind}:` ? "" : ""}${profile}`;
-}
-var keychain = {
-  /**
-   * Best-effort capability check. Returns false if the native binding is not
-   * loadable on this platform — callers can decide to degrade gracefully.
-   */
-  async isAvailable() {
-    try {
-      await load();
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  async setClientSecret(profile, secret) {
-    const mod = await load();
-    new mod.Entry(SERVICE, entryAccount(profile, "clientSecret")).setPassword(
-      secret
-    );
-  },
-  async getClientSecret(profile) {
-    const mod = await load();
-    try {
-      const value = new mod.Entry(
-        SERVICE,
-        entryAccount(profile, "clientSecret")
-      ).getPassword();
-      return value ?? void 0;
-    } catch {
-      return void 0;
-    }
-  },
-  async deleteClientSecret(profile) {
-    const mod = await load();
-    try {
-      return new mod.Entry(
-        SERVICE,
-        entryAccount(profile, "clientSecret")
-      ).deletePassword();
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/auth/token-cache.ts
-import { createHash } from "crypto";
-import { mkdir as mkdir2, readFile as readFile2, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-
-// src/auth/schema.ts
-import { z as z2 } from "zod";
-var cachedTokenSchema = z2.object({
-  accessToken: z2.string(),
-  expiresAt: z2.number().int().positive()
-});
-var tokenCacheFileSchema = z2.object({
-  tokens: z2.record(z2.string().min(1), cachedTokenSchema).default({})
-});
-
-// src/auth/token-cache.ts
-var SECURE_FILE_MODE2 = 384;
-var SECURE_DIR_MODE2 = 448;
-var EMPTY2 = { tokens: {} };
-function cacheKey(profileName, clientId, baseUrl) {
-  const fingerprint = createHash("sha256").update(`${clientId}::${baseUrl}`).digest("hex").slice(0, 16);
-  return `${profileName}.${fingerprint}`;
-}
-async function readFileIfExists() {
-  const path = paths.tokenCacheFile();
-  try {
-    await stat2(path);
-  } catch (err) {
-    if (err.code === "ENOENT") return EMPTY2;
-    throw err;
-  }
-  const raw = await readFile2(path, "utf8");
-  const parsed = tokenCacheFileSchema.safeParse(JSON.parse(raw));
-  return parsed.success ? parsed.data : EMPTY2;
-}
-async function writeFileSecure(file) {
-  const path = paths.tokenCacheFile();
-  await mkdir2(dirname2(path), { recursive: true, mode: SECURE_DIR_MODE2 });
-  await writeFile2(path, JSON.stringify(file, null, 2), {
-    mode: SECURE_FILE_MODE2
-  });
-}
-async function readCachedToken(profileName, clientId, baseUrl) {
-  const file = await readFileIfExists();
-  return file.tokens[cacheKey(profileName, clientId, baseUrl)];
-}
-async function writeCachedToken(profileName, clientId, baseUrl, token) {
-  const file = await readFileIfExists();
-  await writeFileSecure({
-    tokens: {
-      ...file.tokens,
-      [cacheKey(profileName, clientId, baseUrl)]: token
-    }
-  });
-}
-async function clearCachedToken(profileName, clientId, baseUrl) {
-  const file = await readFileIfExists();
-  const key = cacheKey(profileName, clientId, baseUrl);
-  if (!file.tokens[key]) return;
-  const { [key]: _removed, ...rest } = file.tokens;
-  await writeFileSecure({ tokens: rest });
-}
-async function clearAllCachedTokens() {
-  try {
-    await rm(paths.tokenCacheFile());
-  } catch (err) {
-    if (err.code !== "ENOENT") throw err;
-  }
-}
-
-// src/output/tty.ts
-var isTTY = () => Boolean(process.stdout.isTTY);
-
-// src/commands/auth/login.ts
-var login_default = defineCommand2({
-  meta: {
-    name: "login",
-    description: "Save credentials for an order3000 robot account into a named profile"
-  },
-  args: {
-    profile: {
-      type: "string",
-      description: "Profile name to create or update",
-      default: "default"
-    },
-    "client-id": { type: "string", description: "Robot account client ID" },
-    "client-secret": {
-      type: "string",
-      description: "Robot account client secret"
-    },
-    "base-url": {
-      type: "string",
-      description: "API base URL",
-      default: "https://order3000.com/api"
-    },
-    "venue-id": {
-      type: "string",
-      description: "Default venue ID for this profile (optional)"
-    },
-    "set-default": {
-      type: "boolean",
-      description: "Set this profile as the default after login",
-      default: false
-    },
-    "skip-verify": {
-      type: "boolean",
-      description: "Skip the credential verification round-trip",
-      default: false
-    },
-    keychain: {
-      type: "boolean",
-      description: "Store the client secret in the OS keychain instead of profiles.json",
-      default: false
-    }
-  },
-  async run({ args }) {
-    const profileName = args.profile;
-    let clientId = args["client-id"];
-    let clientSecret = args["client-secret"];
-    const baseUrl = args["base-url"];
-    const venueId = args["venue-id"];
-    if (!clientId || !clientSecret) {
-      if (!isTTY()) {
-        throw new CLIError(
-          "Non-interactive run requires --client-id and --client-secret (or env vars)."
-        );
-      }
-      if (!clientId) {
-        clientId = await consola2.prompt("Client ID:", {
-          type: "text"
-        });
-      }
-      if (!clientSecret) {
-        clientSecret = await consola2.prompt("Client secret:", {
-          type: "text"
-        });
-      }
-    }
-    if (!clientId || !clientSecret) {
-      throw new CLIError("Client ID and client secret are required.");
-    }
-    const useKeychain = Boolean(args.keychain);
-    if (useKeychain && !await keychain.isAvailable()) {
-      throw new CLIError(
-        "Cannot use --keychain: OS keychain backend is not available in this build.",
-        {
-          hint: "--keychain requires the npm install (`pnpm i -g @order3000/cli`); the Homebrew binary does not bundle native modules. Linux users also need libsecret. Otherwise, omit --keychain."
-        }
-      );
-    }
-    const fullCreds = {
-      baseUrl,
-      clientId,
-      clientSecret,
-      venueId: venueId || void 0
-    };
-    if (!args["skip-verify"]) {
-      consola2.start(`Verifying credentials against ${baseUrl}\u2026`);
-      const fresh = await exchangeToken(fullCreds);
-      const expiresAt = Date.now() + fresh.expiresIn * 1e3;
-      if (useKeychain) {
-        await keychain.setClientSecret(profileName, clientSecret);
-        await setProfile(profileName, {
-          baseUrl,
-          clientId,
-          useKeychain: true,
-          venueId: venueId || void 0
-        });
-      } else {
-        await setProfile(profileName, fullCreds);
-      }
-      await writeCachedToken(profileName, clientId, baseUrl, {
-        accessToken: fresh.accessToken,
-        expiresAt
-      });
-      consola2.success(
-        `Profile "${profileName}" saved${useKeychain ? " (secret in OS keychain)" : ""} and token cached.`
-      );
-    } else {
-      if (useKeychain) {
-        await keychain.setClientSecret(profileName, clientSecret);
-        await setProfile(profileName, {
-          baseUrl,
-          clientId,
-          useKeychain: true,
-          venueId: venueId || void 0
-        });
-      } else {
-        await setProfile(profileName, fullCreds);
-      }
-      consola2.success(
-        `Profile "${profileName}" saved${useKeychain ? " (secret in OS keychain)" : ""} (verification skipped).`
-      );
-    }
-    if (args["set-default"]) {
-      await setDefaultProfile(profileName);
-      consola2.info(`"${profileName}" is now the default profile.`);
-    }
-  }
-});
-
-// src/commands/auth/logout.ts
-import { defineCommand as defineCommand3 } from "citty";
-import { consola as consola3 } from "consola";
-var logout_default = defineCommand3({
-  meta: {
-    name: "logout",
-    description: "Remove a profile and its cached token (default: keep the profile, drop the token)"
-  },
-  args: {
-    profile: {
-      type: "string",
-      description: "Profile name to log out from",
-      required: true
-    },
-    "remove-profile": {
-      type: "boolean",
-      description: "Also remove the profile from ~/.config/order3000/profiles.json",
-      default: false
-    },
-    all: {
-      type: "boolean",
-      description: "Drop ALL cached tokens (does not remove profiles)",
-      default: false
-    }
-  },
-  async run({ args }) {
-    if (args.all) {
-      await clearAllCachedTokens();
-      consola3.success("Cleared all cached tokens.");
-      return;
-    }
-    const profile = await getProfile(args.profile);
-    if (!profile) {
-      throw new CLIError(`Profile "${args.profile}" does not exist.`);
-    }
-    await clearCachedToken(args.profile, profile.clientId, profile.baseUrl);
-    consola3.success(`Cleared cached token for "${args.profile}".`);
-    if (args["remove-profile"]) {
-      if (profile.useKeychain) {
-        const removed = await keychain.deleteClientSecret(args.profile);
-        if (removed)
-          consola3.success(
-            `Removed secret from OS keychain for "${args.profile}".`
-          );
-      }
-      await deleteProfile(args.profile);
-      consola3.success(`Removed profile "${args.profile}" from config.`);
-    }
-  }
-});
-
-// src/commands/auth/use.ts
-import { defineCommand as defineCommand4 } from "citty";
-import { consola as consola4 } from "consola";
-var use_default = defineCommand4({
-  meta: {
-    name: "use",
-    description: "Set the default profile for subsequent commands"
-  },
-  args: {
-    profile: {
-      type: "positional",
-      description: "Profile name",
-      required: true
-    }
-  },
-  async run({ args }) {
-    await setDefaultProfile(args.profile);
-    consola4.success(`Default profile set to "${args.profile}".`);
-  }
-});
-
-// src/commands/auth/whoami.ts
-import { defineCommand as defineCommand5 } from "citty";
-import { consola as consola5 } from "consola";
-
-// src/auth/client-factory.ts
-import { Order3000Client } from "order3000";
-var FIVE_MIN_MS = 3e5;
-function decodeJWT(jwt) {
-  const [, payload] = jwt.split(".");
-  if (!payload) throw new AuthError("Malformed JWT: missing payload segment.");
-  try {
-    return JSON.parse(
-      Buffer.from(payload, "base64url").toString("utf8")
-    );
-  } catch (err) {
-    throw new AuthError(
-      `Failed to decode JWT payload: ${err.message}`
-    );
-  }
-}
-async function getActiveToken(profileName, creds) {
-  const cached2 = await readCachedToken(
-    profileName,
-    creds.clientId,
-    creds.baseUrl
-  );
-  if (cached2 && cached2.expiresAt - Date.now() > FIVE_MIN_MS) {
-    return {
-      accessToken: cached2.accessToken,
-      expiresAt: cached2.expiresAt,
-      claims: decodeJWT(cached2.accessToken)
-    };
-  }
-  const fresh = await exchangeToken(creds);
-  const expiresAt = Date.now() + fresh.expiresIn * 1e3;
-  await writeCachedToken(profileName, creds.clientId, creds.baseUrl, {
-    accessToken: fresh.accessToken,
-    expiresAt
-  });
-  return {
-    accessToken: fresh.accessToken,
-    expiresAt,
-    claims: decodeJWT(fresh.accessToken)
-  };
-}
-function buildSDKClient(creds) {
-  return new Order3000Client({
-    clientId: creds.clientId,
-    clientSecret: creds.clientSecret,
-    baseUrl: creds.baseUrl,
-    venueId: creds.venueId
-  });
-}
-
-// src/auth/credentials.ts
-var DEFAULT_BASE_URL = "https://order3000.com/api";
-var ENV = {
-  profile: "ORDER3000_PROFILE",
-  clientId: "ORDER3000_CLIENT_ID",
-  clientSecret: "ORDER3000_CLIENT_SECRET",
-  baseUrl: "ORDER3000_BASE_URL",
-  venueId: "ORDER3000_VENUE_ID",
-  venueAccessor: "ORDER3000_VENUE_ACCESSOR"
-};
-async function resolveCredentials(flags = {}) {
-  const fromFlags = {
-    clientId: flags.clientId,
-    clientSecret: flags.clientSecret,
-    baseUrl: flags.baseUrl,
-    venueId: flags.venueId,
-    venueAccessor: flags.venueAccessor
-  };
-  const fromEnv = {
-    clientId: process.env[ENV.clientId],
-    clientSecret: process.env[ENV.clientSecret],
-    baseUrl: process.env[ENV.baseUrl],
-    venueId: process.env[ENV.venueId],
-    venueAccessor: process.env[ENV.venueAccessor]
-  };
-  const profileName = flags.profile ?? process.env[ENV.profile] ?? await getDefaultProfileName();
-  const fromProfile = profileName ? await getProfile(profileName) : void 0;
-  let clientSecret = fromFlags.clientSecret ?? fromEnv.clientSecret ?? fromProfile?.clientSecret;
-  if (!clientSecret && profileName && fromProfile?.useKeychain) {
-    clientSecret = await keychain.getClientSecret(profileName);
-    if (!clientSecret) {
-      throw new CLIError(
-        `Profile "${profileName}" is configured to use the OS keychain, but no secret was found there.`,
-        {
-          hint: "Re-run `order3000 auth login --profile " + profileName + " --keychain` to store it."
-        }
-      );
-    }
-  }
-  const merged = {
-    baseUrl: fromFlags.baseUrl ?? fromEnv.baseUrl ?? fromProfile?.baseUrl ?? DEFAULT_BASE_URL,
-    clientId: fromFlags.clientId ?? fromEnv.clientId ?? fromProfile?.clientId,
-    clientSecret,
-    venueId: fromFlags.venueId ?? fromEnv.venueId ?? fromProfile?.venueId,
-    venueAccessor: fromFlags.venueAccessor ?? fromEnv.venueAccessor ?? fromProfile?.venueAccessor
-  };
-  if (!merged.clientId || !merged.clientSecret) {
-    throw new CLIError(
-      `Missing credentials. Provide via flags (--client-id/--client-secret), env vars (${ENV.clientId}/${ENV.clientSecret}), or run \`order3000 auth login\`.`
-    );
-  }
-  return {
-    baseUrl: merged.baseUrl,
-    clientId: merged.clientId,
-    clientSecret: merged.clientSecret,
-    venueId: merged.venueId,
-    venueAccessor: merged.venueAccessor,
-    source: profileName ?? (process.env[ENV.clientId] ? "_env" : "_flags")
-  };
-}
-var credentialArgs = {
-  profile: {
-    type: "string",
-    description: "Profile name from ~/.config/order3000/profiles.json"
-  },
-  "client-id": {
-    type: "string",
-    description: "Robot account client ID (overrides env and profile)"
-  },
-  "client-secret": {
-    type: "string",
-    description: "Robot account client secret (overrides env and profile)"
-  },
-  "base-url": {
-    type: "string",
-    description: "API base URL (e.g. https://order3000.com/api)"
-  },
-  "venue-id": {
-    type: "string",
-    description: "Venue ID to scope requests to"
-  }
-};
-function flagsFromCittyArgs(args) {
-  const get = (k) => typeof args[k] === "string" ? args[k] : void 0;
-  return {
-    profile: get("profile"),
-    clientId: get("client-id"),
-    clientSecret: get("client-secret"),
-    baseUrl: get("base-url"),
-    venueId: get("venue-id")
-  };
-}
-
-// src/commands/auth/whoami.ts
-var whoami_default = defineCommand5({
-  meta: {
-    name: "whoami",
-    description: "Show the active profile and the robot account claims encoded in its JWT"
-  },
-  args: {
-    ...credentialArgs,
-    json: {
-      type: "boolean",
-      description: "Emit JSON instead of pretty output",
-      default: false
-    }
-  },
-  async run({ args }) {
-    const creds = await resolveCredentials(
-      flagsFromCittyArgs(args)
-    );
-    const { claims, expiresAt } = await getActiveToken(creds.source, creds);
-    const out = {
-      profile: creds.source,
-      baseUrl: creds.baseUrl,
-      robotAccountId: claims.sub,
-      venues: claims.venues ?? [],
-      permissionGroups: claims.permissionGroups ?? [],
-      tokenExpiresAt: new Date(expiresAt).toISOString()
-    };
-    if (args.json) {
-      process.stdout.write(`${JSON.stringify(out, null, 2)}
-`);
-      return;
-    }
-    const safe = redactSecrets(out);
-    consola5.box({
-      title: `Active profile: ${out.profile}`,
-      message: Object.entries(safe).filter(([k]) => k !== "profile").map(
-        ([k, v]) => `${k.padEnd(20)} ${Array.isArray(v) ? v.join(", ") || "(none)" : v}`
-      ).join("\n")
-    });
-  }
-});
-
-// src/commands/auth/index.ts
-var auth_default = defineCommand6({
-  meta: {
-    name: "auth",
-    description: "Manage credentials and the active profile"
-  },
-  subCommands: {
-    login: login_default,
-    logout: logout_default,
-    list: list_default,
-    use: use_default,
-    whoami: whoami_default
-  }
-});
-
-// src/commands/bind.ts
-import { defineCommand as defineCommand7, showUsage } from "citty";
-import { consola as consola6 } from "consola";
-
-// src/output/format.ts
-function resolveFormat(args) {
-  if (args.json === true) return "json";
-  if (typeof args.format === "string") {
-    const f = args.format.toLowerCase();
-    if (f === "json" || f === "pretty" || f === "jsonl") return f;
-    throw new Error(
-      `Unknown --format value "${args.format}" (expected json | pretty | jsonl)`
-    );
-  }
-  return isTTY() ? "pretty" : "json";
-}
-function emitJSON(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
-`);
-}
-function emitJSONL(values) {
-  for (const value of values) {
-    process.stdout.write(`${JSON.stringify(value)}
-`);
-  }
-}
-var outputArgs = {
-  json: {
-    type: "boolean",
-    description: "Emit JSON (overrides --format and TTY detection)",
-    default: false
-  },
-  format: {
-    type: "string",
-    description: "Output format: pretty | json | jsonl"
-  },
-  schema: {
-    type: "boolean",
-    description: "Print the JSON Schema for this command (input + output) and exit",
-    default: false
-  },
-  yes: {
-    type: "boolean",
-    description: "Confirm any destructive prompt (required for mutating commands in non-TTY mode)",
-    default: false,
-    alias: "y"
-  }
-};
-
-// src/schema/export.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-function exportHandlerSchema(handler) {
-  return {
-    name: handler.name,
-    description: handler.description,
-    contractVersion: handler.contractVersion,
-    mutating: Boolean(handler.mutating),
-    input: zodToJsonSchema(handler.inputSchema, {
-      name: `${handler.name}.input`,
-      $refStrategy: "none"
-    }),
-    output: zodToJsonSchema(handler.outputSchema, {
-      name: `${handler.name}.output`,
-      $refStrategy: "none"
-    })
-  };
-}
-
-// src/commands/bind.ts
-function bindHandlerCommand(handler) {
-  const leafName = handler.name.split(".").slice(-1)[0];
-  return defineCommand7({
-    meta: {
-      name: leafName,
-      description: handler.description
-    },
-    args: {
-      ...handler.cliArgs,
-      ...credentialArgs,
-      ...outputArgs
-    },
-    async run({ args, cmd, rawArgs: rawArgs2 }) {
-      const argsRecord = args;
-      if (rawArgs2.includes("--help") || rawArgs2.includes("-h")) {
-        await showUsage(cmd);
-        return;
-      }
-      if (argsRecord.schema === true) {
-        emitJSON(exportHandlerSchema(handler));
-        return;
-      }
-      const rawInput = handler.parseInput(argsRecord);
-      const input = handler.inputSchema.parse(rawInput);
-      if (handler.mutating && !isTTY() && argsRecord.yes !== true) {
-        throw new CLIError(
-          `Refusing to run mutating command "${handler.name}" without --yes in a non-TTY context.`,
-          {
-            hint: "Pass --yes to confirm, or run interactively from a terminal."
-          }
-        );
-      }
-      const ctx = await buildContext(handler, argsRecord);
-      const output = await handler.run(input, ctx);
-      const validated = handler.outputSchema.parse(output);
-      const fmt = resolveFormat(argsRecord);
-      if (fmt === "json") {
-        emitJSON(validated);
-      } else if (fmt === "jsonl") {
-        emitJSONL(Array.isArray(validated) ? validated : [validated]);
-      } else {
-        consola6.box({
-          title: handler.name,
-          message: JSON.stringify(validated, null, 2)
-        });
-      }
-    }
-  });
-}
-async function buildContext(handler, argsRecord) {
-  if (handler.requiresCredentials === false) {
-    return { client: void 0, venueId: void 0, logger: consola6 };
-  }
-  const creds = await resolveCredentials(flagsFromCittyArgs(argsRecord));
-  return {
-    client: buildSDKClient(creds),
-    venueId: creds.venueId,
-    logger: consola6
-  };
-}
-function bindHandlerGroup(groupName, handlers) {
-  const subCommands = {};
-  for (const handler of handlers) {
-    const [head, ...tail] = handler.name.split(".");
-    if (head !== groupName || tail.length !== 1) {
-      throw new Error(
-        `Handler "${handler.name}" does not match group "${groupName}" \u2014 expected name "${groupName}.<leaf>".`
-      );
-    }
-    subCommands[tail[0]] = bindHandlerCommand(handler);
-  }
-  return defineCommand7({
-    meta: { name: groupName, description: `${groupName} commands` },
-    subCommands,
-    async run({ rawArgs: rawArgs2, cmd }) {
-      const hasSubcommandToken = rawArgs2.some((a) => !a.startsWith("-"));
-      if (hasSubcommandToken) return;
-      await showUsage(cmd);
-    }
-  });
-}
-
-// src/handlers/areas/getAvailability.ts
-import { z as z4 } from "zod";
-
-// src/handlers/_shared/schemas.ts
-import { z as z3 } from "zod";
-var passthroughObject = z3.object({}).passthrough();
-var passthroughArray = z3.array(passthroughObject);
-var idSchema = z3.string().min(1);
-var isoDateTime = z3.string().datetime({ offset: true });
-function objectWithKnownKeys(shape) {
-  return z3.object(shape).passthrough();
-}
-function maybeString(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function maybeBool(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function maybeNumber(value) {
-  if (typeof value === "number") return value;
-  if (typeof value === "string" && value.length > 0) {
-    const n = Number(value);
-    return Number.isFinite(n) ? n : void 0;
-  }
-  return void 0;
-}
-
-// src/handlers/types.ts
-function defineHandler(handler) {
-  return handler;
-}
-
-// src/schema/version.ts
-var CONTRACT_VERSION = "v1";
-
-// src/handlers/areas/getAvailability.ts
-var dateOnly = z4.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected YYYY-MM-DD");
-var areasGetAvailability = defineHandler({
-  name: "areas.getAvailability",
-  description: "List occupied date/time windows for an area between `from` and `to`.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z4.object({
-    accessor: z4.string().min(1),
-    from: dateOnly.optional(),
-    to: dateOnly.optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: { type: "positional", description: "Area id or accessor" },
-    from: {
-      type: "string",
-      description: "Window start (YYYY-MM-DD), defaults to today"
-    },
-    to: {
-      type: "string",
-      description: "Window end (YYYY-MM-DD), defaults to today + 90d"
-    }
-  },
-  parseInput: (args) => ({
-    accessor: maybeString(args.accessor) ?? "",
-    from: maybeString(args.from),
-    to: maybeString(args.to)
-  }),
-  async run(input, ctx) {
-    return ctx.client.areas.getAvailability(input.accessor, {
-      from: input.from,
-      to: input.to
-    });
-  }
-});
-
-// src/handlers/areas/getByAccessor.ts
-import { z as z5 } from "zod";
-var areasGetByAccessor = defineHandler({
-  name: "areas.getByAccessor",
-  description: "Fetch a single area by id or accessor.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z5.object({
-    accessor: z5.string().min(1),
-    expand: z5.array(z5.literal("assets")).optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: { type: "positional", description: "Area id or accessor" },
-    expand: {
-      type: "string",
-      description: "Comma-separated expand sections (only 'assets' for now)"
-    }
-  },
-  parseInput: (args) => {
-    const expandRaw = maybeString(args.expand);
-    return {
-      accessor: maybeString(args.accessor) ?? "",
-      expand: expandRaw ? expandRaw.split(",").map((s) => s.trim()).filter((s) => s === "assets") : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.areas.getByAccessor(input.accessor, {
-      expand: input.expand
-    });
-  }
-});
-
-// src/handlers/areas/list.ts
-import { z as z6 } from "zod";
-var areasList = defineHandler({
-  name: "areas.list",
-  description: "List bookable + public areas for the venue.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z6.object({ expand: z6.array(z6.literal("assets")).optional() }),
-  outputSchema: passthroughArray,
-  cliArgs: {
-    expand: {
-      type: "string",
-      description: "Comma-separated expand sections (only 'assets' for now)"
-    }
-  },
-  parseInput: (args) => {
-    const expandRaw = maybeString(args.expand);
-    return {
-      expand: expandRaw ? expandRaw.split(",").map((s) => s.trim()).filter((s) => s === "assets") : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.areas.list({ expand: input.expand });
-  }
-});
-
-// src/handlers/areas/submitBookingRequest.ts
-import { schemas } from "order3000/schemas";
-import { z as z7 } from "zod";
-
-// src/handlers/_shared/jsonInput.ts
-import { readFileSync } from "fs";
-var jsonInputArgs = {
-  data: {
-    type: "string",
-    description: "JSON string with the request body (alternative to --data-file)"
-  },
-  "data-file": {
-    type: "string",
-    description: "Path to a JSON file with the request body (alternative to --data)"
-  }
-};
-function readJsonInput(args) {
-  const inline = typeof args.data === "string" ? args.data : void 0;
-  const path = typeof args["data-file"] === "string" ? args["data-file"] : void 0;
-  if (inline && path) {
-    throw new CLIError("Provide either --data or --data-file, not both.");
-  }
-  if (!inline && !path) return void 0;
-  const raw = inline ?? readFileSync(path, "utf8");
-  try {
-    return JSON.parse(raw);
-  } catch (err) {
-    throw new CLIError(
-      `Invalid JSON in ${inline ? "--data" : path}: ${err.message}`
-    );
-  }
-}
-
-// src/handlers/areas/submitBookingRequest.ts
-var areasSubmitBookingRequest = defineHandler({
-  name: "areas.submitBookingRequest",
-  description: "Submit a public booking request for an area.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  /** Combine path param with the body schema from the SDK contract. */
-  inputSchema: z7.object({
-    accessor: z7.string().min(1),
-    payload: schemas.SubmitAreaBookingRequest
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: { type: "positional", description: "Area id or accessor" },
-    ...jsonInputArgs
-  },
-  parseInput: (args) => ({
-    accessor: maybeString(args.accessor) ?? "",
-    payload: readJsonInput(args)
-  }),
-  async run(input, ctx) {
-    return ctx.client.areas.submitBookingRequest(
-      input.accessor,
-      input.payload
-    );
-  }
-});
-
-// src/handlers/baskets/abandon.ts
-import { z as z8 } from "zod";
-var basketsAbandon = defineHandler({
-  name: "baskets.abandon",
-  description: "Mark every active basket for the session as 'abandoned' \u2014 used by 'start fresh' flows.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z8.object({ sessionId: z8.string().min(1) }),
-  outputSchema: z8.object({ abandonedCount: z8.number().int().nonnegative() }),
-  cliArgs: {
-    "session-id": { type: "string", description: "Guest session id" }
-  },
-  parseInput: (args) => ({ sessionId: maybeString(args["session-id"]) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.baskets.abandon(input.sessionId);
-  }
-});
-
-// src/handlers/baskets/add.ts
-import { schemas as schemas2 } from "order3000/schemas";
-var inputSchema = schemas2.AddToBasketRequest.omit({ venueId: true });
-var basketsAdd = defineHandler({
-  name: "baskets.add",
-  description: "Add an item to the basket. Creates the basket and guest customer when missing.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.baskets.add(
-      input
-    );
-  }
-});
-
-// src/handlers/baskets/get.ts
-import { z as z9 } from "zod";
-var basketsGet = defineHandler({
-  name: "baskets.get",
-  description: "Get the current basket for a guest session (returns null if none).",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z9.object({ sessionId: z9.string().min(1) }),
-  outputSchema: objectWithKnownKeys({}).nullable(),
-  cliArgs: {
-    "session-id": { type: "string", description: "Guest session id" }
-  },
-  parseInput: (args) => ({ sessionId: maybeString(args["session-id"]) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.baskets.get(input.sessionId);
-  }
-});
-
-// src/handlers/baskets/getTotals.ts
-import { schemas as schemas3 } from "order3000/schemas";
-import { z as z10 } from "zod";
-var basketsGetTotals = defineHandler({
-  name: "baskets.getTotals",
-  description: "Compute canonical totals for a basket, including deposit credit.",
-  contractVersion: CONTRACT_VERSION,
-  /**
-   * Combines the path-param `basketId` with the body shape generated from
-   * `GetBasketTotalsRequest`. The SDK schema only carries the body fields,
-   * so we extend it locally with the route param.
-   */
-  inputSchema: z10.object({
-    basketId: idSchema,
-    declaredReturns: schemas3.GetBasketTotalsRequest.shape.declaredReturns
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "basket-id": { type: "string", description: "Basket id" },
-    "declared-returns": {
-      type: "string",
-      description: `JSON array of declared returns (e.g. '[{"depositwareTemplateId":"...","count":2}]')`
-    }
-  },
-  parseInput: (args) => {
-    const declaredReturnsRaw = maybeString(args["declared-returns"]);
-    return {
-      basketId: maybeString(args["basket-id"]) ?? "",
-      declaredReturns: declaredReturnsRaw ? JSON.parse(declaredReturnsRaw) : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.baskets.getTotals(input.basketId, {
-      declaredReturns: input.declaredReturns
-    });
-  }
-});
-
-// src/handlers/baskets/remove.ts
-import { z as z11 } from "zod";
-var basketsRemove = defineHandler({
-  name: "baskets.remove",
-  description: "Remove a basket item by id.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z11.object({
-    sessionId: z11.string().min(1),
-    basketItemId: idSchema
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "session-id": { type: "string", description: "Guest session id" },
-    "basket-item-id": {
-      type: "string",
-      description: "Basket item id to remove"
-    }
-  },
-  parseInput: (args) => ({
-    sessionId: maybeString(args["session-id"]) ?? "",
-    basketItemId: maybeString(args["basket-item-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.baskets.remove(input.sessionId, input.basketItemId);
-  }
-});
-
-// src/handlers/baskets/setDeclaredReturns.ts
-import { z as z12 } from "zod";
-var basketsSetDeclaredReturns = defineHandler({
-  name: "baskets.setDeclaredReturns",
-  description: "Persist per-template declared-return counts on a basket (team-order participants).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z12.object({
-    basketId: idSchema,
-    sessionId: z12.string().min(1),
-    declaredReturns: z12.array(
-      z12.object({
-        depositwareTemplateId: z12.string().min(1),
-        count: z12.number().int().nonnegative()
-      })
-    )
-  }),
-  outputSchema: objectWithKnownKeys({
-    basketId: z12.string()
-  }),
-  cliArgs: {
-    "basket-id": { type: "string", description: "Basket id" },
-    "session-id": {
-      type: "string",
-      description: "Guest session id (must match basket owner)"
-    },
-    "declared-returns": {
-      type: "string",
-      description: "JSON array of declared returns"
-    }
-  },
-  parseInput: (args) => {
-    const declaredReturnsRaw = maybeString(args["declared-returns"]) ?? "[]";
-    return {
-      basketId: maybeString(args["basket-id"]) ?? "",
-      sessionId: maybeString(args["session-id"]) ?? "",
-      declaredReturns: JSON.parse(declaredReturnsRaw)
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.baskets.setDeclaredReturns(input.basketId, {
-      sessionId: input.sessionId,
-      declaredReturns: input.declaredReturns
-    });
-  }
-});
-
-// src/handlers/events/get.ts
-import { z as z13 } from "zod";
-var eventsGet = defineHandler({
-  name: "events.get",
-  description: "Fetch a single event by id.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z13.object({ eventId: idSchema }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "event-id": { type: "positional", description: "Event id" }
-  },
-  parseInput: (args) => ({ eventId: maybeString(args["event-id"]) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.events.get(input.eventId);
-  }
-});
-
-// src/handlers/events/getByAccessor.ts
-import { z as z14 } from "zod";
-var eventsGetByAccessor = defineHandler({
-  name: "events.getByAccessor",
-  description: "Fetch an event by its accessor slug, with optional `expand` parts.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z14.object({
-    accessor: z14.string().min(1),
-    expand: z14.array(z14.string()).optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: { type: "positional", description: "Event accessor (slug)" },
-    expand: {
-      type: "string",
-      description: "Comma-separated expand sections (e.g. 'schedule,timeSlots,menus,posters')"
-    }
-  },
-  parseInput: (args) => {
-    const expandRaw = maybeString(args.expand);
-    return {
-      accessor: maybeString(args.accessor) ?? "",
-      expand: expandRaw ? expandRaw.split(",").map((s) => s.trim()).filter(Boolean) : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.events.getByAccessor(input.accessor, {
-      expand: input.expand
-    });
-  }
-});
-
-// src/handlers/events/list.ts
-import { z as z15 } from "zod";
-var eventsList = defineHandler({
-  name: "events.list",
-  description: "List events for the active venue, with optional filters.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z15.object({
-    includePrivate: z15.boolean().optional(),
-    includeInactive: z15.boolean().optional(),
-    isPublic: z15.boolean().optional(),
-    isRecurring: z15.boolean().optional(),
-    isClosed: z15.boolean().optional(),
-    upcomingWithinDays: z15.number().int().positive().optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "include-private": {
-      type: "boolean",
-      description: "Include private events"
-    },
-    "include-inactive": {
-      type: "boolean",
-      description: "Include inactive events"
-    },
-    "is-public": { type: "boolean", description: "Filter by public status" },
-    "is-recurring": {
-      type: "boolean",
-      description: "Filter by recurring status"
-    },
-    "is-closed": { type: "boolean", description: "Filter by closed status" },
-    "upcoming-within-days": {
-      type: "string",
-      description: "Restrict to events within N days from now"
-    }
-  },
-  parseInput: (args) => ({
-    includePrivate: maybeBool(args["include-private"]),
-    includeInactive: maybeBool(args["include-inactive"]),
-    isPublic: maybeBool(args["is-public"]),
-    isRecurring: maybeBool(args["is-recurring"]),
-    isClosed: maybeBool(args["is-closed"]),
-    upcomingWithinDays: maybeNumber(args["upcoming-within-days"])
-  }),
-  async run(input, ctx) {
-    return ctx.client.events.list(input);
-  }
-});
-
-// src/handlers/events/place.ts
-import { schemas as schemas4 } from "order3000/schemas";
-var eventsPlace = defineHandler({
-  name: "events.place",
-  description: "Create a new event (full payload via --data or --data-file).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas4.CreateEventRequest,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.events.place(
-      input
-    );
-  }
-});
-
-// src/handlers/menus/get.ts
-import { z as z16 } from "zod";
-var menusGet = defineHandler({
-  name: "menus.get",
-  description: "Fetch a menu by id, with optional `expand` parts.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z16.object({
-    menuId: idSchema,
-    expand: z16.array(z16.string()).optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "menu-id": { type: "positional", description: "Menu id (UUID)" },
-    expand: { type: "string", description: "Comma-separated expand sections" }
-  },
-  parseInput: (args) => {
-    const expandRaw = maybeString(args.expand);
-    return {
-      menuId: maybeString(args["menu-id"]) ?? "",
-      expand: expandRaw ? expandRaw.split(",").map((s) => s.trim()).filter(Boolean) : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.menus.get(input.menuId, {
-      expand: input.expand
-    });
-  }
-});
-
-// src/handlers/menus/getBundles.ts
-import { z as z17 } from "zod";
-var menusGetBundles = defineHandler({
-  name: "menus.getBundles",
-  description: "List bundles for a menu (by id or accessor).",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z17.object({ menuIdOrAccessor: z17.string().min(1) }),
-  outputSchema: passthroughArray,
-  cliArgs: {
-    menu: { type: "positional", description: "Menu id or accessor" }
-  },
-  parseInput: (args) => ({ menuIdOrAccessor: maybeString(args.menu) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.menus.getBundles(input.menuIdOrAccessor);
-  }
-});
-
-// src/handlers/menus/getByAccessor.ts
-import { z as z18 } from "zod";
-var menusGetByAccessor = defineHandler({
-  name: "menus.getByAccessor",
-  description: "Fetch a menu by its accessor slug, with optional `expand` parts.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z18.object({
-    accessor: z18.string().min(1),
-    expand: z18.array(z18.string()).optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: { type: "positional", description: "Menu accessor (slug)" },
-    expand: { type: "string", description: "Comma-separated expand sections" }
-  },
-  parseInput: (args) => {
-    const expandRaw = maybeString(args.expand);
-    return {
-      accessor: maybeString(args.accessor) ?? "",
-      expand: expandRaw ? expandRaw.split(",").map((s) => s.trim()).filter(Boolean) : void 0
-    };
-  },
-  async run(input, ctx) {
-    return ctx.client.menus.getByAccessor(input.accessor, {
-      expand: input.expand
-    });
-  }
-});
-
-// src/handlers/menus/getSubscriptions.ts
-import { z as z19 } from "zod";
-var menusGetSubscriptions = defineHandler({
-  name: "menus.getSubscriptions",
-  description: "List active subscriptions for a menu (by id or accessor).",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z19.object({ menuIdOrAccessor: z19.string().min(1) }),
-  outputSchema: passthroughArray,
-  cliArgs: {
-    menu: { type: "positional", description: "Menu id or accessor" }
-  },
-  parseInput: (args) => ({ menuIdOrAccessor: maybeString(args.menu) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.menus.getSubscriptions(input.menuIdOrAccessor);
-  }
-});
-
-// src/handlers/orders/confirm.ts
-import { z as z20 } from "zod";
-var ordersConfirm = defineHandler({
-  name: "orders.confirm",
-  description: "Confirm an order after Stripe PaymentIntent succeeded; transitions the order to paid.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z20.object({
-    orderId: idSchema,
-    paymentIntentId: z20.string().min(1)
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "order-id": { type: "positional", description: "Order id" },
-    "payment-intent-id": {
-      type: "string",
-      description: "Stripe PaymentIntent id (from a successful client-side confirmation)"
-    }
-  },
-  parseInput: (args) => ({
-    orderId: maybeString(args["order-id"]) ?? "",
-    paymentIntentId: maybeString(args["payment-intent-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.orders.confirm(input.orderId, {
-      paymentIntentId: input.paymentIntentId
-    });
-  }
-});
-
-// src/handlers/orders/get.ts
-import { z as z21 } from "zod";
-var ordersGet = defineHandler({
-  name: "orders.get",
-  description: "Fetch a single order by id.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z21.object({
-    orderId: idSchema
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "order-id": {
-      type: "positional",
-      description: "Order id (UUID)"
-    }
-  },
-  parseInput: (args) => ({
-    orderId: maybeString(args["order-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.orders.get(input.orderId);
-  }
-});
-
-// src/handlers/orders/getLatest.ts
-import { z as z22 } from "zod";
-var ordersGetLatest = defineHandler({
-  name: "orders.getLatest",
-  description: "Get the most recent non-team order for a guest session (returns null if none).",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z22.object({
-    sessionId: z22.string().min(1)
-  }),
-  outputSchema: objectWithKnownKeys({
-    id: z22.string(),
-    status: z22.string()
-  }).nullable(),
-  cliArgs: {
-    "session-id": {
-      type: "string",
-      description: "Guest session identifier (from the order3000 cookie)"
-    }
-  },
-  parseInput: (args) => ({
-    sessionId: maybeString(args["session-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.orders.getLatest(input.sessionId);
-  }
-});
-
-// src/handlers/orders/place.ts
-import { schemas as schemas5 } from "order3000/schemas";
-import { z as z23 } from "zod";
-var inputSchema2 = schemas5.PlaceOrderRequest.omit({
-  id: true,
-  venueId: true,
-  publicId: true,
-  quickReferenceNumber: true,
-  status: true,
-  paymentIntentId: true,
-  paymentStatus: true,
-  taxAmount: true,
-  totalAmount: true,
-  currency: true,
-  orderedAt: true,
-  orderedBy: true,
-  updatedAt: true,
-  updatedBy: true,
-  teamOrderId: true,
-  participantDisplayName: true,
-  leadSettledAt: true
-});
-var ordersPlace = defineHandler({
-  name: "orders.place",
-  description: "Place a new (non-team) order from an existing basket.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: inputSchema2,
-  outputSchema: objectWithKnownKeys({
-    id: z23.string(),
-    status: z23.string()
-  }),
-  cliArgs: {
-    "basket-id": { type: "string", description: "Basket id" },
-    "session-id": { type: "string", description: "Guest session id" },
-    "payment-method": {
-      type: "string",
-      description: "Payment method: card | cash | voucher"
-    },
-    "fulfillment-type": {
-      type: "string",
-      description: "Fulfillment type: pickup | delivery"
-    },
-    "fulfillment-at": {
-      type: "string",
-      description: "ISO 8601 datetime for the desired pickup/delivery slot"
-    }
-  },
-  parseInput: (args) => ({
-    basketId: maybeString(args["basket-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    paymentMethod: maybeString(args["payment-method"]),
-    fulfillmentType: maybeString(args["fulfillment-type"]),
-    fulfillmentAt: maybeString(args["fulfillment-at"])
-  }),
-  async run(input, ctx) {
-    return ctx.client.orders.place(
-      input
-    );
-  }
-});
-
-// src/handlers/paymentIntents/create.ts
-import { schemas as schemas6 } from "order3000/schemas";
-var paymentIntentsCreate = defineHandler({
-  name: "paymentIntents.create",
-  description: "Create a Stripe PaymentIntent for an order. Returns clientSecret and orderId.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas6.CreatePaymentIntentRequest,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.paymentIntents.create(
-      input
-    );
-  }
-});
-
-// src/handlers/paymentIntents/createDelta.ts
-import { schemas as schemas7 } from "order3000/schemas";
-var paymentIntentsCreateDelta = defineHandler({
-  name: "paymentIntents.createDelta",
-  description: "Create a delta PaymentIntent for a team-order participant who added items after paying.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas7.CreateDeltaPaymentIntentRequest,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.paymentIntents.createDelta(
-      input
-    );
-  }
-});
-
-// src/handlers/paymentIntents/reduceDelta.ts
-import { schemas as schemas8 } from "order3000/schemas";
-var paymentIntentsReduceDelta = defineHandler({
-  name: "paymentIntents.reduceDelta",
-  description: "Release part of a participant authorisation when items are removed from the basket.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas8.ReduceDeltaPaymentIntentRequest,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.paymentIntents.reduceDelta(
-      input
-    );
-  }
-});
-
-// src/handlers/reservations/get.ts
-import { z as z24 } from "zod";
-var reservationsGet = defineHandler({
-  name: "reservations.get",
-  description: "Fetch a reservation by id.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z24.object({ reservationId: idSchema }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "reservation-id": { type: "positional", description: "Reservation id" }
-  },
-  parseInput: (args) => ({
-    reservationId: maybeString(args["reservation-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.reservations.get(input.reservationId);
-  }
-});
-
-// src/handlers/reservations/make.ts
-import { schemas as schemas9 } from "order3000/schemas";
-var reservationsMake = defineHandler({
-  name: "reservations.make",
-  description: "Make a new reservation (payload via --data or --data-file).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas9.MakeReservationRequest,
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.reservations.make(
-      input
-    );
-  }
-});
-
-// src/handlers/subscriptions/cancel.ts
-import { z as z25 } from "zod";
-var subscriptionsCancel = defineHandler({
-  name: "subscriptions.cancel",
-  description: "Cancel a customer's subscription.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z25.object({
-    subscriptionIdOrAccessor: z25.string().min(1),
-    subscriberId: z25.string().min(1)
-  }),
-  // SDK returns void; expose an explicit "ok" envelope so JSON output is
-  // never an empty body and the contract has a stable schema to validate.
-  outputSchema: z25.object({ ok: z25.literal(true) }),
-  cliArgs: {
-    subscription: {
-      type: "positional",
-      description: "Subscription id or accessor"
-    },
-    "subscriber-id": {
-      type: "string",
-      description: "Subscriber row id to cancel"
-    }
-  },
-  parseInput: (args) => ({
-    subscriptionIdOrAccessor: maybeString(args.subscription) ?? "",
-    subscriberId: maybeString(args["subscriber-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    await ctx.client.subscriptions.cancel(
-      input.subscriptionIdOrAccessor,
-      input.subscriberId
-    );
-    return { ok: true };
-  }
-});
-
-// src/handlers/subscriptions/get.ts
-import { z as z26 } from "zod";
-var subscriptionsGet = defineHandler({
-  name: "subscriptions.get",
-  description: "Fetch a subscription by id.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z26.object({ subscriptionId: idSchema }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "subscription-id": {
-      type: "positional",
-      description: "Subscription id (UUID)"
-    }
-  },
-  parseInput: (args) => ({
-    subscriptionId: maybeString(args["subscription-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.subscriptions.get(input.subscriptionId);
-  }
-});
-
-// src/handlers/subscriptions/getByAccessor.ts
-import { z as z27 } from "zod";
-var subscriptionsGetByAccessor = defineHandler({
-  name: "subscriptions.getByAccessor",
-  description: "Fetch a subscription by its accessor slug.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z27.object({ accessor: z27.string().min(1) }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    accessor: {
-      type: "positional",
-      description: "Subscription accessor (slug)"
-    }
-  },
-  parseInput: (args) => ({ accessor: maybeString(args.accessor) ?? "" }),
-  async run(input, ctx) {
-    return ctx.client.subscriptions.getByAccessor(input.accessor);
-  }
-});
-
-// src/handlers/subscriptions/getCredits.ts
-import { z as z28 } from "zod";
-var subscriptionsGetCredits = defineHandler({
-  name: "subscriptions.getCredits",
-  description: "List credits for a subscriber, optionally filtered by status.",
-  contractVersion: CONTRACT_VERSION,
-  /**
-   * Path params + query params. `openapi-zod-client` doesn't emit named
-   * components for query schemas (only for body refs), so the CLI mirrors
-   * the contract inline. The enum literals match the order3000 contract
-   * (`apps/order3000/src/app/api/openapi/contracts/subscriptions.ts`).
-   */
-  inputSchema: z28.object({
-    subscriptionIdOrAccessor: z28.string().min(1),
-    subscriberId: z28.string().min(1),
-    status: z28.enum(["available", "redeemed", "expired"]).optional()
-  }),
-  outputSchema: passthroughArray,
-  cliArgs: {
-    subscription: {
-      type: "positional",
-      description: "Subscription id or accessor"
-    },
-    "subscriber-id": { type: "string", description: "Subscriber row id" },
-    status: {
-      type: "string",
-      description: "Filter by credit status: available | redeemed | expired"
-    }
-  },
-  parseInput: (args) => ({
-    subscriptionIdOrAccessor: maybeString(args.subscription) ?? "",
-    subscriberId: maybeString(args["subscriber-id"]) ?? "",
-    status: maybeString(args.status)
-  }),
-  async run(input, ctx) {
-    return ctx.client.subscriptions.getCredits(
-      input.subscriptionIdOrAccessor,
-      input.subscriberId,
-      input.status
-    );
-  }
-});
-
-// src/handlers/subscriptions/subscribe.ts
-import { z as z29 } from "zod";
-var subscriptionsSubscribe = defineHandler({
-  name: "subscriptions.subscribe",
-  description: "Start a Stripe Checkout session to subscribe a customer to a subscription plan.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z29.object({
-    subscriptionIdOrAccessor: z29.string().min(1),
-    email: z29.string().email(),
-    firstName: z29.string().optional(),
-    lastName: z29.string().optional(),
-    sessionId: z29.string().optional(),
-    successUrl: z29.string().url(),
-    cancelUrl: z29.string().url()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    subscription: {
-      type: "positional",
-      description: "Subscription id or accessor"
-    },
-    email: { type: "string", description: "Customer email" },
-    "first-name": { type: "string", description: "Customer first name" },
-    "last-name": { type: "string", description: "Customer last name" },
-    "session-id": {
-      type: "string",
-      description: "Optional guest session id to attach"
-    },
-    "success-url": {
-      type: "string",
-      description: "Stripe Checkout success URL"
-    },
-    "cancel-url": { type: "string", description: "Stripe Checkout cancel URL" }
-  },
-  parseInput: (args) => ({
-    subscriptionIdOrAccessor: maybeString(args.subscription) ?? "",
-    email: maybeString(args.email) ?? "",
-    firstName: maybeString(args["first-name"]),
-    lastName: maybeString(args["last-name"]),
-    sessionId: maybeString(args["session-id"]),
-    successUrl: maybeString(args["success-url"]) ?? "",
-    cancelUrl: maybeString(args["cancel-url"]) ?? ""
-  }),
-  async run(input, ctx) {
-    const { subscriptionIdOrAccessor, ...request } = input;
-    return ctx.client.subscriptions.subscribe(subscriptionIdOrAccessor, request);
-  }
-});
-
-// src/handlers/system/ping.ts
-import { z as z30 } from "zod";
-
-// package.json
-var package_default = {
-  name: "@order3000/cli",
-  version: "0.0.0",
-  description: "Agent-friendly command-line interface for the order3000 platform",
-  type: "module",
-  private: false,
-  publishConfig: {
-    access: "public"
-  },
-  bin: {
-    order3000: "./dist/cli.js"
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    build: "pnpm build:schemas:check && tsup",
-    "build:schemas": "tsx scripts/build-schemas.ts",
-    "build:schemas:check": "tsx scripts/build-schemas.ts --check",
-    "build:binaries": "tsx scripts/build-binaries.ts",
-    "build:binaries:check": "tsx scripts/build-binaries.ts --check",
-    dev: "tsup --watch",
-    start: "node ./dist/cli.js",
-    lint: "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix"
-  },
-  dependencies: {
-    "@napi-rs/keyring": "^1.1.7",
-    citty: "^0.1.6",
-    consola: "^3.4.2",
-    order3000: "workspace:*",
-    zod: "^3.23.8",
-    "zod-to-json-schema": "^3.24.5"
-  },
-  devDependencies: {
-    "@kolaveri/eslint-config": "workspace:*",
-    "@kolaveri/prettier-config": "workspace:*",
-    "@kolaveri/tsconfig": "workspace:*",
-    "@types/node": "^24.10.0",
-    eslint: "^8.57.0",
-    prettier: "^3.7.4",
-    tsup: "^8.3.5",
-    tsx: "^4.19.2",
-    typescript: "^5.9.3"
-  },
-  prettier: "@kolaveri/prettier-config"
-};
-
-// src/version.ts
-var VERSION = package_default.version;
-
-// src/handlers/system/ping.ts
-var systemPing = defineHandler({
-  name: "system.ping",
-  description: "Health check \u2014 returns the CLI version and a server-side timestamp echo",
-  contractVersion: CONTRACT_VERSION,
-  requiresCredentials: false,
-  inputSchema: z30.object({
-    message: z30.string().min(1).max(200).optional()
-  }),
-  outputSchema: z30.object({
-    ok: z30.literal(true),
-    cliVersion: z30.string(),
-    timestamp: z30.string().datetime(),
-    echo: z30.string().optional()
-  }),
-  cliArgs: {
-    message: {
-      type: "string",
-      description: "Optional string to echo back (max 200 chars)"
-    }
-  },
-  parseInput: (args) => ({
-    message: typeof args.message === "string" ? args.message : void 0
-  }),
-  async run(input) {
-    return {
-      ok: true,
-      cliVersion: VERSION,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      echo: input.message
-    };
-  }
-});
-
-// src/handlers/teamOrders/autoExtendFulfillmentIfExpired.ts
-import { z as z31 } from "zod";
-var teamOrdersAutoExtendFulfillmentIfExpired = defineHandler({
-  name: "teamOrders.autoExtendFulfillmentIfExpired",
-  description: "Any participant proposes an auto-extend when fulfillmentAt has passed while still collecting.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z31.object({
-    publicId: z31.string().min(1),
-    sessionId: z31.string().min(1),
-    proposedFulfillmentAt: isoDateTime
-  }),
-  outputSchema: objectWithKnownKeys({ extended: z31.boolean() }),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Caller session id" },
-    "proposed-fulfillment-at": {
-      type: "string",
-      description: "Proposed new fulfillmentAt (ISO 8601)"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    proposedFulfillmentAt: maybeString(args["proposed-fulfillment-at"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.autoExtendFulfillmentIfExpired(
-      input.publicId,
-      {
-        sessionId: input.sessionId,
-        proposedFulfillmentAt: input.proposedFulfillmentAt
-      }
-    );
-  }
-});
-
-// src/handlers/teamOrders/cancel.ts
-import { z as z32 } from "zod";
-var teamOrdersCancel = defineHandler({
-  name: "teamOrders.cancel",
-  description: "Lead cancels pre-placement. Voids every authorised PaymentIntent.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z32.object({
-    publicId: z32.string().min(1),
-    sessionId: z32.string().min(1),
-    reason: z32.string().optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    reason: {
-      type: "string",
-      description: "Free-text reason shown to participants"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    reason: maybeString(args.reason)
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.cancel(input.publicId, {
-      sessionId: input.sessionId,
-      reason: input.reason
-    });
-  }
-});
-
-// src/handlers/teamOrders/create.ts
-import { schemas as schemas10 } from "order3000/schemas";
-import { z as z33 } from "zod";
-var teamOrdersCreate = defineHandler({
-  name: "teamOrders.create",
-  description: "Lead creates a team order from their active basket. Returns the unguessable publicId.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: schemas10.CreateTeamOrderRequest,
-  outputSchema: objectWithKnownKeys({
-    publicId: z33.string(),
-    teamOrderId: z33.string()
-  }),
-  cliArgs: { ...jsonInputArgs },
-  parseInput: (args) => readJsonInput(args),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.create(
-      input
-    );
-  }
-});
-
-// src/handlers/teamOrders/extendDeadline.ts
-import { z as z34 } from "zod";
-var teamOrdersExtendDeadline = defineHandler({
-  name: "teamOrders.extendDeadline",
-  description: "Lead pushes the team-order deadline.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z34.object({
-    publicId: z34.string().min(1),
-    sessionId: z34.string().min(1),
-    newDeadlineAt: isoDateTime
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    "new-deadline-at": {
-      type: "string",
-      description: "New deadline (ISO 8601 datetime)"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    newDeadlineAt: maybeString(args["new-deadline-at"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.extendDeadline(input.publicId, {
-      sessionId: input.sessionId,
-      newDeadlineAt: input.newDeadlineAt
-    });
-  }
-});
-
-// src/handlers/teamOrders/get.ts
-import { z as z35 } from "zod";
-var teamOrdersGet = defineHandler({
-  name: "teamOrders.get",
-  description: "Public read of a team order by publicId. Pass --session-id to gate isLead correctly.",
-  contractVersion: CONTRACT_VERSION,
-  inputSchema: z35.object({
-    publicId: z35.string().min(1),
-    sessionId: z35.string().optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": {
-      type: "string",
-      description: "Caller session id (drives isLead)"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"])
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.get(input.publicId, input.sessionId);
-  }
-});
-
-// src/handlers/teamOrders/join.ts
-import { z as z36 } from "zod";
-var teamOrdersJoin = defineHandler({
-  name: "teamOrders.join",
-  description: "Participant joins a team order. Idempotent.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z36.object({
-    publicId: z36.string().min(1),
-    sessionId: z36.string().min(1),
-    displayName: z36.string().optional()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Joiner session id" },
-    "display-name": { type: "string", description: "Optional display name" }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    displayName: maybeString(args["display-name"])
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.join(input.publicId, {
-      sessionId: input.sessionId,
-      displayName: input.displayName
-    });
-  }
-});
-
-// src/handlers/teamOrders/setDiningLocation.ts
-import { z as z37 } from "zod";
-var teamOrdersSetDiningLocation = defineHandler({
-  name: "teamOrders.setDiningLocation",
-  description: 'Lead sets the free-form "where we will eat" text on the team order.',
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z37.object({
-    publicId: z37.string().min(1),
-    sessionId: z37.string().min(1),
-    diningLocation: z37.string().min(1)
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    "dining-location": {
-      type: "string",
-      description: "Free-form location text"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    diningLocation: maybeString(args["dining-location"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.setDiningLocation(input.publicId, {
-      sessionId: input.sessionId,
-      diningLocation: input.diningLocation
-    });
-  }
-});
-
-// src/handlers/teamOrders/setDiningTime.ts
-import { z as z38 } from "zod";
-var teamOrdersSetDiningTime = defineHandler({
-  name: "teamOrders.setDiningTime",
-  description: "Lead sets when the team will start eating (HH:MM in venue timezone).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z38.object({
-    publicId: z38.string().min(1),
-    sessionId: z38.string().min(1),
-    diningTime: z38.string().regex(/^\d{2}:\d{2}$/, "Expected HH:MM")
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    "dining-time": { type: "string", description: "Dining time (HH:MM)" }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    diningTime: maybeString(args["dining-time"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.setDiningTime(input.publicId, {
-      sessionId: input.sessionId,
-      diningTime: input.diningTime
-    });
-  }
-});
-
-// src/handlers/teamOrders/setFulfillmentAt.ts
-import { z as z39 } from "zod";
-var teamOrdersSetFulfillmentAt = defineHandler({
-  name: "teamOrders.setFulfillmentAt",
-  description: "Lead commits the shared pickup/delivery time. Required before submit.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z39.object({
-    publicId: z39.string().min(1),
-    sessionId: z39.string().min(1),
-    fulfillmentAt: isoDateTime
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    "fulfillment-at": {
-      type: "string",
-      description: "Pickup/delivery time (ISO 8601)"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    fulfillmentAt: maybeString(args["fulfillment-at"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.setFulfillmentAt(input.publicId, {
-      sessionId: input.sessionId,
-      fulfillmentAt: input.fulfillmentAt
-    });
-  }
-});
-
-// src/handlers/teamOrders/setOrderLeadSettled.ts
-import { z as z40 } from "zod";
-var teamOrdersSetOrderLeadSettled = defineHandler({
-  name: "teamOrders.setOrderLeadSettled",
-  description: "Toggle a participant's settled tick on the Lead's settle-up checklist.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z40.object({
-    publicId: z40.string().min(1),
-    sessionId: z40.string().min(1),
-    orderId: idSchema,
-    settled: z40.boolean()
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" },
-    "order-id": {
-      type: "string",
-      description: "Child order id to mark settled or unsettled"
-    },
-    settled: {
-      type: "boolean",
-      description: "true to mark settled, false to clear"
-    }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? "",
-    orderId: maybeString(args["order-id"]) ?? "",
-    settled: maybeBool(args.settled) ?? false
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.setOrderLeadSettled(input.publicId, {
-      sessionId: input.sessionId,
-      orderId: input.orderId,
-      settled: input.settled
-    });
-  }
-});
-
-// src/handlers/teamOrders/submit.ts
-import { z as z41 } from "zod";
-var teamOrdersSubmit = defineHandler({
-  name: "teamOrders.submit",
-  description: "Lead submits the team order \u2014 captures auths, finalises child orders.",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z41.object({
-    publicId: z41.string().min(1),
-    sessionId: z41.string().min(1)
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    "session-id": { type: "string", description: "Lead session id" }
-  },
-  parseInput: (args) => ({
-    publicId: maybeString(args["public-id"]) ?? "",
-    sessionId: maybeString(args["session-id"]) ?? ""
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.submit(input.publicId, {
-      sessionId: input.sessionId
-    });
-  }
-});
-
-// src/handlers/teamOrders/switchFulfillment.ts
-import { schemas as schemas11 } from "order3000/schemas";
-import { z as z42 } from "zod";
-var teamOrdersSwitchFulfillment = defineHandler({
-  name: "teamOrders.switchFulfillment",
-  description: "Lead flips pickup \u2194 delivery. Pass the full request body via --data (sessionId, fulfillmentType, optional deliveryAddress).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z42.object({
-    publicId: z42.string().min(1),
-    request: schemas11.SwitchFulfillmentTeamOrderRequest
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    ...jsonInputArgs
-  },
-  parseInput: (args) => ({
-    publicId: typeof args["public-id"] === "string" ? args["public-id"] : "",
-    request: readJsonInput(args)
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.switchFulfillment(
-      input.publicId,
-      input.request
-    );
-  }
-});
-
-// src/handlers/teamOrders/updateDeliveryAddress.ts
-import { schemas as schemas12 } from "order3000/schemas";
-import { z as z43 } from "zod";
-var teamOrdersUpdateDeliveryAddress = defineHandler({
-  name: "teamOrders.updateDeliveryAddress",
-  description: "Lead replaces the delivery address. Pass the full request body via --data (sessionId, deliveryAddress).",
-  contractVersion: CONTRACT_VERSION,
-  mutating: true,
-  inputSchema: z43.object({
-    publicId: z43.string().min(1),
-    request: schemas12.UpdateDeliveryAddressTeamOrderRequest
-  }),
-  outputSchema: objectWithKnownKeys({}),
-  cliArgs: {
-    "public-id": { type: "positional", description: "Team order publicId" },
-    ...jsonInputArgs
-  },
-  parseInput: (args) => ({
-    publicId: typeof args["public-id"] === "string" ? args["public-id"] : "",
-    request: readJsonInput(args)
-  }),
-  async run(input, ctx) {
-    return ctx.client.teamOrders.updateDeliveryAddress(
-      input.publicId,
-      input.request
-    );
-  }
-});
-
-// src/handlers/index.ts
-var handlerGroups = {
-  system: [systemPing],
-  areas: [
-    areasList,
-    areasGetByAccessor,
-    areasGetAvailability,
-    areasSubmitBookingRequest
-  ],
-  baskets: [
-    basketsGet,
-    basketsAdd,
-    basketsRemove,
-    basketsGetTotals,
-    basketsAbandon,
-    basketsSetDeclaredReturns
-  ],
-  events: [eventsList, eventsGet, eventsGetByAccessor, eventsPlace],
-  menus: [menusGet, menusGetByAccessor, menusGetBundles, menusGetSubscriptions],
-  orders: [ordersGetLatest, ordersGet, ordersPlace, ordersConfirm],
-  paymentIntents: [
-    paymentIntentsCreate,
-    paymentIntentsCreateDelta,
-    paymentIntentsReduceDelta
-  ],
-  reservations: [reservationsMake, reservationsGet],
-  subscriptions: [
-    subscriptionsGet,
-    subscriptionsGetByAccessor,
-    subscriptionsSubscribe,
-    subscriptionsCancel,
-    subscriptionsGetCredits
-  ],
-  teamOrders: [
-    teamOrdersCreate,
-    teamOrdersGet,
-    teamOrdersJoin,
-    teamOrdersSubmit,
-    teamOrdersCancel,
-    teamOrdersExtendDeadline,
-    teamOrdersSetFulfillmentAt,
-    teamOrdersSetDiningLocation,
-    teamOrdersSetDiningTime,
-    teamOrdersSetOrderLeadSettled,
-    teamOrdersAutoExtendFulfillmentIfExpired,
-    teamOrdersSwitchFulfillment,
-    teamOrdersUpdateDeliveryAddress
-  ]
-};
-var allHandlers = Object.values(handlerGroups).flat();
-
-// src/cli.ts
-var handlerSubCommands = Object.fromEntries(
-  Object.entries(handlerGroups).map(([group, handlers]) => [
-    group,
-    bindHandlerGroup(group, handlers)
-  ])
-);
-var main = defineCommand8({
-  meta: {
-    name: "order3000",
-    version: VERSION,
-    description: "Agent-friendly command-line interface for the order3000 platform"
-  },
-  subCommands: {
-    auth: auth_default,
-    ...handlerSubCommands
-  },
-  async run({ rawArgs: rawArgs2, cmd }) {
-    const hasSubcommandToken = rawArgs2.some((a) => !a.startsWith("-"));
-    if (hasSubcommandToken) return;
-    await showUsage2(cmd);
-  }
-});
-process.on("unhandledRejection", (err) => {
-  reportError(err);
-  process.exit(ExitCode.Unexpected);
-});
-var rawArgs = process.argv.slice(2);
-if (rawArgs.length === 1 && (rawArgs[0] === "--version" || rawArgs[0] === "-v")) {
-  process.stdout.write(`${VERSION}
-`);
-  process.exit(ExitCode.Ok);
-}
-if (rawArgs.includes("--schema")) {
-  const positional = rawArgs.filter((a) => !a.startsWith("-"));
-  const handlerName = positional.slice(0, 2).join(".");
-  const handler = allHandlers.find((h) => h.name === handlerName);
-  if (handler) {
-    emitJSON(exportHandlerSchema(handler));
-    process.exit(ExitCode.Ok);
-  }
-}
-runCommand(main, { rawArgs }).then(() => process.exit(ExitCode.Ok)).catch((err) => {
-  reportError(err);
-  if (err instanceof CLIError) process.exit(err.exitCode);
-  if (err instanceof ZodError) process.exit(ExitCode.UserError);
-  process.exit(ExitCode.Unexpected);
-});
-function reportError(err) {
-  if (err instanceof CLIError) {
-    consola7.error(err.message);
-    if (err.hint) consola7.info(err.hint);
-    return;
-  }
-  if (err instanceof ZodError) {
-    consola7.error("Invalid input:");
-    for (const issue of err.issues) {
-      const path = issue.path.length ? issue.path.join(".") : "(root)";
-      consola7.error(`  ${path}: ${issue.message}`);
-    }
-    return;
-  }
-  consola7.error(err instanceof Error ? err.message : String(err));
-}
-//# sourceMappingURL=cli.js.map