@hushscript/cli 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hushscript
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,200 @@
-# Temporary Holding Version
+# Hushscript CLI
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official command line client for [Hushscript](https://hushscript.com), a privacy-first,
+pay-as-you-go transcription service. It is built on the official TypeScript SDK, `@hushscript/sdk`,
+and needs Node 22 or newer.
+
+## Why Hushscript
+
+- **No subscription.** You buy prepaid minute packs, and nothing recurs. Current prices are on the
+  [pricing page](https://hushscript.com/pricing).
+- **The audio you send isn't kept.** The audio sent for transcription isn't kept after processing. Stored
+  transcripts are encrypted at rest, and you choose how long they stay.
+- **Free speaker labels and AI insights.** Speaker labels carry no extra charge (translation costs
+  more). The first all-in AI insights run on a transcript (summaries, action items, quotes, chapters)
+  is free in the Hushscript app.
+- **Around 99 languages.** Pick one with `--language` or let Hushscript detect it, and translate
+  the result.
+- **A tool you can read.** It is MIT licensed, official, and keeps your token in a file only you can
+  read (mode `0600`).
+
+## What you can do with it
+
+- Transcribe a recording from the terminal and print the transcript as `txt`, `srt`, `vtt` or
+  `json`, to stdout or to a file.
+- Translate in the same run (`--translate es,de`) and print a translation or the AI-cleaned
+  body of any finished transcript.
+- Pick up an interrupted run with `resume`, using the token the CLI prints, without paying twice.
+- Check your balance, list transcripts and jobs, and see which minute packs you can buy.
+- Buy a pack with your saved card, with the no-refund notice shown and a confirmation first.
+- Script it: `--json` output, JSON Lines errors on stderr and fixed exit codes.
+
+[Website](https://hushscript.com) · [Pricing](https://hushscript.com/pricing) · [SDK docs](https://hushscript.com/sdks) · [API reference](https://hushscript.com/developers)
+
+## Quick start
+
+```sh
+npm install --global @hushscript/cli
+hushscript login
+hushscript transcribe meeting.mp3 --format srt --out meeting.srt
+```
+
+## Token
+
+Create a token in the Hushscript app under Account, Connected apps. The CLI looks for it in this
+order:
+
+1. `--token <token>`
+2. the `HUSHSCRIPT_TOKEN` environment variable
+3. the token stored by `hushscript login`
+
+`hushscript login` asks for the token without echoing it (or reads one line from stdin when it is
+piped) and keeps it in `$XDG_CONFIG_HOME/hushscript/config.json`, which is `~/.config/hushscript/config.json`
+when `XDG_CONFIG_HOME` is not set and `%APPDATA%\hushscript\config.json` on Windows. The file is
+created with mode `0600` in a `0700` folder. `hushscript logout` deletes it. Prefer the environment
+variable in CI: a token on the command line is visible to other processes on the machine, and
+`login --token` prints a warning for that reason; run plain `login` to type the token or pipe it on
+stdin.
+
+- If the stored file is readable by group or others, every command that reads it warns on stderr and
+  suggests `chmod 600`; the token is still used.
+- If the config folder is a symbolic link, `login` refuses with exit code 1 instead of changing the
+  mode of whatever the link points at. Replace the link with a real folder, or point
+  `XDG_CONFIG_HOME` at one.
+- A source that is empty or only whitespace counts as not set: `--token ""`, an empty
+  `HUSHSCRIPT_TOKEN`, an empty `token` in the stored file, and likewise `HUSHSCRIPT_BASE_URL`,
+  `XDG_CONFIG_HOME` and `APPDATA`. The CLI moves on to the next source; with none left it reports
+  "No Hushscript token." (exit code 1). `login --token ""` prompts as if the flag was absent, and
+  `logout` ignores `--token`.
+
+## Commands
+
+| Command                 | What it does                                                                                                                                            |
+| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `login`                 | Prompts for a token and stores it.                                                                                                                      |
+| `logout`                | Deletes the stored token.                                                                                                                               |
+| `balance`               | Shows the minutes you can spend.                                                                                                                        |
+| `transcribe <file>`     | Uploads a recording, waits, and prints the transcript. Flags: `--language`, `--translate es,de`, `--format srt\|vtt\|txt\|json`, `--out path`, `--key`. |
+| `resume <token> <file>` | Finishes a transcription that `transcribe` left behind (see Interrupting). Flags: `--format`, `--out`.                                                  |
+| `transcripts`           | Lists finished transcripts, newest first. Flag: `--limit` (default 20).                                                                                 |
+| `transcript <id>`       | Prints one transcript. Flags: `--format`, `--lang` (a translation, or `cleaned`).                                                                       |
+| `jobs`                  | Lists jobs. Flag: `--active` for the ones that have not finished.                                                                                       |
+| `packs`                 | Lists the minute packs you can buy, with prices.                                                                                                        |
+| `buy <pack>`            | Buys a pack with your saved default card. Flags: `--yes`, `--key`.                                                                                      |
+
+Global flags: `--json` and `--token`. The default format is `txt`. `--out` writes through a temporary
+file and a rename, so the target is never half written. The temporary file is created with the mode
+the target will have (an existing target keeps its mode, a new file gets `0644` minus the umask). A
+symbolic link is followed, also a dangling one, and written through to the file it points at; before
+anything is sent, `--out` is checked at the place the link leads to, so a link into a folder that
+does not exist is a usage error (exit code 2) and no job is created.
+
+### Buying minutes
+
+`buy` shows the no-refund notice on stderr and asks you to confirm; a missing token is reported
+before it asks. With `--yes` the notice is still printed, before the purchase, also under `--json`.
+Without a terminal (stdin and stderr both) and without `--yes` it exits with code 2 and sends nothing:
+
+```sh
+hushscript buy 300min --yes
+```
+
+A stop signal (SIGINT, SIGTERM or SIGHUP) while `buy` waits for your answer prints nothing and exits
+with 130: the no-refund notice and the question are already on stderr, nothing was sent and nothing
+was charged.
+
+Every purchase has an idempotency key: the one from `--key`, or a fresh one the CLI makes. If a
+purchase fails after it was sent, or the CLI is stopped by SIGINT, SIGTERM or SIGHUP once the
+purchase is confirmed (or with `--yes`; exit code 130, also while the card is still being looked up),
+it prints the key and says "The purchase may have been sent. Retry with --key <key>: the same key never
+charges twice." A failure before any request was sent leaves the notice out, and so does a refusal that
+proves nothing was charged (a 400, 402, 404 or 422 answer, or a 403 with numeric code 4021 or 4023); a 401 or 429 does not prove it, because the
+server answers those before it replays a purchase that already went through. Retry with the same key and
+it cannot be charged twice:
+
+```sh
+hushscript buy 300min --yes --key <key>
+```
+
+### Interrupting
+
+Ctrl-C (SIGINT), SIGTERM or SIGHUP during `transcribe` or `resume` stops the call, prints the resume
+token of the job and exits with 130. A second signal exits at once, still printing the token (and the
+idempotency key `transcribe` started with). A stop signal at any other moment, when nothing was sent
+that a token could be about, ends the CLI with 130 and prints nothing. The message names the command
+that continues the job:
+
+```sh
+hushscript resume <token> meeting.mp3 --format srt --out meeting.srt
+```
+
+When the run stopped before the API handed out a token, the message carries the idempotency key
+instead and names the command that replays the same `transcribe` call, with the `--language`, `--translate`,
+`--format` and `--out` you passed, so the replay asks for the same job; the same key never creates the
+job twice:
+
+```sh
+hushscript transcribe --key <key> meeting.mp3 --language en --format srt --out meeting.srt
+```
+
+The resume command carries the `--format` and `--out` you passed (the flags you did not pass are left
+out). `resume` takes the same recording and the same `--format`, `--out` and `--json` as `transcribe`; if
+the job has finished meanwhile it just fetches the transcript.
+
+## Scripting
+
+`--json` prints one JSON document on stdout and nothing else. `--help --json` prints `{"help": "..."}`
+and `--version --json` prints `{"version": "..."}`.
+
+Error and notice text on stderr is scrubbed of every token the CLI knows, as given and trimmed, whatever
+its length or shape. Results on stdout are not scrubbed: they are your output, and a result that holds a
+token (a newly issued one, for example) prints it.
+
+Under `--json` stderr is JSON Lines: every line is one JSON object with a `type`. Notices and warnings
+come first, as they happen, and the error object, if the command failed, comes last:
+
+```json
+{"type":"notice","code":"no_refund","message":"..."}
+{"type":"warning","code":"token_file_shared","message":"..."}
+{
+  "type": "error",
+  "code": "insufficient_balance",
+  "numericCode": 4020,
+  "status": 402,
+  "message": "...",
+  "hint": "...",
+  "idempotencyKey": "...",
+  "resumeToken": "..."
+}
+```
+
+(The error object is one line on stderr; it is wrapped here to read.) `idempotencyKey` and `resumeToken`
+appear only when the error has one. The notice codes are `no_refund` (the `buy` notice) and the warning
+codes are `token_file_shared` (a stored token file other users can read) and `token_on_command_line`
+(`login --token`). Progress bars are drawn on stderr only when it is a terminal and `--json` is off.
+The one text that can still reach stderr under `--json` is a prompt (`login` asking for the token,
+`buy` asking to confirm): prompts are only shown when both stdin and stderr are terminals; otherwise pass the flags (`--yes`, `--token`) or pipe the token.
+
+| Exit code | Meaning                                                                                                            |
+| --------- | ------------------------------------------------------------------------------------------------------------------ |
+| 0         | Success.                                                                                                           |
+| 1         | The API or the SDK reported an error (also a missing token, or a declined purchase).                               |
+| 2         | Usage error: unknown command or flag, a bad value, `buy` without a terminal and without `--yes`. Nothing was sent. |
+| 130       | Interrupted by SIGINT, SIGTERM or SIGHUP, at any moment of the run.                                                |
+
+## Links
+
+- Documentation: <https://hushscript.com/sdks>
+- REST API reference: <https://hushscript.com/developers>
+- Package on npm: <https://www.npmjs.com/package/@hushscript/cli>
+- Source: <https://github.com/Hushscript/hushscript-cli>
+- Other Hushscript SDKs: [TypeScript](https://github.com/Hushscript/hushscript-sdk-typescript), [Python](https://github.com/Hushscript/hushscript-sdk-python), [Go](https://github.com/Hushscript/hushscript-sdk-go), [PHP](https://github.com/Hushscript/hushscript-sdk-php)
+
+## Development
+
+Everything runs in containers, through `just`: `just ci` runs the static checks, the tests and the
+end-to-end run of the built binary against the conformance mock, on Node 22, 24, and 26.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,1028 @@
+#!/usr/bin/env node
+import { homedir } from 'os';
+import { HushscriptError, Hushscript } from '@hushscript/sdk';
+import { createInterface } from 'readline';
+import { Command, CommanderError, Option } from 'commander';
+import { randomUUID, randomBytes } from 'crypto';
+import { lstat, mkdir, chmod, open, rename, unlink, stat, readlink, readFile } from 'fs/promises';
+import { dirname, join, resolve, basename } from 'path';
+
+// src/errors.ts
+var CliError = class extends Error {
+  code;
+  exitCode;
+  numericCode;
+  status;
+  hint;
+  idempotencyKey;
+  resumeToken;
+  constructor(init) {
+    super(init.message);
+    this.name = "CliError";
+    this.code = init.code;
+    this.exitCode = init.exitCode;
+    this.numericCode = init.numericCode ?? null;
+    this.status = init.status ?? null;
+    this.hint = init.hint ?? null;
+    this.idempotencyKey = init.idempotencyKey ?? null;
+    this.resumeToken = init.resumeToken ?? null;
+  }
+};
+function usageError(message, hint) {
+  return new CliError({ code: "usage_error", message, exitCode: 2, hint });
+}
+function interrupted(resumeToken, idempotencyKey = null, hint = null) {
+  return new CliError({
+    code: "interrupted",
+    message: "Interrupted.",
+    exitCode: 130,
+    resumeToken,
+    idempotencyKey,
+    hint
+  });
+}
+
+// src/prompt.ts
+var CTRL_C = "";
+var CTRL_D = "";
+var BACKSPACE = /* @__PURE__ */ new Set(["\x7F", "\b"]);
+async function readAll(input) {
+  let text = "";
+  input.setEncoding("utf8");
+  for await (const chunk of input) text += String(chunk);
+  return text;
+}
+async function readSecret(input, output, prompt) {
+  if (input.isTTY !== true || input.setRawMode === void 0) {
+    const text = await readAll(input);
+    return text.split(/\r?\n/, 1)[0] ?? "";
+  }
+  const setRawMode = input.setRawMode.bind(input);
+  output.write(prompt);
+  input.setEncoding("utf8");
+  setRawMode(true);
+  input.resume();
+  return await new Promise((resolve2, reject) => {
+    let typed = "";
+    const finish = (settle) => {
+      input.off("data", onData);
+      input.off("end", onEnd);
+      input.off("close", onEnd);
+      input.off("error", onError);
+      try {
+        setRawMode(false);
+      } catch {
+      }
+      input.pause();
+      output.write("\n");
+      settle();
+    };
+    const onEnd = () => {
+      finish(() => {
+        resolve2(typed);
+      });
+    };
+    const onError = (error) => {
+      finish(() => {
+        reject(
+          new CliError({
+            code: "input_failed",
+            message: `Reading from the terminal failed (${error.message}).`,
+            exitCode: 1
+          })
+        );
+      });
+    };
+    const onData = (chunk) => {
+      for (const char of String(chunk)) {
+        if (char === "\r" || char === "\n" || char === CTRL_D) {
+          finish(() => {
+            resolve2(typed);
+          });
+          return;
+        }
+        if (char === CTRL_C) {
+          finish(() => {
+            reject(interrupted(null));
+          });
+          return;
+        }
+        if (BACKSPACE.has(char)) typed = typed.slice(0, -1);
+        else if (char >= " ") typed += char;
+      }
+    };
+    input.on("data", onData);
+    input.once("end", onEnd);
+    input.once("close", onEnd);
+    input.once("error", onError);
+  });
+}
+async function confirm(input, output, prompt) {
+  if (input.destroyed || input.readableEnded) return false;
+  const lines = createInterface({ input, output, terminal: false });
+  return await new Promise((resolve2) => {
+    let answer = false;
+    const onInputClose = () => {
+      lines.close();
+    };
+    lines.once("close", () => {
+      input.off("close", onInputClose);
+      resolve2(answer);
+    });
+    input.once("close", onInputClose);
+    lines.once("error", onInputClose);
+    output.write(prompt);
+    lines.once("line", (line) => {
+      answer = /^\s*y(?:es)?\s*$/i.test(line);
+      lines.close();
+    });
+  });
+}
+
+// package.json
+var package_default = {
+  version: "1.0.1"};
+
+// src/shell.ts
+var SAFE = /^[\w@%+=:,./-]+$/;
+function shellWord(text) {
+  return SAFE.test(text) ? text : `'${text.replaceAll("'", `'\\''`)}'`;
+}
+
+// src/store.ts
+function configPath({ env, platform, homedir: homedir2 }) {
+  if (platform === "win32") {
+    const base2 = valueOf(env["APPDATA"]) ?? join(homedir2, "AppData", "Roaming");
+    return join(base2, "hushscript", "config.json");
+  }
+  const base = valueOf(env["XDG_CONFIG_HOME"]) ?? join(homedir2, ".config");
+  return join(base, "hushscript", "config.json");
+}
+function valueOf(value) {
+  return value === void 0 || value === null || value.trim() === "" ? void 0 : value;
+}
+function isMissing(error) {
+  return error.code === "ENOENT";
+}
+function storeError(path, problem) {
+  return new CliError({
+    code: "config_invalid",
+    message: `The config file at ${path} ${problem}.`,
+    exitCode: 1,
+    hint: "Run `hushscript login` to write it again, or delete the file."
+  });
+}
+async function warnIfShared(path, { platform, warn }) {
+  if (platform === "win32") return;
+  const info = await stat(path).catch(() => null);
+  if (info === null || (info.mode & 63) === 0) return;
+  const mode = (info.mode & 511).toString(8).padStart(4, "0");
+  warn(`${path} can be read by other users (mode ${mode}). Run: chmod 600 ${shellWord(path)}`);
+}
+async function readStoredToken(path, options) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if (isMissing(error)) return null;
+    throw storeError(path, "could not be read");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw storeError(path, "is not valid JSON");
+  }
+  const token = parsed?.token;
+  if (typeof token !== "string") throw storeError(path, "holds no token");
+  if (valueOf(token) === void 0) return null;
+  if (options !== void 0) await warnIfShared(path, options);
+  return token;
+}
+async function saveToken(path, token, platform) {
+  const dir = dirname(path);
+  if ((await lstat(dir).catch(() => null))?.isSymbolicLink() === true) {
+    throw new CliError({
+      code: "config_invalid",
+      message: `The config folder ${dir} is a symbolic link, so the token was not stored.`,
+      exitCode: 1,
+      hint: "Replace the link with a real folder, or point XDG_CONFIG_HOME at one."
+    });
+  }
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const posix = platform !== "win32";
+  if (posix) await chmod(dir, 448);
+  const temp = join(dir, `.config.${String(process.pid)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    const handle = await open(temp, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify({ token })}
+`);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    if (posix) await chmod(temp, 384);
+    await rename(temp, path);
+  } catch (error) {
+    await unlink(temp).catch(() => void 0);
+    throw error;
+  }
+}
+async function removeToken(path) {
+  try {
+    await unlink(path);
+    return true;
+  } catch (error) {
+    if (isMissing(error)) return false;
+    throw error;
+  }
+}
+async function resolveToken(sources) {
+  const fromFlag = valueOf(sources.flag);
+  if (fromFlag !== void 0) return fromFlag;
+  const fromEnv = valueOf(sources.env["HUSHSCRIPT_TOKEN"]);
+  if (fromEnv !== void 0) return fromEnv;
+  return await sources.stored();
+}
+
+// src/context.ts
+function registerSecret(secrets, token) {
+  if (token.trim() === "") return;
+  for (const form of [token, token.trim()]) {
+    if (!secrets.includes(form)) secrets.push(form);
+  }
+}
+function storePath(deps2) {
+  return configPath(deps2);
+}
+async function openClient(rt) {
+  const { deps: deps2 } = rt;
+  const token = await resolveToken({
+    flag: rt.globals().token,
+    env: deps2.env,
+    stored: () => readStoredToken(storePath(deps2), {
+      platform: deps2.platform,
+      warn: (text) => {
+        rt.out.warning("token_file_shared", text);
+      }
+    })
+  });
+  if (token === null) {
+    throw new CliError({
+      code: "config_invalid",
+      message: "No Hushscript token.",
+      exitCode: 1,
+      hint: "Run `hushscript login`, set HUSHSCRIPT_TOKEN, or pass --token. Create a token in the Hushscript app under Account, Connected apps."
+    });
+  }
+  registerSecret(rt.secrets, token);
+  return deps2.createClient({ token, baseUrl: valueOf(deps2.env["HUSHSCRIPT_BASE_URL"]) });
+}
+var TOKEN_SHAPE = /\bhsr\w*:[\w:.-]+/g;
+function scrub(text, secrets) {
+  let out = text;
+  for (const secret of secrets) {
+    if (secret.trim() !== "") out = out.replaceAll(secret, "[redacted]");
+  }
+  return out.replace(TOKEN_SHAPE, "[redacted]");
+}
+function describeError(error, secrets) {
+  const clean = (text) => scrub(text, secrets);
+  const cleanOrNull = (text) => text === null ? null : clean(text);
+  const base = (source) => {
+    const report = {
+      code: source.code,
+      numericCode: source.numericCode,
+      status: source.status,
+      message: clean(source.message),
+      hint: cleanOrNull(source.hint)
+    };
+    if (source.idempotencyKey !== null) report.idempotencyKey = source.idempotencyKey;
+    if (source.resumeToken !== null) report.resumeToken = source.resumeToken;
+    return report;
+  };
+  if (error instanceof CliError || error instanceof HushscriptError) return base(error);
+  const message = error instanceof Error ? error.message : "";
+  return base({
+    code: "unexpected_error",
+    numericCode: null,
+    status: null,
+    message: message === "" ? "The CLI failed unexpectedly." : `Unexpected error: ${message}`,
+    hint: null,
+    idempotencyKey: null,
+    resumeToken: null
+  });
+}
+function exitCodeOf(error) {
+  return error instanceof CliError ? error.exitCode : 1;
+}
+function endWithNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+var Output = class {
+  json;
+  #io;
+  #secrets;
+  constructor(io2, json, secrets) {
+    this.#io = io2;
+    this.json = json;
+    this.#secrets = secrets;
+  }
+  /** The command's result: `value` as JSON under --json, else `human`. */
+  document(value, human) {
+    this.#io.stdout(this.json ? `${JSON.stringify(value, null, 2)}
+` : endWithNewline(human));
+  }
+  /** Content that is already formatted (a transcript): written byte for byte, plus a final newline on a terminal so the prompt starts on its own line. */
+  content(text) {
+    this.#io.stdout(this.#io.stdoutIsTTY ? endWithNewline(text) : text);
+  }
+  /** Something worth knowing before the command goes on: a line of text, or under --json a `notice` object. */
+  notice(code2, message) {
+    this.#line("notice", code2, message, message);
+  }
+  /** A problem that does not stop the command: `Warning: ...`, or under --json a `warning` object. */
+  warning(code2, message) {
+    this.#line("warning", code2, message, `Warning: ${message}`);
+  }
+  #line(type, code2, message, human) {
+    const clean = scrub(message, this.#secrets);
+    if (this.json) this.#io.stderr(`${JSON.stringify({ type, code: code2, message: clean })}
+`);
+    else this.#io.stderr(endWithNewline(scrub(human, this.#secrets)));
+  }
+  /** A line for a person on stderr; silent under --json. */
+  note(message) {
+    if (!this.json) this.#io.stderr(endWithNewline(message));
+  }
+  /** Prints the error and returns the exit code. */
+  fail(error) {
+    const report = describeError(error, this.#secrets);
+    if (this.json) {
+      this.#io.stderr(`${JSON.stringify({ type: "error", ...report })}
+`);
+    } else {
+      const lines = [`Error: ${report.message}`];
+      if (report.hint !== null) lines.push(`Hint: ${report.hint}`);
+      if (report.idempotencyKey !== void 0)
+        lines.push(`Idempotency key: ${report.idempotencyKey}`);
+      if (report.resumeToken !== void 0) lines.push(`Resume token: ${report.resumeToken}`);
+      this.#io.stderr(`${lines.join("\n")}
+`);
+    }
+    return exitCodeOf(error);
+  }
+};
+function renderTranscript(transcript, format, language) {
+  switch (format) {
+    case "srt":
+      return transcript.toSRT({ language });
+    case "vtt":
+      return transcript.toVTT({ language });
+    case "txt":
+      return transcript.toText({ language });
+    case "json":
+      return `${JSON.stringify(transcript.toJSON(), null, 2)}
+`;
+  }
+}
+function formatDuration(seconds) {
+  const whole = Math.max(0, Math.round(seconds));
+  const hours = Math.floor(whole / 3600);
+  const minutes = Math.floor(whole % 3600 / 60);
+  const rest = whole % 60;
+  const pad = (value) => String(value).padStart(2, "0");
+  return hours > 0 ? `${String(hours)}:${pad(minutes)}:${pad(rest)}` : `${String(minutes)}:${pad(rest)}`;
+}
+function formatDate(date) {
+  return date.toISOString();
+}
+
+// src/commands/balance.ts
+function registerBalance(program, rt) {
+  program.command("balance").description("Show the minutes you can spend").action(async () => {
+    const api = await openClient(rt);
+    const balance = await api.balance();
+    const lines = [`Balance: ${String(balance.minutes)} min (${String(balance.seconds)} s)`];
+    if (balance.heldSeconds > 0) {
+      lines.push(`Held for running jobs: ${String(Math.trunc(balance.heldSeconds / 60))} min`);
+    }
+    if (balance.expiresAt !== null) lines.push(`Expires: ${formatDate(balance.expiresAt)}`);
+    rt.out.document(balance, lines.join("\n"));
+  });
+}
+
+// src/validate.ts
+var FORMATS = ["srt", "vtt", "txt", "json"];
+var LOCALE = /^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$/i;
+var LANG_FLAG = /^[a-z][\w-]{0,31}$/i;
+var ID = /^[\w.-]{1,128}$/;
+var PACK = /^\d{1,6}min$/;
+var KEY = /^[\w-]{1,128}$/;
+var LIMIT = /^[1-9]\d{0,5}$/;
+function parseLanguage(value) {
+  if (!LOCALE.test(value)) {
+    throw usageError(`--language must be a language code such as en or pt-BR, not "${value}".`);
+  }
+  return value;
+}
+function parseTranslate(value) {
+  const codes = value.split(",").map((code2) => code2.trim());
+  for (const code2 of codes) {
+    if (!LOCALE.test(code2)) {
+      throw usageError(
+        `--translate takes language codes separated by commas, such as es,de; "${code2}" is not one.`
+      );
+    }
+  }
+  return [...new Set(codes)];
+}
+function parseLang(value) {
+  if (!LANG_FLAG.test(value)) {
+    throw usageError(`--lang must be a translation language code or "cleaned", not "${value}".`);
+  }
+  return value;
+}
+function parseLimit(value) {
+  if (!LIMIT.test(value)) throw usageError("--limit must be a whole number from 1 to 999999.");
+  return Number(value);
+}
+function parseId(value, name) {
+  if (!ID.test(value) || value === "." || value === "..") {
+    throw usageError(`${name} must be 1 to 128 letters, digits, dots, dashes or underscores.`);
+  }
+  return value;
+}
+function parsePack(value) {
+  if (!PACK.test(value)) {
+    throw usageError(`The pack must look like 300min; run \`hushscript packs\` to list them.`);
+  }
+  return value;
+}
+function parseKey(value) {
+  if (!KEY.test(value)) {
+    throw usageError("--key must be 1 to 128 characters from A-Z, a-z, 0-9, _ and -.");
+  }
+  return value;
+}
+function resolveFormat(json, format) {
+  if (!json) return format ?? "txt";
+  if (format !== void 0 && format !== "json") {
+    throw usageError("--json prints the transcript as JSON; drop --format or use --format json.");
+  }
+  return "json";
+}
+
+// src/commands/buy.ts
+var NO_REFUND_NOTICE = "Minutes are added to your account instantly after payment. All purchases are final and non-refundable.";
+var NEVER_CHARGED = /* @__PURE__ */ new Set([400, 402, 404, 422]);
+function chargeNotice(key) {
+  return `The purchase may have been sent. Retry with --key ${key}: the same key never charges twice.`;
+}
+function withChargeNotice(error) {
+  if (!(error instanceof HushscriptError)) return error;
+  const key = error.idempotencyKey;
+  const neverCharged = error.status !== null && NEVER_CHARGED.has(error.status) || error.status === 403 && (error.numericCode === 4021 || error.numericCode === 4023);
+  if (key === null || neverCharged) return error;
+  const notice = chargeNotice(key);
+  return new CliError({
+    code: error.code,
+    numericCode: error.numericCode,
+    status: error.status,
+    message: error.message,
+    hint: error.hint === null ? notice : `${error.hint} ${notice}`,
+    exitCode: 1,
+    idempotencyKey: key
+  });
+}
+function registerBuy(program, rt) {
+  program.command("buy").description("Buy a minute pack with your saved default card").argument("<pack>", "pack id, for example 300min (see `hushscript packs`)").option("--yes", "confirm the purchase without asking").option(
+    "--key <key>",
+    "idempotency key; pass the one a failed purchase printed to retry it safely"
+  ).action(async (packArgument, options) => {
+    const { deps: deps2, out } = rt;
+    const { io: io2 } = deps2;
+    const pack = parsePack(packArgument);
+    const key = options.key === void 0 ? randomUUID() : parseKey(options.key);
+    const confirmed = options.yes === true;
+    if (!confirmed && !(io2.stdinIsTTY && io2.stderrIsTTY)) {
+      if (!out.json) out.notice("no_refund", NO_REFUND_NOTICE);
+      throw usageError(
+        "Buying needs your confirmation, and there is no terminal to ask on. Nothing was sent.",
+        "Pass --yes to confirm the purchase."
+      );
+    }
+    const api = await openClient(rt);
+    out.notice("no_refund", NO_REFUND_NOTICE);
+    if (!confirmed && !await io2.confirm(`Buy ${pack} with your saved default card? [y/N] `)) {
+      throw new CliError({
+        code: "cancelled",
+        message: "Cancelled. Nothing was charged.",
+        exitCode: 1
+      });
+    }
+    const stop = io2.onInterrupt(() => {
+      io2.forceExit(out.fail(interrupted(null, key, chargeNotice(key))));
+    });
+    let purchase;
+    try {
+      purchase = await api.buy(pack, { acknowledgeNoRefund: true, idempotencyKey: key });
+    } catch (error) {
+      throw withChargeNotice(error);
+    } finally {
+      stop();
+    }
+    out.document(purchase, `Bought ${pack}. Balance: ${String(purchase.minutes)} min.`);
+  });
+}
+
+// src/commands/jobs.ts
+function registerJobs(program, rt) {
+  program.command("jobs").description("List jobs, newest first").option("--active", "only jobs that have not finished").action(async (options) => {
+    const api = await openClient(rt);
+    const jobs = [];
+    for await (const job of api.jobs.list({ active: options.active === true })) jobs.push(job);
+    const lines = jobs.map((job) => {
+      const detail = job.error === null ? "" : `  ${job.error}`;
+      return `${job.id}  ${job.state}  ${formatDate(job.createdAt)}  ${job.transcriptId ?? "-"}${detail}`;
+    });
+    rt.out.document({ jobs }, lines.length === 0 ? "No jobs." : lines.join("\n"));
+  });
+}
+function registerLogin(program, rt) {
+  program.command("login").description("Store a token for later commands (prompts without echo; reads stdin when piped)").action(async () => {
+    const { deps: deps2, out } = rt;
+    const supplied = rt.globals().token;
+    if (supplied === void 0 && deps2.io.stdinIsTTY && !deps2.io.stderrIsTTY) {
+      throw usageError(
+        "There is no terminal to ask for the token on. Nothing was stored.",
+        "Pipe the token on stdin, or run login in a terminal."
+      );
+    }
+    const typed = supplied ?? await deps2.io.readSecret("Hushscript token: ");
+    registerSecret(rt.secrets, typed);
+    const token = typed.trim();
+    if (token === "") throw usageError("No token was entered.");
+    if (supplied !== void 0) {
+      out.warning(
+        "token_on_command_line",
+        "a token on the command line can leak through shell history and the process list. Run `hushscript login` without --token to type it, or pipe it on stdin."
+      );
+    }
+    new Hushscript({ token });
+    const path = storePath(deps2);
+    await saveToken(path, token, deps2.platform);
+    out.document({ stored: true, path }, `Token saved to ${path}`);
+  });
+}
+
+// src/commands/logout.ts
+function registerLogout(program, rt) {
+  program.command("logout").description("Delete the stored token").action(async () => {
+    const removed = await removeToken(storePath(rt.deps));
+    rt.out.document(
+      { removed },
+      removed ? "Logged out; the stored token was deleted." : "No stored token."
+    );
+  });
+}
+
+// src/commands/packs.ts
+function registerPacks(program, rt) {
+  program.command("packs").description("List the minute packs you can buy").action(async () => {
+    const api = await openClient(rt);
+    const packs = await api.billing.packs();
+    const lines = packs.map((pack) => {
+      const bonus = pack.bonusMinutes > 0 ? `, +${String(pack.bonusMinutes)} min bonus` : "";
+      const locked = pack.available ? "" : " (not available to this account)";
+      return `${pack.id}  ${String(pack.minutes)} min  ${pack.price.formatted}${bonus}${locked}`;
+    });
+    rt.out.document({ packs }, lines.length === 0 ? "No packs." : lines.join("\n"));
+  });
+}
+async function statOrNull(path) {
+  try {
+    return await stat(path);
+  } catch {
+    return null;
+  }
+}
+async function checkInputFile(path) {
+  const info = await statOrNull(path);
+  if (info === null) throw usageError(`No such file: ${path}`);
+  if (!info.isFile()) throw usageError(`Not a file: ${path}`);
+}
+async function checkOutputPath(path) {
+  let target;
+  try {
+    target = await resolveLinks(path);
+  } catch {
+    throw usageError(`--out is a loop of symbolic links: ${path}`);
+  }
+  const folder = await statOrNull(dirname(resolve(target)));
+  if (folder?.isDirectory() !== true) {
+    throw usageError(`The folder for --out does not exist: ${dirname(target)}`);
+  }
+  if ((await statOrNull(target))?.isDirectory() === true) {
+    throw usageError(`--out is a folder, not a file: ${path}`);
+  }
+}
+var MAX_LINK_HOPS = 40;
+var NEW_FILE_MODE = 420;
+async function resolveLinks(path) {
+  let current = path;
+  for (let hops = 0; hops < MAX_LINK_HOPS; hops += 1) {
+    const info = await lstat(current).catch(() => null);
+    if (info?.isSymbolicLink() !== true) return current;
+    current = resolve(dirname(current), await readlink(current));
+  }
+  throw Object.assign(new Error("Too many levels of symbolic links."), { code: "ELOOP" });
+}
+async function writeFileAtomic(path, content, hint) {
+  let temp = null;
+  try {
+    const target = await resolveLinks(path);
+    const existing = await statOrNull(target);
+    temp = join(dirname(target), `.${basename(target)}.${randomBytes(6).toString("hex")}.tmp`);
+    const mode = existing === null ? NEW_FILE_MODE : Number(existing.mode) & 4095;
+    const handle = await open(temp, "wx", mode);
+    try {
+      if (existing !== null) await handle.chmod(mode);
+      await handle.writeFile(content);
+    } finally {
+      await handle.close();
+    }
+    await rename(temp, target);
+  } catch (error) {
+    if (temp !== null) await unlink(temp).catch(() => void 0);
+    const reason = error.code ?? "unknown error";
+    throw new CliError({
+      code: "write_failed",
+      message: `Could not write ${path} (${reason}).`,
+      exitCode: 1,
+      hint
+    });
+  }
+}
+var CLEAR_LINE = "\r\x1B[K";
+function progressLine(progress) {
+  return progress.stage === "uploading" ? `Uploading ${String(progress.percent)}%` : `Processing (${progress.state})`;
+}
+function flagWords(passed, names) {
+  return names.flatMap((name) => {
+    const value = passed[name];
+    return value === void 0 ? [] : [` --${name} ${shellWord(value)}`];
+  }).join("");
+}
+function continueHint(token, key, job) {
+  const file = shellWord(job.file);
+  if (token !== null) {
+    return `Continue with: hushscript resume ${token} ${file}${flagWords(job.passed, ["format", "out"])}`;
+  }
+  if (key === null) return null;
+  const flags = flagWords(job.passed, ["language", "translate", "format", "out"]);
+  return `Retry with: hushscript transcribe --key ${key} ${file}${flags}`;
+}
+async function runJob(rt, job) {
+  const { deps: deps2, out } = rt;
+  const { io: io2 } = deps2;
+  const api = await openClient(rt);
+  const abort = new AbortController();
+  let resumeToken = job.resumeToken;
+  const drawing = { drawn: false };
+  const hooks = {
+    signal: abort.signal,
+    onProgress: void 0,
+    onResumeToken: (token) => {
+      resumeToken = token;
+    }
+  };
+  if (io2.stderrIsTTY && !out.json) {
+    hooks.onProgress = (progress) => {
+      drawing.drawn = true;
+      io2.stderr(`${CLEAR_LINE}${progressLine(progress)}`);
+    };
+  }
+  const wasInterrupted = () => abort.signal.aborted;
+  const stop = io2.onInterrupt((count) => {
+    if (count > 1) {
+      if (drawing.drawn) io2.stderr(CLEAR_LINE);
+      io2.forceExit(
+        out.fail(
+          interrupted(
+            resumeToken,
+            job.idempotencyKey,
+            continueHint(resumeToken, job.idempotencyKey, job)
+          )
+        )
+      );
+      return;
+    }
+    abort.abort();
+  });
+  let transcript;
+  try {
+    transcript = await job.start(api, hooks);
+  } catch (error) {
+    if (wasInterrupted()) {
+      const known = error instanceof HushscriptError ? error : null;
+      const token = known?.resumeToken ?? resumeToken;
+      const key = known?.idempotencyKey ?? job.idempotencyKey;
+      throw interrupted(token, key, continueHint(token, key, job));
+    }
+    throw error;
+  } finally {
+    stop();
+    if (drawing.drawn) io2.stderr(CLEAR_LINE);
+  }
+  const content = renderTranscript(transcript, job.format, void 0);
+  if (job.out === void 0) {
+    out.content(content);
+  } else {
+    await writeFileAtomic(
+      job.out,
+      content,
+      `The transcript was created; fetch it again with \`hushscript transcript ${transcript.id}\`.`
+    );
+    if (out.json) out.document({ id: transcript.id, format: job.format, out: job.out }, "");
+    else out.note(`Saved the ${job.format} transcript ${transcript.id} to ${job.out}`);
+  }
+  if (job.translateTo !== void 0) {
+    out.note(
+      `Translations are ready (${job.translateTo.join(", ")}). Print one with: hushscript transcript ${transcript.id} --lang ${job.translateTo[0] ?? ""}`
+    );
+  }
+}
+
+// src/commands/resume.ts
+function registerResume(program, rt) {
+  program.command("resume").description("Finish a transcription that `transcribe` left behind when it was interrupted").argument("<token>", "the resume token `transcribe` printed").argument("<file>", "the same recording").addOption(new Option("--format <format>", "output format (default txt)").choices(FORMATS)).option("--out <path>", "write the transcript to a file instead of stdout").action(async (token, file, options) => {
+    const format = resolveFormat(rt.globals().json, options.format);
+    await checkInputFile(file);
+    if (options.out !== void 0) await checkOutputPath(options.out);
+    await runJob(rt, {
+      file,
+      passed: { format: options.format, out: options.out },
+      format,
+      out: options.out,
+      resumeToken: token,
+      idempotencyKey: null,
+      translateTo: void 0,
+      start: (api, hooks) => api.resume(token, file, { signal: hooks.signal, onProgress: hooks.onProgress })
+    });
+  });
+}
+function registerTranscribe(program, rt) {
+  program.command("transcribe").description("Upload a recording and print its transcript").argument("<file>", "audio or video file").option("--language <code>", "force the spoken language (default: detect it)").option("--translate <codes>", "also translate, for example es,de").addOption(new Option("--format <format>", "output format (default txt)").choices(FORMATS)).option("--out <path>", "write the transcript to a file instead of stdout").option(
+    "--key <key>",
+    "idempotency key; pass the one an interrupted run printed to replay it safely"
+  ).action(async (file, options) => {
+    const language = options.language === void 0 ? void 0 : parseLanguage(options.language);
+    const translateTo = options.translate === void 0 ? void 0 : parseTranslate(options.translate);
+    const format = resolveFormat(rt.globals().json, options.format);
+    const idempotencyKey = options.key === void 0 ? randomUUID() : parseKey(options.key);
+    await checkInputFile(file);
+    if (options.out !== void 0) await checkOutputPath(options.out);
+    await runJob(rt, {
+      file,
+      passed: {
+        language,
+        translate: translateTo?.join(","),
+        format: options.format,
+        out: options.out
+      },
+      format,
+      out: options.out,
+      resumeToken: null,
+      idempotencyKey,
+      translateTo,
+      start: (api, hooks) => {
+        const request = {
+          signal: hooks.signal,
+          onResumeToken: hooks.onResumeToken,
+          idempotencyKey
+        };
+        if (hooks.onProgress !== void 0) request.onProgress = hooks.onProgress;
+        if (language !== void 0) request.language = language;
+        if (translateTo !== void 0) request.translateTo = translateTo;
+        return api.transcribe(file, request);
+      }
+    });
+  });
+}
+function registerTranscript(program, rt) {
+  program.command("transcript").description("Print one finished transcript").argument("<id>", "transcript id").addOption(new Option("--format <format>", "output format (default txt)").choices(FORMATS)).option("--lang <code>", 'a translation language code, or "cleaned" for the cleaned body').action(async (idArgument, options) => {
+    const id = parseId(idArgument, "The transcript id");
+    const format = resolveFormat(rt.globals().json, options.format);
+    const lang = options.lang === void 0 ? void 0 : parseLang(options.lang);
+    if (lang !== void 0 && format === "json") {
+      throw usageError("--lang does not apply to JSON output, which holds every language.");
+    }
+    const api = await openClient(rt);
+    const transcript = await api.transcripts.get(id);
+    if (lang !== void 0 && lang !== "original") {
+      const known = lang === "cleaned" ? transcript.cleaned !== null : transcript.languages.includes(lang);
+      if (!known) {
+        const available = [
+          ...transcript.languages,
+          ...transcript.cleaned === null ? [] : ["cleaned"]
+        ];
+        throw usageError(
+          `This transcript has no "${lang}" version.`,
+          available.length === 0 ? "It has only the original." : `Available: ${available.join(", ")}.`
+        );
+      }
+    }
+    rt.out.content(renderTranscript(transcript, format, lang));
+  });
+}
+
+// src/commands/transcripts.ts
+var DEFAULT_LIMIT = 20;
+var MAX_PAGE_SIZE = 100;
+function registerTranscripts(program, rt) {
+  program.command("transcripts").description("List finished transcripts, newest first").option("--limit <n>", `how many to list (default ${String(DEFAULT_LIMIT)})`).action(async (options) => {
+    const limit = options.limit === void 0 ? DEFAULT_LIMIT : parseLimit(options.limit);
+    const api = await openClient(rt);
+    const transcripts = [];
+    for await (const summary of api.transcripts.list({
+      pageSize: Math.min(limit, MAX_PAGE_SIZE)
+    })) {
+      transcripts.push(summary);
+      if (transcripts.length >= limit) break;
+    }
+    const lines = transcripts.map(
+      (row) => `${row.id}  ${formatDate(row.createdAt)}  ${formatDuration(row.durationSeconds)}  ${row.title}`
+    );
+    rt.out.document({ transcripts }, lines.length === 0 ? "No transcripts." : lines.join("\n"));
+  });
+}
+
+// src/program.ts
+var CLEAN_EXIT = /* @__PURE__ */ new Set(["commander.helpDisplayed", "commander.version"]);
+function tokensIn(argv) {
+  const found = [];
+  argv.forEach((arg, index) => {
+    if (arg === "--token") {
+      const next = argv[index + 1];
+      if (next !== void 0) found.push(next);
+    } else if (arg.startsWith("--token=")) {
+      found.push(arg.slice("--token=".length));
+    }
+  });
+  return found;
+}
+function buildProgram(rt, program, shown) {
+  program.name("hushscript").description("Command line client for the Hushscript transcription API.").version(package_default.version).option("--json", "print one JSON document on stdout; stderr as JSON Lines").option("--token <token>", "API token (default: HUSHSCRIPT_TOKEN, then the one from `login`)").configureOutput({
+    // Under --json the help or version text is held back and printed as a JSON document instead.
+    writeOut: (text) => {
+      if (rt.out.json) shown.text += text;
+      else rt.deps.io.stdout(text);
+    },
+    // Under --json stderr carries only JSON; a bare `hushscript --json` reports its usage error that way.
+    writeErr: (text) => {
+      if (!rt.out.json) rt.deps.io.stderr(text);
+    },
+    outputError: () => void 0
+  }).exitOverride();
+  registerLogin(program, rt);
+  registerLogout(program, rt);
+  registerBalance(program, rt);
+  registerTranscribe(program, rt);
+  registerResume(program, rt);
+  registerTranscripts(program, rt);
+  registerTranscript(program, rt);
+  registerJobs(program, rt);
+  registerPacks(program, rt);
+  registerBuy(program, rt);
+}
+async function run(argv, deps2) {
+  const secrets = [];
+  for (const token of tokensIn(argv)) registerSecret(secrets, token);
+  registerSecret(secrets, deps2.env["HUSHSCRIPT_TOKEN"] ?? "");
+  const program = new Command();
+  const out = new Output(deps2.io, argv.includes("--json"), secrets);
+  const rt = {
+    deps: deps2,
+    out,
+    secrets,
+    globals: () => {
+      const options = program.opts();
+      const globals = { json: options.json === true, token: valueOf(options.token) };
+      return globals;
+    }
+  };
+  const shown = { text: "" };
+  buildProgram(rt, program, shown);
+  const printShown = (code2) => {
+    if (!out.json) return;
+    out.document(
+      code2 === "commander.version" ? { version: shown.text.trim() } : { help: shown.text },
+      ""
+    );
+  };
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (CLEAN_EXIT.has(error.code)) {
+        printShown(error.code);
+        return 0;
+      }
+      if (error.code === "commander.help") {
+        if (error.exitCode === 0) {
+          printShown(error.code);
+          return 0;
+        }
+        if (!out.json) return 2;
+        return out.fail(
+          usageError("A command is required.", "Run `hushscript --help` to list them.")
+        );
+      }
+      return out.fail(usageError(error.message.replace(/^error: /, "")));
+    }
+    return out.fail(error);
+  }
+}
+
+// src/signals.ts
+var STOP_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var INTERRUPTED_EXIT = 130;
+function installInterrupts(host) {
+  let open3 = null;
+  let forced = null;
+  const received = () => {
+    if (forced !== null) {
+      host.exit(forced);
+      return;
+    }
+    if (open3 === null) {
+      host.exit(INTERRUPTED_EXIT);
+      return;
+    }
+    open3.count += 1;
+    open3.handler(open3.count);
+  };
+  for (const signal of STOP_SIGNALS) host.listen(signal, received);
+  return {
+    onInterrupt: (handler) => {
+      const window = { handler, count: 0 };
+      open3 = window;
+      return () => {
+        if (open3 === window) open3 = null;
+      };
+    },
+    forceExit: (code2) => {
+      forced ??= code2;
+      const final = forced;
+      host.flushStderr(() => {
+        host.exit(final);
+      });
+    },
+    exiting: () => forced !== null,
+    finalCode: (code2) => forced ?? code2
+  };
+}
+
+// src/index.ts
+function flush(stream) {
+  return new Promise(
+    (resolve2) => stream.write("", () => {
+      resolve2();
+    })
+  );
+}
+var interrupts = installInterrupts({
+  listen: (signal, listener) => process.on(signal, listener),
+  flushStderr: (done) => process.stderr.write("", done),
+  // eslint-disable-next-line n/no-process-exit -- an interrupted purchase and a second Ctrl-C must end the process at once
+  exit: (code2) => process.exit(code2)
+});
+var io = {
+  stdout: (text) => {
+    if (!interrupts.exiting()) process.stdout.write(text);
+  },
+  stderr: (text) => {
+    if (!interrupts.exiting()) process.stderr.write(text);
+  },
+  stdinIsTTY: process.stdin.isTTY,
+  stdoutIsTTY: process.stdout.isTTY,
+  stderrIsTTY: process.stderr.isTTY,
+  readSecret: (prompt) => readSecret(process.stdin, process.stderr, prompt),
+  confirm: (prompt) => confirm(process.stdin, process.stderr, prompt),
+  onInterrupt: interrupts.onInterrupt,
+  forceExit: interrupts.forceExit
+};
+var deps = {
+  io,
+  env: process.env,
+  platform: process.platform,
+  homedir: homedir(),
+  createClient: ({ token, baseUrl }) => new Hushscript({ token, baseUrl })
+};
+var code = await run(process.argv.slice(2), deps);
+await Promise.all([flush(process.stdout), flush(process.stderr)]);
+process.exit(interrupts.finalCode(code));

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@hushscript/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Command line client for the Hushscript transcription API.",
+  "license": "MIT",
+  "type": "module",
+  "homepage": "https://github.com/Hushscript/hushscript-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hushscript/hushscript-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Hushscript/hushscript-cli/issues"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "hushscript": "dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "config": {
+    "conformanceRef": "v1.0.0"
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@hushscript/sdk": "^1.0.0",
+    "commander": "15.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "22.20.5",
+    "@vitest/coverage-v8": "5.0.3",
+    "eslint": "10.12.0",
+    "eslint-plugin-n": "18.4.1",
+    "eslint-plugin-regexp": "3.3.1",
+    "globals": "17.13.0",
+    "knip": "6.39.0",
+    "prettier": "3.9.9",
+    "publint": "0.3.25",
+    "tsup": "8.5.1",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.71.1",
+    "vitest": "5.0.3"
+  }
+}