@dropthis/cli 0.4.0 → 0.5.0

package/dist/cli.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,126 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/inline-auth.ts
+var inline_auth_exports = {};
+__export(inline_auth_exports, {
+  runInlineAuth: () => runInlineAuth
+});
+async function runInlineAuth(deps) {
+  try {
+    const prompt = deps.prompt ?? defaultPrompts();
+    deps.stderr("\nNot logged in. Let's fix that:\n");
+    const emailResult = await prompt.email();
+    if (typeof emailResult === "symbol") {
+      return null;
+    }
+    const email = emailResult;
+    const otpRequest = await deps.client.auth.requestEmailOtp({ email });
+    if (otpRequest.error) {
+      deps.stderr(`${otpRequest.error.message}
+`);
+      return null;
+    }
+    deps.stderr("Code sent! Check your inbox.\n");
+    const maxAttempts = 3;
+    let session = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const codeResult = await prompt.code(attempt, maxAttempts);
+      if (typeof codeResult === "symbol") {
+        return null;
+      }
+      const code = codeResult;
+      const verifyResult = await deps.client.auth.verifyEmailOtp({
+        email,
+        code
+      });
+      if (!verifyResult.error) {
+        session = verifyResult.data;
+        break;
+      }
+      if (attempt < maxAttempts) {
+        deps.stderr(`${verifyResult.error.message}
+`);
+      } else {
+        deps.stderr(
+          "Too many attempts. Run `dropthis login` to request a new code.\n"
+        );
+        return null;
+      }
+    }
+    if (!session) {
+      return null;
+    }
+    const authedClient = deps.createClient(session.token);
+    const apiKeyResult = await authedClient.apiKeys.create({
+      label: `CLI on ${deps.hostname ?? (0, import_node_os2.hostname)()}`
+    });
+    if (apiKeyResult.error) {
+      deps.stderr(`${apiKeyResult.error.message}
+`);
+      return null;
+    }
+    const { id: keyId, key: apiKey, keyLast4, accountId } = apiKeyResult.data;
+    try {
+      await deps.store.save({
+        apiKey,
+        keyId,
+        keyLast4,
+        accountId: accountId ?? session.accountId,
+        email,
+        storage: "secure"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      deps.stderr(`Failed to save credentials: ${message}
+`);
+      return null;
+    }
+    deps.stderr("\u2713 Logged in\n\n");
+    return {
+      apiKey,
+      source: "storage",
+      keyId,
+      keyLast4,
+      accountId: accountId ?? session.accountId,
+      email
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    deps.stderr(`Login failed: ${message}
+`);
+    return null;
+  }
+}
+function defaultPrompts() {
+  return {
+    email: () => readlineQuestion("Email: "),
+    code: (attempt) => readlineQuestion(
+      attempt === 1 ? "Code: " : "Try again \u2014 enter the code: "
+    )
+  };
+}
+function readlineQuestion(question) {
+  const rl = (0, import_node_readline.createInterface)({
+    input: process.stdin,
+    output: process.stderr
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+var import_node_os2, import_node_readline;
+var init_inline_auth = __esm({
+  "src/inline-auth.ts"() {
+    "use strict";
+    import_node_os2 = require("os");
+    import_node_readline = require("readline");
+  }
+});
+
 // src/program.ts
 var import_commander = require("commander");
 var import_picocolors4 = __toESM(require("picocolors"), 1);
@@ -400,6 +527,7 @@ var COMMAND_CATALOG = [
     arguments: ["input"],
     options: ["--json", "--url", "--dry-run", "--title", "--metadata"],
     examples: [
+      "dropthis ./file.html",
       "dropthis publish ./site --json",
       "dropthis publish ./site --url",
       "dropthis publish ./dist --dry-run"
@@ -561,13 +689,13 @@ async function runDoctor(_input, deps) {
   const authSource = credential?.source ?? "missing";
   const storageBackend = stored?.storage ?? "none";
   const pairs = [
-    ["Version", "0.4.0"],
+    ["Version", "0.5.0"],
     ["Auth", authSource],
     ["Storage", storageBackend]
   ];
   writeKv(deps, pairs, {
     ok: true,
-    version: "0.4.0",
+    version: "0.5.0",
     auth: { source: authSource },
     storage: { backend: storageBackend }
   });
@@ -997,8 +1125,9 @@ async function readJsonObjectFile(path) {
 
 // src/commands/publish.ts
 async function runPublish(input, raw, deps) {
+  let credential;
   try {
-    await requireCredential({
+    credential = await resolveCredential({
       ...raw.apiKey ?? deps.apiKey ? { apiKey: raw.apiKey ?? deps.apiKey } : {},
       env: deps.env,
       store: deps.store
@@ -1006,8 +1135,26 @@ async function runPublish(input, raw, deps) {
   } catch {
     return writeAuthError(deps);
   }
+  let didInlineAuth = false;
+  if (!credential) {
+    if (deps.interactive && deps.inlineAuth) {
+      try {
+        credential = await deps.inlineAuth();
+      } catch {
+        return writeAuthError(deps);
+      }
+      if (!credential) return writeAuthError(deps);
+      didInlineAuth = true;
+    } else {
+      return writeAuthError(deps);
+    }
+  }
+  let client = deps.client;
+  if (didInlineAuth && deps.createClient) {
+    client = deps.createClient(credential.apiKey);
+  }
   if (raw.dryRun) {
-    return handlePublishDryRun(input, raw, deps);
+    return handlePublishDryRun(input, raw, deps, client);
   }
   const singleInput = Array.isArray(input) ? input[0] : input;
   const spin = shouldSpin(deps.outputMode) ? createSpinner("Publishing\u2026", deps.stderr) : void 0;
@@ -1016,13 +1163,44 @@ async function runPublish(input, raw, deps) {
       throw new Error("Use either <input> or --from-json, not both.");
     }
     const options = withIdempotencyKey(await parseDropOptions(raw), "pub");
-    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) : (() => {
+    const jsonBody = raw.fromJson ? await (deps.readJsonObject ?? readJsonObjectFile)(raw.fromJson) : void 0;
+    const idempotencyOpt = options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : {};
+    const doPublish = (c) => jsonBody ? c.drops.createRaw(jsonBody, idempotencyOpt) : singleInput ? c.publish(singleInput, options) : (() => {
       throw new Error("Publish requires <input> or --from-json.");
     })();
+    const result = await doPublish(client);
     if (result.error) {
+      if (result.error.statusCode === 401 && deps.interactive && deps.inlineAuth && !didInlineAuth) {
+        spin?.stop();
+        const newCredential = await deps.inlineAuth();
+        if (newCredential && deps.createClient) {
+          client = deps.createClient(newCredential.apiKey);
+          const retrySpin = shouldSpin(deps.outputMode) ? createSpinner("Publishing\u2026", deps.stderr) : void 0;
+          try {
+            const retryResult = await doPublish(client);
+            if (retryResult.error) {
+              retrySpin?.fail();
+              return writeApiError(deps, retryResult.error);
+            }
+            retrySpin?.stop();
+            if (raw.url) deps.stdout(`${retryResult.data.url}
+`);
+            else
+              writeResult(
+                deps,
+                retryResult.data.url,
+                "Published",
+                retryResult.data
+              );
+            return { exitCode: 0 };
+          } catch (retryError) {
+            retrySpin?.fail();
+            const message = retryError instanceof Error ? retryError.message : "Publish failed.";
+            const code = isFileSystemError(retryError) ? "local_input_error" : "invalid_usage";
+            return writeError(deps, code, message);
+          }
+        }
+      }
       spin?.fail();
       return writeApiError(deps, result.error);
     }
@@ -1038,7 +1216,7 @@ async function runPublish(input, raw, deps) {
     return writeError(deps, code, message);
   }
 }
-async function handlePublishDryRun(input, raw, deps) {
+async function handlePublishDryRun(input, raw, deps, client) {
   if (raw.url) {
     return writeError(
       deps,
@@ -1067,10 +1245,10 @@ async function handlePublishDryRun(input, raw, deps) {
     if (Array.isArray(input)) {
       return dryRunMultiFile(input, options, deps);
     }
-    if (!deps.client.prepare) {
+    if (!client.prepare) {
       throw new Error("Client does not support dry-run.");
     }
-    const prepared = await deps.client.prepare(input, options);
+    const prepared = await client.prepare(input, options);
     const output = formatDryRunManifest(prepared);
     validateManifestFileCount(
       output.manifest.files.length
@@ -1126,6 +1304,9 @@ async function dryRunMultiFile(inputs, options, deps) {
 }
 
 // src/commands/update.ts
+var prompts4 = __toESM(require("@clack/prompts"), 1);
+var NO_UPDATE_MESSAGE = "Nothing to update. Provide an input path or at least one update option.";
+var NO_UPDATE_NEXT_ACTION = "Run dropthis drops update --help, or retry with an input path (for example, dropthis drops update <dropId> ./dist) or one of: --title, --slug, --visibility, --password, --no-password, --noindex, --index, --expires-at, or --metadata.";
 async function runUpdate(target, input, raw, deps) {
   try {
     await requireCredential({
@@ -1139,14 +1320,31 @@ async function runUpdate(target, input, raw, deps) {
   if (raw.dryRun) {
     return handleUpdateDryRun(target, input, raw, deps);
   }
-  const spin = shouldSpin(deps.outputMode) ? createSpinner("Updating\u2026", deps.stderr) : void 0;
+  let spin;
   try {
     assertDropId(target);
     if (raw.fromJson && input) {
       throw new Error("Use either [input] or --from-json, not both.");
     }
-    const parsed = await parseDropOptions(raw);
+    let updateInput = input;
+    let parsed = await parseDropOptions(raw);
+    if (!updateInput && !raw.fromJson && !hasUpdateFields(parsed)) {
+      if (shouldPromptForUpdate(deps)) {
+        const prompted = await promptForUpdate(target, deps.prompts ?? prompts4);
+        if (!prompted) return { exitCode: 0 };
+        updateInput = prompted.input;
+        parsed = { ...parsed, ...prompted.options };
+      } else {
+        return writeError(
+          deps,
+          "invalid_usage",
+          NO_UPDATE_MESSAGE,
+          NO_UPDATE_NEXT_ACTION
+        );
+      }
+    }
     const revisionOptions = raw.ifRevision !== void 0 ? { ifRevision: Number(raw.ifRevision) } : {};
+    spin = shouldSpin(deps.outputMode) ? createSpinner("Updating\u2026", deps.stderr) : void 0;
     const result = raw.fromJson ? await deps.client.deployments.createRaw(
       target,
       await (deps.readJsonObject ?? readJsonObjectFile)(raw.fromJson),
@@ -1157,9 +1355,9 @@ async function runUpdate(target, input, raw, deps) {
         },
         "upd"
       )
-    ) : input ? await deps.client.update(
+    ) : updateInput ? await deps.client.update(
       target,
-      input,
+      updateInput,
       withIdempotencyKey(
         {
           ...parsed,
@@ -1184,6 +1382,162 @@ async function runUpdate(target, input, raw, deps) {
     return writeError(deps, code, message);
   }
 }
+function hasUpdateFields(options) {
+  const { idempotencyKey: _, ...fields } = options;
+  return Object.keys(fields).length > 0;
+}
+function shouldPromptForUpdate(deps) {
+  return deps.outputMode === "human" && deps.interactive === true;
+}
+async function promptForUpdate(target, prompt) {
+  prompt.intro(`Update ${target}`);
+  const fields = await prompt.multiselect({
+    message: "What do you want to update?",
+    required: true,
+    options: [
+      {
+        value: "content",
+        label: "Content",
+        hint: "replace files, folder, URL, or text"
+      },
+      { value: "title", label: "Title", hint: "--title" },
+      { value: "slug", label: "Slug", hint: "--slug" },
+      { value: "visibility", label: "Visibility", hint: "--visibility" },
+      {
+        value: "password",
+        label: "Password",
+        hint: "--password or --no-password"
+      },
+      {
+        value: "indexing",
+        label: "Search indexing",
+        hint: "--noindex or --index"
+      },
+      { value: "expiresAt", label: "Expiration", hint: "--expires-at" },
+      { value: "metadata", label: "Metadata", hint: "--metadata" }
+    ]
+  });
+  if (prompt.isCancel(fields)) {
+    prompt.cancel("Update cancelled.");
+    return void 0;
+  }
+  const selected = new Set(fields);
+  const options = {};
+  let input;
+  if (selected.has("content")) {
+    const value = await prompt.text({
+      message: "Content path, URL, or text",
+      validate: requireNonEmpty("Enter content or a path.")
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    input = value.trim();
+  }
+  if (selected.has("title")) {
+    const value = await prompt.text({
+      message: "Title",
+      validate: requireNonEmpty("Enter a title.")
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.title = value.trim();
+  }
+  if (selected.has("slug")) {
+    const value = await prompt.text({
+      message: "Slug",
+      validate: requireNonEmpty("Enter a slug.")
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.slug = value.trim();
+  }
+  if (selected.has("visibility")) {
+    const value = await prompt.select({
+      message: "Visibility",
+      options: [
+        { value: "public", label: "Public" },
+        { value: "unlisted", label: "Unlisted" }
+      ]
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.visibility = value;
+  }
+  if (selected.has("password")) {
+    const action = await prompt.select({
+      message: "Password",
+      options: [
+        { value: "set", label: "Set password" },
+        { value: "remove", label: "Remove password" }
+      ]
+    });
+    if (prompt.isCancel(action)) return cancelUpdate(prompt);
+    if (action === "set") {
+      const value = await prompt.password({
+        message: "Password",
+        validate: requireNonEmpty("Enter a password.")
+      });
+      if (prompt.isCancel(value)) return cancelUpdate(prompt);
+      options.password = value;
+    } else {
+      options.password = null;
+    }
+  }
+  if (selected.has("indexing")) {
+    const value = await prompt.select({
+      message: "Search indexing",
+      options: [
+        { value: "noindex", label: "Prevent indexing" },
+        { value: "index", label: "Allow indexing" }
+      ]
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.noindex = value === "noindex";
+  }
+  if (selected.has("expiresAt")) {
+    const value = await prompt.text({
+      message: "Expiration date",
+      placeholder: "2025-12-31T23:59:59Z",
+      validate: validateIsoDate
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.expiresAt = value.trim();
+  }
+  if (selected.has("metadata")) {
+    const value = await prompt.text({
+      message: "Metadata JSON object",
+      placeholder: '{"source":"cli"}',
+      validate: validateJsonObject
+    });
+    if (prompt.isCancel(value)) return cancelUpdate(prompt);
+    options.metadata = parseJsonObject2(value);
+  }
+  return { ...input ? { input } : {}, options };
+}
+function cancelUpdate(prompt) {
+  prompt.cancel("Update cancelled.");
+  return void 0;
+}
+function requireNonEmpty(message) {
+  return (value) => value?.trim() ? void 0 : message;
+}
+function validateIsoDate(value) {
+  if (!value?.trim()) return "Enter an ISO 8601 date.";
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? "Enter a valid ISO 8601 date." : void 0;
+}
+function validateJsonObject(value) {
+  if (!value?.trim()) return "Enter a JSON object.";
+  try {
+    parseJsonObject2(value);
+    return void 0;
+  } catch {
+    return "Enter a valid JSON object.";
+  }
+}
+function parseJsonObject2(value) {
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Metadata must be a JSON object.");
+  }
+  return parsed;
+}
 async function handleUpdateDryRun(target, input, raw, deps) {
   if (raw.url) {
     return writeError(
@@ -1402,11 +1756,13 @@ async function readJsonFile(path) {
 }
 async function writeCredentialFile(path, credential) {
   await (0, import_promises4.mkdir)((0, import_node_path3.dirname)(path), { recursive: true });
-  await (0, import_promises4.writeFile)(path, `${JSON.stringify(credential, null, 2)}
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  await (0, import_promises4.writeFile)(tmpPath, `${JSON.stringify(credential, null, 2)}
 `, {
     mode: 384
   });
-  await (0, import_promises4.chmod)(path, 384);
+  await (0, import_promises4.chmod)(tmpPath, 384);
+  await (0, import_promises4.rename)(tmpPath, path);
 }
 
 // src/program.ts
@@ -1421,7 +1777,7 @@ function buildProgram(options = {}) {
       `  ${import_picocolors4.default.cyan("dropthis login")}`,
       `  ${import_picocolors4.default.cyan("dropthis publish ./dist")}`
     ].join("\n")
-  ).version("0.4.0").configureHelp({
+  ).version("0.5.0").configureHelp({
     subcommandTerm(cmd) {
       const args = cmd.registeredArguments.map((a) => {
         const name = a.name();
@@ -1439,7 +1795,8 @@ function buildProgram(options = {}) {
   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("publish [input...]").description(
+  program.option("--no-interactive", "Disable interactive prompts");
+  program.command("publish [input...]", { isDefault: true }).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("--title <title>", "Drop title").option("--visibility <v>", "public or unlisted (default: public)").option("--password <password>", "Require password to view").option("--noindex", "Prevent search-engine indexing").option("--expires-at <datetime>", "Auto-delete after this ISO 8601 date").option(
     "--content-type <mime>",
@@ -1454,8 +1811,18 @@ function buildProgram(options = {}) {
     "--idempotency-key <key>",
     "Prevent duplicate publishes on retry (auto-generated)"
   ).action(async (inputs, commandOptions) => {
-    const deps = await commandDeps(program, options, store, commandOptions);
     const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY ?? false;
+    if (inputs.length === 0 && stdinIsTTY && !commandOptions.fromJson) {
+      program.outputHelp();
+      return;
+    }
+    const { deps } = await buildPublishDeps(
+      program,
+      options,
+      store,
+      commandOptions,
+      stdinIsTTY
+    );
     let publishInput;
     try {
       if (commandOptions.dryRun && inputs.length > 1) {
@@ -1517,6 +1884,8 @@ function buildProgram(options = {}) {
     "Prevent duplicate updates on retry (auto-generated)"
   ).action(
     async (dropId, input, commandOptions) => {
+      const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY ?? false;
+      const global = globalOptions(program, commandOptions);
       const deps = await commandDeps(program, options, store, commandOptions);
       let updateInput;
       try {
@@ -1538,16 +1907,24 @@ function buildProgram(options = {}) {
         process.exitCode = writeError(deps, "invalid_usage", msg).exitCode;
         return;
       }
-      const result = await runUpdate(dropId, updateInput, dropOpts, deps);
+      const result = await runUpdate(dropId, updateInput, dropOpts, {
+        ...deps,
+        interactive: isInteractive(stdinIsTTY, deps.env, global)
+      });
       process.exitCode = result.exitCode;
     }
   );
   drops.command("delete <dropId>").description("Delete a drop").option("--yes", "Confirm deletion").option("--json", "Force JSON output").action(
     async (dropId, commandOptions) => {
+      const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY ?? false;
+      const global = globalOptions(program, commandOptions);
       const deps = await commandDeps(program, options, store, commandOptions);
       const result = await runDropsDelete(
         dropId,
-        { ...commandOptions, interactive: deps.outputMode === "human" },
+        {
+          ...commandOptions,
+          interactive: isInteractive(stdinIsTTY, deps.env, global)
+        },
         deps
       );
       process.exitCode = result.exitCode;
@@ -1566,10 +1943,15 @@ function buildProgram(options = {}) {
   });
   apiKeys.command("delete <keyId>").description("Delete an API key").option("--yes", "Confirm deletion").option("--json", "Force JSON output").action(
     async (keyId, commandOptions) => {
+      const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY ?? false;
+      const global = globalOptions(program, commandOptions);
       const deps = await commandDeps(program, options, store, commandOptions);
       const result = await runApiKeysDelete(
         keyId,
-        { ...commandOptions, interactive: deps.outputMode === "human" },
+        {
+          ...commandOptions,
+          interactive: isInteractive(stdinIsTTY, deps.env, global)
+        },
         deps
       );
       process.exitCode = result.exitCode;
@@ -1714,13 +2096,56 @@ async function commandDeps(program, options, store, commandOptions) {
     outputMode: context.output.mode
   };
 }
+async function buildPublishDeps(program, options, store, commandOptions, stdinIsTTY) {
+  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
+  });
+  const interactive = isInteractive(stdinIsTTY, context.env, global);
+  const inlineAuth = async () => {
+    const { runInlineAuth: runInlineAuth2 } = await Promise.resolve().then(() => (init_inline_auth(), inline_auth_exports));
+    return runInlineAuth2({
+      client: context.createClient(),
+      createClient: (apiKey) => context.createClient(apiKey),
+      store,
+      stderr: context.stderr
+    });
+  };
+  return {
+    deps: {
+      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,
+      interactive,
+      inlineAuth,
+      createClient: (apiKey) => context.createClient(apiKey)
+    }
+  };
+}
+function isInteractive(stdinIsTTY, env, global) {
+  return stdinIsTTY && !env.CI && !env.DROPTHIS_NON_INTERACTIVE && global.interactive !== false;
+}
 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 } : {}
+    ...commandOptions.quiet !== void 0 ? { quiet: commandOptions.quiet } : opts.quiet !== void 0 ? { quiet: opts.quiet } : {},
+    ...opts.interactive !== void 0 ? { interactive: opts.interactive } : {}
   };
 }
 function toDropOptions(options) {