@dropthis/cli 0.1.5

package/dist/cli.cjs

@@ -0,0 +1,1489 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/program.ts
+var import_commander = require("commander");
+
+// src/auth.ts
+async function resolveCredential(input) {
+  if (input.apiKey) return { apiKey: input.apiKey, source: "flag" };
+  if (input.env.DROPTHIS_API_KEY) {
+    return { apiKey: input.env.DROPTHIS_API_KEY, source: "env" };
+  }
+  const stored = await input.store.read();
+  if (!stored) return null;
+  return {
+    apiKey: stored.apiKey,
+    source: "storage",
+    ...stored.keyId ? { keyId: stored.keyId } : {},
+    ...stored.keyLast4 ? { keyLast4: stored.keyLast4 } : {},
+    ...stored.accountId ? { accountId: stored.accountId } : {},
+    ...stored.email ? { email: stored.email } : {}
+  };
+}
+function maskKey(apiKey) {
+  return apiKey.length <= 8 ? "sk_..." : `${apiKey.slice(0, 3)}...${apiKey.slice(-4)}`;
+}
+
+// src/output.ts
+var UPLOAD_NEXT_ACTIONS = {
+  upload_expired: "Create a new upload session and retry the publish.",
+  upload_already_used: "Create a new upload session; upload sessions are single-use.",
+  upload_verification_failed: "Re-upload the file bytes and complete the upload again.",
+  too_many_active_uploads: "Cancel unused uploads or wait for expired uploads to be cleaned.",
+  upload_not_complete: "Complete the upload session before publishing."
+};
+function createOutput(input) {
+  const json = input.json === true || input.quiet === true || input.stdoutIsTTY === false || input.env.CI === "true";
+  return { mode: json ? "json" : "human", quiet: input.quiet === true };
+}
+function errorEnvelope(code, message, nextAction) {
+  return {
+    ok: false,
+    error: {
+      code,
+      message,
+      ...nextAction ? { next_action: nextAction } : {}
+    }
+  };
+}
+function apiErrorEnvelope(error) {
+  return {
+    ok: false,
+    error: {
+      code: error.code ?? "api_error",
+      message: error.message,
+      ...error.statusCode !== void 0 ? { status: error.statusCode } : {},
+      ...typeof error.detail === "string" ? { detail: error.detail } : {},
+      ...error.param ? { param: error.param } : {},
+      ...error.currentRevision !== void 0 ? { current_revision: error.currentRevision } : {},
+      ...error.requestId ? { request_id: error.requestId } : {},
+      next_action: nextActionForApiError(error)
+    }
+  };
+}
+function nextActionForApiError(error) {
+  const uploadNextAction = error.code ? UPLOAD_NEXT_ACTIONS[error.code] : void 0;
+  if (uploadNextAction) return uploadNextAction;
+  if (error.code === "revision_conflict") {
+    return "Fetch the drop, merge your changes, and retry with the current revision.";
+  }
+  if (error.statusCode === 401 || error.code === "missing_api_key") {
+    return "Authenticate with dropthis login or set DROPTHIS_API_KEY.";
+  }
+  if (error.statusCode === 413 || error.code === "quota_exceeded") {
+    return "Reduce the upload size or upgrade the account limit.";
+  }
+  if (error.statusCode === 422) {
+    return "Fix the input shown in the error detail and retry.";
+  }
+  if (error.statusCode !== void 0 && error.statusCode !== null && error.statusCode >= 500) {
+    return "Retry the request with the same idempotency key, or contact support with the request id.";
+  }
+  return "Fix the request or retry after checking the drop state.";
+}
+function exitCodeFor(code) {
+  if (code === "invalid_usage") return 2;
+  if (code === "auth_error") return 3;
+  if (code === "local_input_error") return 4;
+  if (code === "network_error") return 5;
+  return 1;
+}
+
+// src/commands/account.ts
+async function runAccountGet(_input, deps) {
+  if (await resolveCredential({ env: deps.env, store: deps.store }) === null) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+    );
+    return { exitCode: exitCodeFor("auth_error") };
+  }
+  const result = await deps.client.account.get();
+  if (result.error) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("api_error", result.error.message))}
+`
+    );
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  deps.stdout(`${JSON.stringify({ ok: true, account: result.data })}
+`);
+  return { exitCode: 0 };
+}
+
+// src/commands/api-keys.ts
+async function runApiKeysCreate(input, deps) {
+  if (!await hasCredential(deps)) return authError(deps);
+  const result = await deps.client.apiKeys.create({ label: input.label });
+  if (result.error) return apiError(deps, result.error.message);
+  deps.stdout(`${JSON.stringify({ ok: true, api_key: result.data })}
+`);
+  return { exitCode: 0 };
+}
+async function runApiKeysList(_input, deps) {
+  if (!await hasCredential(deps)) return authError(deps);
+  const result = await deps.client.apiKeys.list();
+  if (result.error) return apiError(deps, result.error.message);
+  deps.stdout(
+    `${JSON.stringify({ ok: true, api_keys: listItems(result.data) })}
+`
+  );
+  return { exitCode: 0 };
+}
+async function runApiKeysDelete(keyId, input, deps) {
+  if (!input.yes && input.interactive === false) {
+    return invalidUsage(deps, "Pass --yes to delete in non-interactive mode.");
+  }
+  if (!await hasCredential(deps)) return authError(deps);
+  const result = await deps.client.apiKeys.delete(keyId);
+  if (result?.error) return apiError(deps, result.error.message);
+  deps.stdout(`${JSON.stringify({ ok: true, deleted: true, id: keyId })}
+`);
+  return { exitCode: 0 };
+}
+async function hasCredential(deps) {
+  return await resolveCredential({ env: deps.env, store: deps.store }) !== null;
+}
+function listItems(data) {
+  if (data && typeof data === "object" && "data" in data) {
+    return data.data;
+  }
+  if (data && typeof data === "object" && "apiKeys" in data) {
+    return data.apiKeys;
+  }
+  return data;
+}
+function authError(deps) {
+  deps.stderr(
+    `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+  );
+  return { exitCode: exitCodeFor("auth_error") };
+}
+function apiError(deps, message) {
+  deps.stderr(`${JSON.stringify(errorEnvelope("api_error", message))}
+`);
+  return { exitCode: exitCodeFor("api_error") };
+}
+function invalidUsage(deps, message) {
+  deps.stderr(`${JSON.stringify(errorEnvelope("invalid_usage", message))}
+`);
+  return { exitCode: exitCodeFor("invalid_usage") };
+}
+
+// src/commands/commands.ts
+var COMMANDS = [
+  {
+    name: "publish",
+    description: "Publish an input and return a Dropthis URL.",
+    arguments: ["input"],
+    options: ["--json", "--url", "--dry-run", "--title", "--metadata"],
+    examples: [
+      "dropthis publish ./site --json",
+      "dropthis publish ./site --url",
+      "dropthis publish ./dist --dry-run"
+    ]
+  },
+  {
+    name: "update",
+    description: "Update an existing drop by id.",
+    arguments: ["target", "input"],
+    options: ["--json", "--url", "--dry-run", "--if-revision"],
+    examples: [
+      "dropthis update drop_abc ./site --json",
+      "dropthis update drop_abc --title 'New Title' --dry-run"
+    ]
+  },
+  {
+    name: "deployments list <dropId>",
+    description: "List deployments for a drop.",
+    arguments: ["dropId"],
+    options: ["--json", "--limit", "--cursor"],
+    auth: "required",
+    examples: ["dropthis deployments list drop_abc --json"]
+  },
+  {
+    name: "deployments get <dropId> <deploymentId>",
+    description: "Get deployment details for a drop.",
+    arguments: ["dropId", "deploymentId"],
+    options: ["--json"],
+    auth: "required",
+    examples: ["dropthis deployments get drop_abc dep_abc --json"]
+  },
+  {
+    name: "drops",
+    description: "List, inspect, update, and delete drops.",
+    examples: ["dropthis drops list --json"]
+  },
+  {
+    name: "api-keys",
+    description: "Create, list, and delete API keys.",
+    examples: ["dropthis api-keys create --label CI --json"]
+  },
+  {
+    name: "login",
+    description: "Authenticate with email OTP and store an API key.",
+    examples: [
+      "dropthis login verify --email user@example.com --otp 123456 --json"
+    ]
+  },
+  {
+    name: "logout",
+    description: "Remove stored local credentials.",
+    examples: ["dropthis logout --json"]
+  },
+  {
+    name: "whoami",
+    description: "Show current auth source and credential metadata.",
+    examples: ["dropthis whoami --json"]
+  },
+  {
+    name: "account",
+    description: "Get account details.",
+    examples: ["dropthis account get --json"]
+  },
+  {
+    name: "doctor",
+    description: "Report local CLI diagnostics.",
+    examples: ["dropthis doctor --json"]
+  },
+  {
+    name: "commands",
+    description: "Print this machine-readable command tree.",
+    examples: ["dropthis commands --json"]
+  }
+];
+async function runCommands(_input, deps) {
+  deps.stdout(
+    `${JSON.stringify({
+      ok: true,
+      output: "JSON by default in CI, pipes, non-TTY, --json, or --quiet.",
+      commands: COMMANDS
+    })}
+`
+  );
+  return { exitCode: 0 };
+}
+
+// src/commands/deployments.ts
+async function runDeploymentsList(dropId, input, deps) {
+  if (!await hasCredential2(deps)) return authError2(deps);
+  const params = {
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.cursor ? { cursor: input.cursor } : {}
+  };
+  const result = await deps.client.deployments.list(dropId, params);
+  if (result.error) {
+    deps.stderr(`${JSON.stringify(apiErrorEnvelope(result.error))}
+`);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  deps.stdout(`${JSON.stringify({ ok: true, ...spreadData(result.data) })}
+`);
+  return { exitCode: 0 };
+}
+async function runDeploymentsGet(dropId, deploymentId, _input, deps) {
+  if (!await hasCredential2(deps)) return authError2(deps);
+  const result = await deps.client.deployments.get(dropId, deploymentId);
+  if (result.error) {
+    deps.stderr(`${JSON.stringify(apiErrorEnvelope(result.error))}
+`);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  deps.stdout(`${JSON.stringify({ ok: true, deployment: result.data })}
+`);
+  return { exitCode: 0 };
+}
+async function hasCredential2(deps) {
+  return await resolveCredential({
+    ...deps.apiKey ? { apiKey: deps.apiKey } : {},
+    env: deps.env,
+    store: deps.store
+  }) !== null;
+}
+function authError2(deps) {
+  deps.stderr(
+    `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+  );
+  return { exitCode: exitCodeFor("auth_error") };
+}
+function spreadData(data) {
+  return data && typeof data === "object" ? data : { data };
+}
+
+// src/commands/doctor.ts
+async function runDoctor(_input, deps) {
+  const stored = await deps.store.read();
+  const credential = await resolveCredential({
+    env: deps.env,
+    store: deps.store
+  });
+  deps.stdout(
+    `${JSON.stringify({
+      ok: true,
+      version: "0.1.0",
+      auth: { source: credential?.source ?? "missing" },
+      storage: { backend: stored?.storage ?? "none" }
+    })}
+`
+  );
+  return { exitCode: 0 };
+}
+
+// src/options.ts
+var import_promises = require("fs/promises");
+async function parseDropOptions(raw) {
+  if (raw.metadata && raw.metadataFile) {
+    throw new Error("Use either --metadata or --metadata-file, not both.");
+  }
+  if (raw.password && raw.noPassword) {
+    throw new Error("Use either --password or --no-password, not both.");
+  }
+  if (raw.noindex && raw.index) {
+    throw new Error("Use either --noindex or --index, not both.");
+  }
+  const metadata = raw.metadata ? parseJsonObject(raw.metadata, "--metadata") : raw.metadataFile ? parseJsonObject(
+    await (0, import_promises.readFile)(raw.metadataFile, "utf8"),
+    "--metadata-file"
+  ) : void 0;
+  return {
+    ...raw.slug ? { slug: raw.slug } : {},
+    ...raw.title ? { title: raw.title } : {},
+    ...raw.visibility ? { visibility: raw.visibility } : {},
+    ...raw.password ? { password: raw.password } : {},
+    ...raw.noPassword ? { password: null } : {},
+    ...raw.noindex ? { noindex: true } : {},
+    ...raw.index ? { noindex: false } : {},
+    ...raw.expiresAt ? { expiresAt: raw.expiresAt } : {},
+    ...metadata ? { metadata } : {},
+    ...raw.entry ? { entry: raw.entry } : {},
+    ...raw.contentType ? { contentType: raw.contentType } : {},
+    ...raw.path ? { path: raw.path } : {},
+    ...raw.idempotencyKey ? { idempotencyKey: raw.idempotencyKey } : {}
+  };
+}
+function parseJsonObject(value, label) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+
+// src/commands/drops.ts
+async function runDropsList(input, deps) {
+  if (!await hasCredential3(deps)) return authError3(deps);
+  const params = {
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.cursor ? { cursor: input.cursor } : {}
+  };
+  const result = await deps.client.drops.list(params);
+  if (result.error) return apiError2(deps, result.error.message);
+  deps.stdout(
+    `${JSON.stringify({ ok: true, drops: listItems2(result.data) })}
+`
+  );
+  return { exitCode: 0 };
+}
+async function runDropsGet(dropId, _input, deps) {
+  if (!await hasCredential3(deps)) return authError3(deps);
+  const result = await deps.client.drops.get(dropId);
+  if (result.error) return apiError2(deps, result.error.message);
+  deps.stdout(`${JSON.stringify({ ok: true, drop: result.data })}
+`);
+  return { exitCode: 0 };
+}
+async function runDropsUpdate(dropId, input, deps) {
+  if (!await hasCredential3(deps)) return authError3(deps);
+  try {
+    const options = await parseDropOptions(input);
+    const result = await deps.client.drops.update(dropId, options);
+    if (result.error) return apiError2(deps, result.error.message);
+    deps.stdout(`${JSON.stringify({ ok: true, drop: result.data })}
+`);
+    return { exitCode: 0 };
+  } catch (error) {
+    return invalidUsage2(
+      deps,
+      error instanceof Error ? error.message : "Invalid drop options."
+    );
+  }
+}
+async function runDropsDelete(dropId, input, deps) {
+  if (!input.yes && input.interactive === false) {
+    return invalidUsage2(deps, "Pass --yes to delete in non-interactive mode.");
+  }
+  if (!await hasCredential3(deps)) return authError3(deps);
+  const result = await deps.client.drops.delete(dropId);
+  if (result?.error) return apiError2(deps, result.error.message);
+  deps.stdout(`${JSON.stringify({ ok: true, deleted: true, id: dropId })}
+`);
+  return { exitCode: 0 };
+}
+async function hasCredential3(deps) {
+  return await resolveCredential({ env: deps.env, store: deps.store }) !== null;
+}
+function listItems2(data) {
+  if (data && typeof data === "object" && "data" in data) {
+    return data.data;
+  }
+  if (data && typeof data === "object" && "drops" in data) {
+    return data.drops;
+  }
+  return data;
+}
+function authError3(deps) {
+  deps.stderr(
+    `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+  );
+  return { exitCode: exitCodeFor("auth_error") };
+}
+function apiError2(deps, message) {
+  deps.stderr(`${JSON.stringify(errorEnvelope("api_error", message))}
+`);
+  return { exitCode: exitCodeFor("api_error") };
+}
+function invalidUsage2(deps, message) {
+  deps.stderr(`${JSON.stringify(errorEnvelope("invalid_usage", message))}
+`);
+  return { exitCode: exitCodeFor("invalid_usage") };
+}
+
+// src/commands/login.ts
+var prompts = __toESM(require("@clack/prompts"), 1);
+async function runLoginInteractive(deps) {
+  prompts.intro("dropthis login");
+  const email = await prompts.text({
+    message: "Email address",
+    validate: (v) => v?.includes("@") ? void 0 : "Enter a valid email"
+  });
+  if (prompts.isCancel(email)) {
+    prompts.cancel("Login cancelled.");
+    return { exitCode: 0 };
+  }
+  const requestResult = await deps.client.auth.requestEmailOtp({ email });
+  if (requestResult.error) {
+    prompts.cancel(requestResult.error.message);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  const otp = await prompts.text({
+    message: "Paste the code from your email"
+  });
+  if (prompts.isCancel(otp)) {
+    prompts.cancel("Login cancelled.");
+    return { exitCode: 0 };
+  }
+  const session = await deps.client.auth.verifyEmailOtp({ email, code: otp });
+  if (session.error) {
+    prompts.cancel(session.error.message);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  const authedClient = deps.createClient(session.data.token);
+  const apiKey = await authedClient.apiKeys.create({ label: "CLI" });
+  if (apiKey.error) {
+    prompts.cancel(apiKey.error.message);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  await deps.store.save({
+    apiKey: apiKey.data.key,
+    keyId: apiKey.data.id,
+    keyLast4: apiKey.data.keyLast4,
+    accountId: apiKey.data.accountId ?? session.data.accountId,
+    email,
+    storage: "secure"
+  });
+  prompts.outro("Logged in successfully.");
+  return { exitCode: 0 };
+}
+async function runLoginRequest(input, deps) {
+  const result = await deps.client.auth.requestEmailOtp({
+    email: input.email
+  });
+  if (result.error) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("api_error", result.error.message))}
+`
+    );
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  deps.stdout(
+    `${JSON.stringify({
+      ok: true,
+      email: input.email,
+      expires_in: result.data.expiresIn
+    })}
+`
+  );
+  return { exitCode: 0 };
+}
+async function runLoginVerify(input, deps) {
+  const session = await deps.client.auth.verifyEmailOtp({
+    email: input.email,
+    code: input.otp
+  });
+  if (session.error) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("api_error", session.error.message))}
+`
+    );
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  const apiKey = await deps.client.apiKeys.create({ label: "CLI" });
+  if (apiKey.error) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("api_error", apiKey.error.message))}
+`
+    );
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  await deps.store.save({
+    apiKey: apiKey.data.key,
+    keyId: apiKey.data.id,
+    keyLast4: apiKey.data.keyLast4,
+    accountId: apiKey.data.accountId ?? session.data.accountId,
+    email: input.email,
+    storage: "secure"
+  });
+  deps.stdout(
+    `${JSON.stringify({
+      ok: true,
+      account_id: apiKey.data.accountId ?? session.data.accountId,
+      key_id: apiKey.data.id,
+      key_last4: apiKey.data.keyLast4,
+      is_new_account: apiKey.data.isNewAccount ?? session.data.isNewAccount
+    })}
+`
+  );
+  return { exitCode: 0 };
+}
+
+// src/commands/logout.ts
+async function runLogout(input, deps) {
+  const stored = await deps.store.read();
+  let revokeError;
+  if (input.revoke && stored?.keyId) {
+    const result = await deps.client.apiKeys.delete(stored.keyId);
+    if (result?.error) revokeError = result.error.message;
+  }
+  await deps.store.clear();
+  if (revokeError) {
+    deps.stderr(`${JSON.stringify(errorEnvelope("api_error", revokeError))}
+`);
+    return { exitCode: exitCodeFor("api_error") };
+  }
+  deps.stdout(`${JSON.stringify({ ok: true })}
+`);
+  return { exitCode: 0 };
+}
+
+// src/commands/publish.ts
+var import_node_crypto = require("crypto");
+var import_promises3 = require("fs/promises");
+var import_node_path = require("path");
+
+// src/commands/json_body.ts
+var import_promises2 = require("fs/promises");
+async function readJsonObjectFile(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await (0, import_promises2.readFile)(path, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parse error";
+    throw new Error(`Invalid JSON body in ${path}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("JSON body must be an object.");
+  }
+  return parsed;
+}
+
+// src/commands/publish.ts
+var MAX_BUNDLE_FILE_COUNT = 200;
+async function runPublish(input, raw, deps) {
+  const credential = await resolveCredential({
+    ...raw.apiKey ? { apiKey: raw.apiKey } : {},
+    env: deps.env,
+    store: deps.store
+  });
+  if (!credential) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+    );
+    return { exitCode: exitCodeFor("auth_error") };
+  }
+  if (raw.dryRun) {
+    return handlePublishDryRun(input, raw, deps);
+  }
+  const singleInput = Array.isArray(input) ? input[0] : input;
+  try {
+    if (raw.fromJson && singleInput) {
+      throw new Error("Use either <input> or --from-json, not both.");
+    }
+    const options = withPublishIdempotency(await parseDropOptions(raw));
+    const result = raw.fromJson ? await deps.client.drops.createRaw(
+      await (deps.readJsonObject ?? readJsonObjectFile)(raw.fromJson),
+      options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {}
+    ) : singleInput ? await deps.client.publish(singleInput, options) : (() => {
+      throw new Error("Publish requires <input> or --from-json.");
+    })();
+    if (result.error) {
+      deps.stderr(`${JSON.stringify(apiErrorEnvelope(result.error))}
+`);
+      return { exitCode: exitCodeFor("api_error") };
+    }
+    if (raw.url) deps.stdout(`${result.data.url}
+`);
+    else if (deps.outputMode === "human")
+      deps.stdout(`Published: ${result.data.url}
+`);
+    else deps.stdout(`${JSON.stringify({ ok: true, drop: result.data })}
+`);
+    return { exitCode: 0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Publish failed.";
+    deps.stderr(`${JSON.stringify(errorEnvelope("invalid_usage", message))}
+`);
+    return { exitCode: exitCodeFor("invalid_usage") };
+  }
+}
+async function handlePublishDryRun(input, raw, deps) {
+  if (raw.url) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("invalid_usage", "--url and --dry-run cannot be combined.", "Remove --url; dry-run outputs JSON describing what would be published."))}
+`
+    );
+    return { exitCode: exitCodeFor("invalid_usage") };
+  }
+  try {
+    if (raw.fromJson) {
+      if (input)
+        throw new Error("Use either <input> or --from-json, not both.");
+      const body = await (deps.readJsonObject ?? readJsonObjectFile)(
+        raw.fromJson
+      );
+      deps.stdout(
+        `${JSON.stringify({ dryRun: true, kind: "raw_json", endpoint: "POST /drops", body }, null, 2)}
+`
+      );
+      return { exitCode: 0 };
+    }
+    if (!input || Array.isArray(input) && input.length === 0) {
+      throw new Error("Publish requires <input> or --from-json.");
+    }
+    const options = await parseDropOptions(raw);
+    if (Array.isArray(input)) {
+      return dryRunMultiFile(input, options, deps);
+    }
+    if (!deps.client.prepare) {
+      throw new Error("Client does not support dry-run.");
+    }
+    const prepared = await deps.client.prepare(input, options);
+    const output = formatDryRunOutput(prepared);
+    validateDryRunOutput(output);
+    deps.stdout(`${JSON.stringify(output, null, 2)}
+`);
+    return { exitCode: 0 };
+  } catch (error) {
+    const code = isFileSystemError(error) ? "local_input_error" : "invalid_usage";
+    const message = error instanceof Error ? error.message : "Dry-run failed.";
+    deps.stderr(`${JSON.stringify(errorEnvelope(code, message))}
+`);
+    return { exitCode: exitCodeFor(code) };
+  }
+}
+async function dryRunMultiFile(inputs, options, deps) {
+  const files = [];
+  for (const filePath of inputs) {
+    let info;
+    try {
+      info = await (0, import_promises3.stat)(filePath);
+    } catch {
+      deps.stderr(
+        `${JSON.stringify(errorEnvelope("local_input_error", `File not found: ${filePath}`))}
+`
+      );
+      return { exitCode: exitCodeFor("local_input_error") };
+    }
+    if (info.isDirectory()) {
+      deps.stderr(
+        `${JSON.stringify(errorEnvelope("local_input_error", `Cannot mix directories with multiple file arguments. Use a single folder instead: dropthis publish ${filePath}`))}
+`
+      );
+      return { exitCode: exitCodeFor("local_input_error") };
+    }
+    files.push({
+      path: (0, import_node_path.basename)(filePath),
+      contentType: mimeForPath(filePath),
+      sizeBytes: info.size
+    });
+  }
+  if (files.length > MAX_BUNDLE_FILE_COUNT) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("local_input_error", `Bundle contains ${files.length} files, exceeding the maximum of ${MAX_BUNDLE_FILE_COUNT}.`))}
+`
+    );
+    return { exitCode: exitCodeFor("local_input_error") };
+  }
+  const entry = options.entry ?? files.find((f) => f.path === "index.html")?.path ?? files[0]?.path ?? null;
+  const totalBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const output = {
+    dryRun: true,
+    kind: "staged",
+    manifest: { files, entry },
+    options: dryRunOptionsBody(options),
+    totalBytes
+  };
+  deps.stdout(`${JSON.stringify(output, null, 2)}
+`);
+  return { exitCode: 0 };
+}
+function formatDryRunOutput(prepared) {
+  const totalBytes = prepared.manifest.files.reduce(
+    (sum, f) => sum + f.sizeBytes,
+    0
+  );
+  return {
+    dryRun: true,
+    kind: "staged",
+    manifest: {
+      files: prepared.manifest.files,
+      entry: prepared.manifest.entry ?? null
+    },
+    options: prepared.options,
+    ...prepared.metadata ? { metadata: prepared.metadata } : {},
+    totalBytes
+  };
+}
+function validateDryRunOutput(output) {
+  if (output.kind !== "staged") return;
+  const manifest = output.manifest;
+  if (manifest.files.length > MAX_BUNDLE_FILE_COUNT) {
+    throw Object.assign(
+      new Error(
+        `Bundle contains ${manifest.files.length} files, exceeding the maximum of ${MAX_BUNDLE_FILE_COUNT}.`
+      ),
+      { code: "ELIMIT" }
+    );
+  }
+}
+function dryRunOptionsBody(options) {
+  const result = {};
+  if (options.title) result.title = options.title;
+  if (options.visibility) result.visibility = options.visibility;
+  if (options.password !== void 0) result.password = options.password;
+  if (options.noindex !== void 0) result.noindex = options.noindex;
+  if (options.expiresAt) result.expires_at = options.expiresAt;
+  return result;
+}
+function mimeForPath(filePath) {
+  const ext = (0, import_node_path.extname)(filePath).toLowerCase();
+  const types = {
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".mjs": "text/javascript",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".ico": "image/x-icon",
+    ".avif": "image/avif",
+    ".pdf": "application/pdf",
+    ".zip": "application/zip",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm"
+  };
+  return types[ext] ?? "application/octet-stream";
+}
+function isFileSystemError(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR" || code === "ELIMIT";
+}
+function withPublishIdempotency(options) {
+  return options.idempotencyKey ? options : { ...options, idempotencyKey: `cli_pub_${(0, import_node_crypto.randomUUID)()}` };
+}
+
+// src/commands/update.ts
+var import_node_crypto2 = require("crypto");
+async function runUpdate(target, input, raw, deps) {
+  const credential = await resolveCredential({
+    ...raw.apiKey ? { apiKey: raw.apiKey } : {},
+    env: deps.env,
+    store: deps.store
+  });
+  if (!credential) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("auth_error", "No API key found.", "Set DROPTHIS_API_KEY or run dropthis login."))}
+`
+    );
+    return { exitCode: exitCodeFor("auth_error") };
+  }
+  if (raw.dryRun) {
+    return handleUpdateDryRun(target, input, raw, deps);
+  }
+  try {
+    assertDropId(target);
+    if (raw.fromJson && input) {
+      throw new Error("Use either [input] or --from-json, not both.");
+    }
+    const parsed = await parseDropOptions(raw);
+    const revisionOptions = raw.ifRevision !== void 0 ? { ifRevision: Number(raw.ifRevision) } : {};
+    const result = raw.fromJson ? await deps.client.deployments.createRaw(
+      target,
+      await (deps.readJsonObject ?? readJsonObjectFile)(raw.fromJson),
+      withUpdateIdempotency({
+        ...revisionOptions,
+        ...parsed.idempotencyKey ? { idempotencyKey: parsed.idempotencyKey } : {}
+      })
+    ) : input ? await deps.client.update(
+      target,
+      input,
+      withUpdateIdempotency({
+        ...parsed,
+        ...revisionOptions
+      })
+    ) : await deps.client.update(target, parsed, revisionOptions);
+    if (result.error) {
+      deps.stderr(`${JSON.stringify(apiErrorEnvelope(result.error))}
+`);
+      return { exitCode: exitCodeFor("api_error") };
+    }
+    if (raw.url) deps.stdout(`${result.data.url}
+`);
+    else if (deps.outputMode === "human")
+      deps.stdout(`Updated: ${result.data.url}
+`);
+    else deps.stdout(`${JSON.stringify({ ok: true, drop: result.data })}
+`);
+    return { exitCode: 0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Update failed.";
+    deps.stderr(`${JSON.stringify(errorEnvelope("invalid_usage", message))}
+`);
+    return { exitCode: exitCodeFor("invalid_usage") };
+  }
+}
+async function handleUpdateDryRun(target, input, raw, deps) {
+  if (raw.url) {
+    deps.stderr(
+      `${JSON.stringify(errorEnvelope("invalid_usage", "--url and --dry-run cannot be combined.", "Remove --url; dry-run outputs JSON describing what would be published."))}
+`
+    );
+    return { exitCode: exitCodeFor("invalid_usage") };
+  }
+  try {
+    assertDropId(target);
+    if (raw.fromJson) {
+      if (input)
+        throw new Error("Use either [input] or --from-json, not both.");
+      const body = await (deps.readJsonObject ?? readJsonObjectFile)(
+        raw.fromJson
+      );
+      deps.stdout(
+        `${JSON.stringify({ dryRun: true, kind: "raw_json", endpoint: `POST /drops/${target}/deployments`, body }, null, 2)}
+`
+      );
+      return { exitCode: 0 };
+    }
+    const options = await parseDropOptions(raw);
+    if (!input) {
+      const fields = {};
+      if (options.slug) fields.slug = options.slug;
+      if (options.title) fields.title = options.title;
+      if (options.visibility) fields.visibility = options.visibility;
+      if (options.password !== void 0) fields.password = options.password;
+      if (options.noindex !== void 0) fields.noindex = options.noindex;
+      if (options.expiresAt) fields.expires_at = options.expiresAt;
+      if (options.metadata) fields.metadata = options.metadata;
+      deps.stdout(
+        `${JSON.stringify({ dryRun: true, kind: "options_update", target, fields }, null, 2)}
+`
+      );
+      return { exitCode: 0 };
+    }
+    if (!deps.client.prepare) {
+      throw new Error("Client does not support dry-run.");
+    }
+    const prepared = await deps.client.prepare(input, options);
+    const output = formatUpdateDryRun(target, prepared);
+    validateDryRunFileCount(output);
+    deps.stdout(`${JSON.stringify(output, null, 2)}
+`);
+    return { exitCode: 0 };
+  } catch (error) {
+    const code = isFileSystemError2(error) ? "local_input_error" : "invalid_usage";
+    const message = error instanceof Error ? error.message : "Dry-run failed.";
+    deps.stderr(`${JSON.stringify(errorEnvelope(code, message))}
+`);
+    return { exitCode: exitCodeFor(code) };
+  }
+}
+var MAX_BUNDLE_FILE_COUNT2 = 200;
+function formatUpdateDryRun(target, prepared) {
+  const totalBytes = prepared.manifest.files.reduce(
+    (sum, f) => sum + f.sizeBytes,
+    0
+  );
+  return {
+    dryRun: true,
+    kind: "staged",
+    target,
+    manifest: {
+      files: prepared.manifest.files,
+      entry: prepared.manifest.entry ?? null
+    },
+    options: prepared.options,
+    ...prepared.metadata ? { metadata: prepared.metadata } : {},
+    totalBytes
+  };
+}
+function validateDryRunFileCount(output) {
+  if (output.kind !== "staged") return;
+  const manifest = output.manifest;
+  if (manifest.files.length > MAX_BUNDLE_FILE_COUNT2) {
+    throw Object.assign(
+      new Error(
+        `Bundle contains ${manifest.files.length} files, exceeding the maximum of ${MAX_BUNDLE_FILE_COUNT2}.`
+      ),
+      { code: "ELIMIT" }
+    );
+  }
+}
+function isFileSystemError2(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function withUpdateIdempotency(options) {
+  return options.idempotencyKey ? options : { ...options, idempotencyKey: `cli_upd_${(0, import_node_crypto2.randomUUID)()}` };
+}
+function assertDropId(target) {
+  if (!target.startsWith("drop_")) {
+    throw new Error(
+      "Update target must be a drop id returned by --json output, for example drop_..."
+    );
+  }
+}
+
+// src/commands/whoami.ts
+async function runWhoami(_input, deps) {
+  const credential = await resolveCredential({
+    env: deps.env,
+    store: deps.store
+  });
+  if (!credential) {
+    deps.stdout(`${JSON.stringify({ ok: true, authenticated: false })}
+`);
+    return { exitCode: 0 };
+  }
+  deps.stdout(
+    `${JSON.stringify({
+      ok: true,
+      authenticated: true,
+      source: credential.source,
+      masked_key: maskKey(credential.apiKey),
+      ...credential.keyId ? { key_id: credential.keyId } : {},
+      ...credential.keyLast4 ? { key_last4: credential.keyLast4 } : {},
+      ...credential.accountId ? { account_id: credential.accountId } : {},
+      ...credential.email ? { email: credential.email } : {}
+    })}
+`
+  );
+  return { exitCode: 0 };
+}
+
+// src/context.ts
+var import_node = require("@dropthis/node");
+function createContext(input) {
+  const env = input.env ?? process.env;
+  const global = input.global ?? {};
+  return {
+    env,
+    global,
+    output: createOutput({
+      ...global.json !== void 0 ? { json: global.json } : {},
+      ...global.quiet !== void 0 ? { quiet: global.quiet } : {},
+      stdoutIsTTY: input.stdoutIsTTY ?? process.stdout.isTTY === true,
+      env
+    }),
+    stdout: input.stdout ?? ((value) => process.stdout.write(value)),
+    stderr: input.stderr ?? ((value) => process.stderr.write(value)),
+    createClient(apiKey) {
+      const baseUrl = global.apiUrl ?? env.DROPTHIS_API_URL;
+      return new import_node.Dropthis({
+        ...apiKey ? { apiKey } : {},
+        ...baseUrl ? { baseUrl } : {}
+      });
+    }
+  };
+}
+
+// src/storage.ts
+var import_promises4 = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var import_keyring = require("@napi-rs/keyring");
+var MemoryCredentialStore = class {
+  credential = null;
+  async read() {
+    return this.credential;
+  }
+  async save(credential) {
+    this.credential = credential;
+  }
+  async clear() {
+    this.credential = null;
+  }
+};
+var InsecureFileCredentialStore = class {
+  filePath;
+  constructor(options = {}) {
+    this.filePath = credentialPath(options.configDir);
+  }
+  async read() {
+    const value = await readJsonFile(this.filePath);
+    return value ? { ...value, storage: "insecure" } : null;
+  }
+  async save(credential) {
+    await writeCredentialFile(this.filePath, {
+      ...credential,
+      storage: "insecure"
+    });
+  }
+  async clear() {
+    await (0, import_promises4.rm)(this.filePath, { force: true });
+  }
+};
+var KeyringCredentialStore = class {
+  filePath;
+  keyring;
+  constructor(options = {}) {
+    this.filePath = credentialPath(options.configDir);
+    this.keyring = options.keyring ?? defaultKeyringAdapter();
+  }
+  async read() {
+    const metadata = await readJsonFile(this.filePath);
+    if (!metadata) return null;
+    const apiKey = await this.keyring.getPassword();
+    if (!apiKey) return null;
+    return { ...metadata, apiKey, storage: "secure" };
+  }
+  async save(credential) {
+    await this.keyring.setPassword(credential.apiKey);
+    const { apiKey: _apiKey, ...metadata } = credential;
+    await writeCredentialFile(this.filePath, {
+      ...metadata,
+      storage: "secure"
+    });
+  }
+  async clear() {
+    await this.keyring.deletePassword();
+    await (0, import_promises4.rm)(this.filePath, { force: true });
+  }
+};
+function createCredentialStore(options = {}) {
+  if (options.insecure) return new InsecureFileCredentialStore(options);
+  return new KeyringCredentialStore(options);
+}
+function defaultKeyringAdapter() {
+  const entry = new import_keyring.Entry("dropthis", "default");
+  return {
+    getPassword: () => entry.getPassword(),
+    setPassword: (value) => entry.setPassword(value),
+    deletePassword: () => {
+      entry.deletePassword();
+    }
+  };
+}
+function credentialPath(configDir) {
+  return (0, import_node_path2.join)(
+    configDir ?? (0, import_node_path2.join)((0, import_node_os.homedir)(), ".config", "dropthis"),
+    "credentials.json"
+  );
+}
+async function readJsonFile(path) {
+  try {
+    return JSON.parse(await (0, import_promises4.readFile)(path, "utf8"));
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function writeCredentialFile(path, credential) {
+  await (0, import_promises4.mkdir)((0, import_node_path2.dirname)(path), { recursive: true });
+  await (0, import_promises4.writeFile)(path, `${JSON.stringify(credential, null, 2)}
+`, {
+    mode: 384
+  });
+  await (0, import_promises4.chmod)(path, 384);
+}
+
+// src/program.ts
+function buildProgram(options = {}) {
+  const program = new import_commander.Command();
+  const store = options.store ?? new MemoryCredentialStore();
+  program.name("dropthis").description("Publish anything online and get a URL back.").version("0.1.5");
+  program.option("--api-key <key>", "Override API key for this invocation");
+  program.option("--api-url <url>", "Override API base URL");
+  program.option("--json", "Force JSON output");
+  program.option("-q, --quiet", "Suppress status output and imply JSON");
+  program.command("login").description("Authenticate with email OTP").option("--email <email>", "Email address").option("--otp <otp>", "One-time passcode").option("--json", "Force JSON output").action(
+    async (commandOptions) => {
+      if (!commandOptions.email || !commandOptions.otp) {
+        const deps2 = await commandDeps(program, options, store, commandOptions);
+        const global = globalOptions(program, commandOptions);
+        const context = createContext({ global });
+        const result2 = await runLoginInteractive({
+          ...deps2,
+          createClient: (apiKey) => context.createClient(apiKey)
+        });
+        process.exitCode = result2.exitCode;
+        return;
+      }
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runLoginVerify(
+        {
+          email: commandOptions.email,
+          otp: commandOptions.otp,
+          ...commandOptions.json !== void 0 ? { json: commandOptions.json } : {}
+        },
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  const login = program.commands.find((command) => command.name() === "login");
+  login?.command("request").description("Request an email OTP").requiredOption("--email <email>", "Email address").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runLoginRequest(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  login?.command("verify").description("Verify email OTP and store an API key").requiredOption("--email <email>", "Email address").requiredOption("--otp <otp>", "One-time passcode").option("--json", "Force JSON output").action(
+    async (commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runLoginVerify(commandOptions, deps);
+      process.exitCode = result.exitCode;
+    }
+  );
+  program.command("logout").description("Remove stored credentials").option("--revoke", "Best-effort revoke the saved API key").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(
+      program,
+      options,
+      store,
+      commandOptions
+    );
+    const result = await runLogout(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  program.command("whoami").description("Show current authentication status").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(
+      program,
+      options,
+      store,
+      commandOptions
+    );
+    const result = await runWhoami(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  program.command("account").description("Account commands").command("get").description("Get account details").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runAccountGet(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  program.command("publish [input...]").description(
+    "Publish files, folders, URLs, strings, or stdin.\nMultiple files are bundled into one drop.\nUse - to read stdin explicitly, or pipe without args."
+  ).option("--from-json <path>", "Read exact POST /drops JSON request body").option("--json", "Force JSON output").option("--title <title>", "Drop title").option("--visibility <visibility>", "Drop visibility").option("--password <password>", "Set password").option("--no-password", "Clear password").option("--noindex", "Prevent indexing").option("--index", "Allow indexing").option("--expires-at <datetime>", "Expiration datetime").option("--metadata <json>", "Metadata JSON object").option("--metadata-file <path>", "Metadata JSON file").option("--entry <path>", "Entry file path").option("--content-type <mime>", "Content type").option("--path <path>", "Path for stdin or byte input").option("--idempotency-key <key>", "Idempotency key").option("--url", "Print only the published URL").option("--dry-run", "Validate without publishing").action(async (inputs, commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY ?? false;
+    let publishInput;
+    if (commandOptions.dryRun && inputs.length > 1) {
+      publishInput = inputs;
+    } else {
+      publishInput = await resolvePublishInputs(
+        inputs,
+        options.stdin,
+        stdinIsTTY
+      );
+    }
+    const result = await runPublish(
+      publishInput,
+      toDropOptions(commandOptions),
+      deps
+    );
+    process.exitCode = result.exitCode;
+  });
+  program.command("update <target> [input]").description("Update an existing drop by id").option("--json", "Force JSON output").option("--slug <slug>", "Replace shared hosted drop slug").option("--title <title>", "Drop title").option("--visibility <visibility>", "Drop visibility").option("--password <password>", "Set password").option("--no-password", "Clear password").option("--noindex", "Prevent indexing").option("--index", "Allow indexing").option("--expires-at <datetime>", "Expiration datetime").option("--metadata <json>", "Metadata JSON object").option("--metadata-file <path>", "Metadata JSON file").option("--entry <path>", "Entry file path").option("--content-type <mime>", "Content type").option("--path <path>", "Path for stdin or byte input").option("--idempotency-key <key>", "Idempotency key").option("--if-revision <n>", "Expected current revision", parseInteger).option(
+    "--from-json <path>",
+    "Read exact POST /drops/{drop_id}/deployments JSON request body"
+  ).option("--url", "Print only the published URL").option("--dry-run", "Validate without publishing").action(
+    async (target, input, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const updateInput = input ? await resolveCommandInput(input, options.stdin) : void 0;
+      const result = await runUpdate(
+        target,
+        updateInput,
+        toDropOptions(commandOptions),
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  const drops = program.command("drops").description("Drop resource commands");
+  drops.command("list").option("--limit <n>", "Page size", parseInteger).option("--cursor <cursor>", "Pagination cursor").option("--json", "Force JSON output").action(
+    async (commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDropsList(commandOptions, deps);
+      process.exitCode = result.exitCode;
+    }
+  );
+  drops.command("get <dropId>").option("--json", "Force JSON output").action(async (dropId, commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runDropsGet(dropId, commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  drops.command("update <dropId>").option("--json", "Force JSON output").option("--title <title>", "Drop title").option("--visibility <visibility>", "Drop visibility").option("--password <password>", "Set password").option("--no-password", "Clear password").option("--noindex", "Prevent indexing").option("--index", "Allow indexing").option("--expires-at <datetime>", "Expiration datetime").option("--metadata <json>", "Metadata JSON object").option("--metadata-file <path>", "Metadata JSON file").action(async (dropId, commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runDropsUpdate(
+      dropId,
+      toDropOptions(commandOptions),
+      deps
+    );
+    process.exitCode = result.exitCode;
+  });
+  drops.command("delete <dropId>").option("--yes", "Confirm deletion").option("--json", "Force JSON output").action(
+    async (dropId, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDropsDelete(
+        dropId,
+        { ...commandOptions, interactive: deps.outputMode === "human" },
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  const apiKeys = program.command("api-keys").description("API key commands");
+  apiKeys.command("create").option("--label <label>", "API key label", "CLI").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runApiKeysCreate(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  apiKeys.command("list").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(program, options, store, commandOptions);
+    const result = await runApiKeysList(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  apiKeys.command("delete <keyId>").option("--yes", "Confirm deletion").option("--json", "Force JSON output").action(
+    async (keyId, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runApiKeysDelete(
+        keyId,
+        { ...commandOptions, interactive: deps.outputMode === "human" },
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  const deployments = program.command("deployments").description("Deployment commands");
+  deployments.command("list <dropId>").option("--limit <n>", "Page size", parseInteger).option("--cursor <cursor>", "Pagination cursor").option("--json", "Force JSON output").action(
+    async (dropId, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDeploymentsList(dropId, commandOptions, deps);
+      process.exitCode = result.exitCode;
+    }
+  );
+  deployments.command("get <dropId> <deploymentId>").option("--json", "Force JSON output").action(
+    async (dropId, deploymentId, commandOptions) => {
+      const deps = await commandDeps(program, options, store, commandOptions);
+      const result = await runDeploymentsGet(
+        dropId,
+        deploymentId,
+        commandOptions,
+        deps
+      );
+      process.exitCode = result.exitCode;
+    }
+  );
+  program.command("doctor").description("Report CLI diagnostics").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(
+      program,
+      options,
+      store,
+      commandOptions
+    );
+    const result = await runDoctor(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  program.command("commands").description("Print machine-readable command metadata").option("--json", "Force JSON output").action(async (commandOptions) => {
+    const deps = await commandDeps(
+      program,
+      options,
+      store,
+      commandOptions
+    );
+    const result = await runCommands(commandOptions, deps);
+    process.exitCode = result.exitCode;
+  });
+  return program;
+}
+async function commandDeps(program, options, store, commandOptions) {
+  const global = globalOptions(program, commandOptions);
+  const context = createContext({
+    global,
+    ...options.env !== void 0 ? { env: options.env } : {},
+    ...options.stdout !== void 0 ? { stdout: options.stdout } : {},
+    ...options.stderr !== void 0 ? { stderr: options.stderr } : {},
+    ...options.stdoutIsTTY !== void 0 ? { stdoutIsTTY: options.stdoutIsTTY } : {}
+  });
+  const credential = await resolveCredential({
+    ...global.apiKey ? { apiKey: global.apiKey } : {},
+    env: context.env,
+    store
+  });
+  return {
+    store,
+    client: options.client ?? context.createClient(credential?.apiKey),
+    ...global.apiKey ? { apiKey: global.apiKey } : {},
+    env: context.env,
+    stdout: context.stdout,
+    stderr: context.stderr,
+    outputMode: context.output.mode
+  };
+}
+function globalOptions(program, commandOptions) {
+  const opts = program.opts();
+  return {
+    ...opts.apiKey ? { apiKey: opts.apiKey } : {},
+    ...opts.apiUrl ? { apiUrl: opts.apiUrl } : {},
+    ...commandOptions.json !== void 0 ? { json: commandOptions.json } : opts.json !== void 0 ? { json: opts.json } : {},
+    ...commandOptions.quiet !== void 0 ? { quiet: commandOptions.quiet } : opts.quiet !== void 0 ? { quiet: opts.quiet } : {}
+  };
+}
+function toDropOptions(options) {
+  return {
+    ...options.slug ? { slug: options.slug } : {},
+    ...options.title ? { title: options.title } : {},
+    ...options.visibility === "public" || options.visibility === "unlisted" ? { visibility: options.visibility } : {},
+    ...typeof options.password === "string" ? { password: options.password } : {},
+    ...options.password === false || options.noPassword ? { noPassword: true } : {},
+    ...options.noindex ? { noindex: true } : {},
+    ...options.index ? { index: true } : {},
+    ...options.expiresAt ? { expiresAt: options.expiresAt } : {},
+    ...options.metadata ? { metadata: options.metadata } : {},
+    ...options.metadataFile ? { metadataFile: options.metadataFile } : {},
+    ...options.entry ? { entry: options.entry } : {},
+    ...options.contentType ? { contentType: options.contentType } : {},
+    ...options.path ? { path: options.path } : {},
+    ...options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {},
+    ...options.json !== void 0 ? { json: options.json } : {},
+    ...options.quiet !== void 0 ? { quiet: options.quiet } : {},
+    ...options.url !== void 0 ? { url: options.url } : {},
+    ...options.ifRevision !== void 0 ? { ifRevision: options.ifRevision } : {},
+    ...options.fromJson ? { fromJson: options.fromJson } : {},
+    ...options.dryRun ? { dryRun: options.dryRun } : {}
+  };
+}
+function parseInteger(value) {
+  return Number.parseInt(value, 10);
+}
+async function resolveCommandInput(input, stdin) {
+  if (input !== "-") return input;
+  const buf = await readStdinBytes(stdin ?? process.stdin);
+  return buf.toString("utf8");
+}
+async function resolvePublishInputs(inputs, stdin, stdinIsTTY) {
+  if (inputs.length === 0) {
+    if (stdinIsTTY) return void 0;
+    const buf = await readStdinBytes(stdin ?? process.stdin);
+    if (buf.length === 0) return void 0;
+    return buf.toString("utf8");
+  }
+  if (inputs.length === 1) {
+    if (inputs[0] === "-") {
+      const buf = await readStdinBytes(stdin ?? process.stdin);
+      return buf.toString("utf8");
+    }
+    return inputs[0];
+  }
+  const resolved = [];
+  for (const input of inputs) {
+    if (input === "-") {
+      const buf = await readStdinBytes(stdin ?? process.stdin);
+      const tmpPath = `/tmp/.dropthis-stdin-${Date.now()}`;
+      const { writeFile: writeFile2 } = await import("fs/promises");
+      await writeFile2(tmpPath, buf);
+      resolved.push(tmpPath);
+    } else {
+      resolved.push(input);
+    }
+  }
+  const { mkdtemp, copyFile, stat: fsStat } = await import("fs/promises");
+  const { join: join2, basename: pathBasename } = await import("path");
+  const { tmpdir } = await import("os");
+  const tmpDir = await mkdtemp(join2(tmpdir(), "dropthis-multi-"));
+  for (const filePath of resolved) {
+    const info = await fsStat(filePath);
+    if (info.isDirectory()) {
+      throw new Error(
+        `Cannot mix directories with multiple file arguments. Use a single folder instead: dropthis publish ${filePath}`
+      );
+    }
+    const destName = pathBasename(filePath);
+    await copyFile(filePath, join2(tmpDir, destName));
+  }
+  return tmpDir;
+}
+async function readStdinBytes(stdin) {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(
+      typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk)
+    );
+  }
+  return Buffer.concat(chunks);
+}
+
+// src/cli.ts
+buildProgram({ store: createCredentialStore() }).parseAsync(process.argv).catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map