@twistedsignal/raven 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Twisted Signal
+
+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

@@ -0,0 +1,160 @@
+# Raven
+
+A CLI for the [Roblox Open Cloud API](https://create.roblox.com/docs/cloud). Upload assets, publish places, edit data stores, and manage live servers from your terminal or CI.
+
+## Install
+
+Requires Node.js 20 or newer.
+
+```bash
+npm install -g https://github.com/twistedsignal/raven/archive/refs/heads/main.tar.gz
+```
+
+> `npm install -g github:twistedsignal/raven` currently leaves a broken install on npm 11 (npm links the package to a temporary clone and then deletes it), so use the tarball URL above.
+
+To update, run:
+
+```bash
+raven update          # install the latest version
+raven update --check  # just check whether there's a new one
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/twistedsignal/raven
+cd raven
+pnpm install && pnpm build
+npm link
+```
+
+The compiled `dist/` is committed so installing from GitHub doesn't need a build step. If you change anything in `src/`, run `pnpm build` and commit `dist/` with it; CI fails if it's out of date.
+
+## Logging in
+
+```bash
+raven auth
+```
+
+Raven asks which commands you want to use, tells you exactly which permissions to give your Open Cloud API key for those, then verifies and saves it. Commands you didn't pick are disabled (and marked as such in `raven -h`), so your key only ever needs the permissions you actually use.
+
+```bash
+raven auth commands # change which commands are enabled
+raven auth status   # show the saved key and enabled commands
+raven auth logout   # remove the saved key
+```
+
+Keys are stored at `~/.config/raven/credentials.json` (`%APPDATA%\raven` on Windows) with `0600` permissions. In CI, set `RAVEN_API_KEY` instead of running `raven auth`. You can also pass `--api-key <key>` to any command.
+
+## Commands
+
+Run `raven -h` or `raven <command> -h` for the full list of options.
+
+### Assets
+
+```bash
+# Upload (type is inferred from the extension if --type is omitted)
+raven asset upload --path sword.fbx --type Model --name "Sword" --description "A sword" --creator user:12345
+raven asset upload --path logo.png --creator group:67890
+
+# Upload a new version and/or change metadata
+raven asset update --id 1234567890 --path sword_v2.fbx
+raven asset update --id 1234567890 --name "Better Sword" --description "Sharper"
+
+# Roll back to a previous version
+raven asset rollback --id 1234567890 --to 3
+
+# Inspect
+raven asset get --id 1234567890
+raven asset versions --id 1234567890
+```
+
+`--creator` accepts `user:<id>`, `group:<id>`, or a bare user ID. Supported asset types are `Audio`, `Decal`, `Model`, `Video`, and `Animation`.
+
+### Publishing places
+
+```bash
+raven publish --path game.rbxlx --universe 1234 --place 5678
+raven publish --path game.rbxl --universe 1234 --place 5678 --saved   # save without publishing
+```
+
+### Data stores
+
+```bash
+raven datastore list --universe 1234                                  # list data stores
+raven datastore list --universe 1234 --datastore Players --prefix user_  # list keys
+raven datastore get --universe 1234 --datastore Players --key user_1
+raven datastore set --universe 1234 --datastore Players --key user_1 --value '{"coins": 100}'
+raven datastore set --universe 1234 --datastore Players --key user_1 --file data.json --users 1
+raven datastore increment --universe 1234 --datastore Stats --key visits --by 5
+raven datastore delete --universe 1234 --datastore Players --key user_1
+```
+
+`datastore delete` is irreversible, so it only runs interactively in a terminal and asks you to type the data store name to confirm. It can't be run from scripts or CI.
+
+`datastore` can be shortened to `ds`. Use `--scope <name>` to target a scope other than `global`.
+
+### Game passes and developer products
+
+Every `product` command takes `--type gamepass` or `--type devProduct`.
+
+```bash
+raven product add --type gamepass --universe 1234 --name "VIP" --description "VIP perks" --price 100 --icon vip.png
+raven product add --type devProduct --universe 1234 --name "100 Coins" --price 25 --managed-pricing
+raven product update --type devProduct --universe 1234 --id 5678 --price 30 --no-managed-pricing
+raven product disable --type gamepass --universe 1234 --id 5678      # take off sale
+raven product enable --type gamepass --universe 1234 --id 5678       # put back on sale
+raven product list --type devProduct --universe 1234
+raven product get --type gamepass --universe 1234 --id 5678
+```
+
+- `--managed-pricing` / `--no-managed-pricing` turns Roblox's managed (regional) pricing on or off. Leave both out to keep the current setting.
+- `add` puts the product on sale when you give it a `--price` (pass `--offsale` to skip that).
+- Roblox doesn't allow deleting game passes or developer products, so `disable` takes them off sale instead. Players who already own a game pass keep it.
+
+### Servers
+
+```bash
+raven server restart --universe 1234                                  # restarts outdated servers
+raven server message --universe 1234 --topic Announcements --message "Restarting in 5 minutes"
+```
+
+`server message` publishes through [MessagingService](https://create.roblox.com/docs/reference/engine/classes/MessagingService), so your game needs to subscribe to the topic.
+
+## Scripting
+
+| Variable              | Equivalent flag |
+| --------------------- | --------------- |
+| `RAVEN_API_KEY`       | `--api-key`     |
+| `RAVEN_UNIVERSE_ID`   | `--universe`    |
+| `RAVEN_PLACE_ID`      | `--place`       |
+| `RAVEN_CREATOR`       | `--creator`     |
+
+Pass `--json` to any command for machine-readable output.
+
+```bash
+raven --json datastore get -u 1234 -d Players -k user_1 | jq .value
+```
+
+## API key permissions
+
+`raven auth` shows only the permissions for the commands you pick. For reference:
+
+| Command                                      | API system                    | Operations        |
+| -------------------------------------------- | ----------------------------- | ----------------- |
+| `asset`                                      | `assets`                      | Read, Write       |
+| `product --type gamepass`                    | `game-pass`                   | Read, Write       |
+| `product --type devProduct`                  | `developer-product`           | Read, Write       |
+| `publish`                                    | `universe-places`             | Write             |
+| `datastore list`, `datastore get`            | `universe-datastores.control` | List              |
+|                                              | `universe-datastores.objects` | List, Read        |
+| `datastore set`, `datastore increment`       | `universe-datastores.objects` | Create, Update    |
+| `datastore delete`                           | `universe-datastores.objects` | Delete            |
+| `server restart`                             | `universe`                    | Write             |
+| `server message`                             | `universe-messaging-service`  | Publish           |
+
+When you use `RAVEN_API_KEY` or `--api-key`, every command is enabled.
+
+## License
+
+[MIT](LICENSE) © 2026 Twisted Signal

package/dist/commands/asset.js

@@ -0,0 +1,207 @@
+import { Command, InvalidArgumentError, Option } from "commander";
+import pc from "picocolors";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { request, sleep } from "../lib/api.js";
+import { parseCreator, parseId, parsePositiveInt } from "../lib/args.js";
+import { CliError } from "../lib/config.js";
+import { examples } from "../lib/help.js";
+import { field, output, success, withSpinner } from "../lib/output.js";
+const ASSET_TYPES = ["Audio", "Decal", "Model", "Video", "Animation"];
+const CONTENT_TYPES = {
+    ".mp3": { contentType: "audio/mpeg", assetType: "Audio" },
+    ".ogg": { contentType: "audio/ogg", assetType: "Audio" },
+    ".wav": { contentType: "audio/wav", assetType: "Audio" },
+    ".flac": { contentType: "audio/flac", assetType: "Audio" },
+    ".png": { contentType: "image/png", assetType: "Decal" },
+    ".jpg": { contentType: "image/jpeg", assetType: "Decal" },
+    ".jpeg": { contentType: "image/jpeg", assetType: "Decal" },
+    ".bmp": { contentType: "image/bmp", assetType: "Decal" },
+    ".tga": { contentType: "image/tga", assetType: "Decal" },
+    ".fbx": { contentType: "model/fbx", assetType: "Model" },
+    ".gltf": { contentType: "model/gltf+json", assetType: "Model" },
+    ".glb": { contentType: "model/gltf-binary", assetType: "Model" },
+    ".rbxm": { contentType: "model/x-rbxm", assetType: "Model" },
+    ".rbxmx": { contentType: "model/x-rbxm", assetType: "Model" },
+    ".mp4": { contentType: "video/mp4", assetType: "Video" },
+    ".mov": { contentType: "video/mov", assetType: "Video" },
+};
+function parseAssetType(value) {
+    const match = ASSET_TYPES.find((t) => t.toLowerCase() === value.toLowerCase());
+    if (!match)
+        throw new InvalidArgumentError(`Expected one of: ${ASSET_TYPES.join(", ")}.`);
+    return match;
+}
+function contentTypeFor(path) {
+    const entry = CONTENT_TYPES[extname(path).toLowerCase()];
+    if (!entry) {
+        throw new CliError(`Unsupported file extension "${extname(path)}". Supported: ${Object.keys(CONTENT_TYPES).join(", ")}`);
+    }
+    return entry;
+}
+async function readAssetFile(path) {
+    const { contentType } = contentTypeFor(path);
+    try {
+        return new Blob([await readFile(path)], { type: contentType });
+    }
+    catch (err) {
+        throw new CliError(`Could not read ${path}: ${err.message}`);
+    }
+}
+/** Polls an asset operation until it finishes. */
+async function waitForOperation(op, onTick) {
+    const id = op.path.split("/").pop();
+    let current = op;
+    for (let attempt = 0; !current.done; attempt++) {
+        if (attempt >= 30)
+            throw new CliError(`Timed out waiting for operation ${id}. Check it later on the Creator Dashboard.`);
+        onTick?.(attempt);
+        await sleep(Math.min(1000 * 1.5 ** attempt, 5000));
+        current = await request("GET", `/assets/v1/operations/${id}`);
+    }
+    if (current.error)
+        throw new CliError(`Operation failed: ${current.error.message ?? JSON.stringify(current.error)}`);
+    return current.response ?? {};
+}
+function printAsset(asset) {
+    field("Asset ID", asset.assetId);
+    field("Type", asset.assetType);
+    field("Name", asset.displayName);
+    field("Description", asset.description);
+    field("Revision", asset.revisionId);
+    field("Updated", asset.revisionCreateTime);
+    field("Moderation", asset.moderationResult?.moderationState);
+    if (asset.assetId)
+        field("URL", pc.underline(`https://create.roblox.com/store/asset/${asset.assetId}`));
+}
+export function assetCommand() {
+    const asset = new Command("asset").description("upload, update, and roll back assets").addHelpText("after", examples(["raven asset upload --path sword.fbx --creator user:123", "type is inferred from the extension"], ["raven asset upload --path logo.png --type Decal --name Logo --creator group:456"], ["raven asset update --id 987 --path sword_v2.fbx", "upload a new version"], ["raven asset rollback --id 987 --to 3"], ["raven asset versions --id 987"]));
+    asset
+        .command("upload")
+        .description("upload a new asset")
+        .requiredOption("--path <file>", "file to upload")
+        .addOption(new Option("--type <type>", "asset type (inferred from the file extension if omitted)")
+        .choices(ASSET_TYPES)
+        .argParser(parseAssetType))
+        .option("--name <name>", "display name (defaults to the file name)")
+        .option("--description <text>", "asset description", "")
+        .addOption(new Option("--creator <creator>", "owner as `user:<id>` or `group:<id>`")
+        .env("RAVEN_CREATOR")
+        .argParser(parseCreator)
+        .makeOptionMandatory())
+        .option("--no-wait", "don't wait for processing to finish")
+        .action(async (opts) => {
+        const { assetType: inferred } = contentTypeFor(opts.path);
+        const assetType = opts.type ?? inferred;
+        const displayName = opts.name ?? basename(opts.path, extname(opts.path));
+        const form = new FormData();
+        form.append("request", JSON.stringify({
+            assetType,
+            displayName,
+            description: opts.description,
+            creationContext: { creator: opts.creator },
+        }));
+        form.append("fileContent", await readAssetFile(opts.path), basename(opts.path));
+        const result = await withSpinner(`Uploading ${basename(opts.path)}...`, async (spinner) => {
+            const op = await request("POST", "/assets/v1/assets", { body: form });
+            if (!opts.wait)
+                return op;
+            spinner.text = "Processing asset...";
+            return waitForOperation(op);
+        });
+        output(result, () => {
+            if ("path" in result && result.path?.startsWith("operations/")) {
+                success(`Upload started (${result.path}).`);
+            }
+            else {
+                success(`Uploaded ${pc.cyan(displayName)}`);
+                printAsset(result);
+            }
+        });
+    });
+    asset
+        .command("update")
+        .description("upload a new version of an asset and/or update its metadata")
+        .requiredOption("--id <assetId>", "asset ID", parseId)
+        .option("--path <file>", "new file contents")
+        .option("--name <name>", "new display name")
+        .option("--description <text>", "new description")
+        .option("--no-wait", "don't wait for processing to finish")
+        .action(async (opts) => {
+        if (!opts.path && opts.name === undefined && opts.description === undefined) {
+            throw new CliError("Nothing to update. Pass --path, --name, and/or --description.");
+        }
+        const body = { assetId: opts.id };
+        const mask = [];
+        if (opts.name !== undefined) {
+            body.displayName = opts.name;
+            mask.push("displayName");
+        }
+        if (opts.description !== undefined) {
+            body.description = opts.description;
+            mask.push("description");
+        }
+        const form = new FormData();
+        form.append("request", JSON.stringify(body));
+        if (opts.path)
+            form.append("fileContent", await readAssetFile(opts.path), basename(opts.path));
+        const result = await withSpinner(`Updating asset ${opts.id}...`, async (spinner) => {
+            const op = await request("PATCH", `/assets/v1/assets/${opts.id}`, {
+                body: form,
+                query: { updateMask: mask.length ? mask.join(",") : undefined },
+            });
+            if (!opts.wait)
+                return op;
+            spinner.text = "Processing asset...";
+            return waitForOperation(op);
+        });
+        output(result, () => {
+            success(`Updated asset ${pc.cyan(opts.id)}`);
+            if (opts.wait)
+                printAsset(result);
+        });
+    });
+    asset
+        .command("rollback")
+        .description("roll an asset back to a previous version")
+        .requiredOption("--id <assetId>", "asset ID", parseId)
+        .requiredOption("--to <version>", "version number to roll back to", parsePositiveInt)
+        .action(async (opts) => {
+        const form = new FormData();
+        form.append("assetVersion", `assets/${opts.id}/versions/${opts.to}`);
+        const result = await withSpinner(`Rolling back asset ${opts.id}...`, () => request("POST", `/assets/v1/assets/${opts.id}/versions:rollback`, { body: form }));
+        output(result, () => {
+            success(`Rolled back asset ${pc.cyan(opts.id)} to version ${opts.to}`);
+            field("New version", result?.path?.split("/").pop());
+        });
+    });
+    asset
+        .command("get")
+        .description("show information about an asset")
+        .requiredOption("--id <assetId>", "asset ID", parseId)
+        .action(async (opts) => {
+        const result = await withSpinner(`Fetching asset ${opts.id}...`, () => request("GET", `/assets/v1/assets/${opts.id}`, {
+            query: { readMask: "assetType,creationContext,description,displayName,path,revisionId,revisionCreateTime,state,moderationResult" },
+        }));
+        output(result, () => printAsset(result));
+    });
+    asset
+        .command("versions")
+        .description("list versions of an asset")
+        .requiredOption("--id <assetId>", "asset ID", parseId)
+        .option("--limit <n>", "maximum number of versions to show", parsePositiveInt, 10)
+        .action(async (opts) => {
+        const result = await withSpinner(`Fetching versions of ${opts.id}...`, () => request("GET", `/assets/v1/assets/${opts.id}/versions`, { query: { maxPageSize: Math.min(opts.limit, 50) } }));
+        const versions = (result.assetVersions ?? []).slice(0, opts.limit);
+        output(versions, () => {
+            if (!versions.length)
+                return console.log("No versions found.");
+            for (const v of versions) {
+                const num = v.path.split("/").pop();
+                const state = v.moderationResult?.moderationState;
+                console.log(`  ${pc.bold(`v${num}`)}${v.published ? pc.green(" published") : ""}${state ? pc.dim(` ${state}`) : ""}`);
+            }
+        });
+    });
+    return asset;
+}

package/dist/commands/auth.js

@@ -0,0 +1,176 @@
+import { Command } from "commander";
+import { checkbox, password } from "@inquirer/prompts";
+import pc from "picocolors";
+import { createInterface } from "node:readline/promises";
+import { ApiError, request } from "../lib/api.js";
+import { openBrowser } from "../lib/browser.js";
+import { clearCredentials, CliError, credentialsPath, loadCredentials, saveCredentials, } from "../lib/config.js";
+import { examples } from "../lib/help.js";
+import { field, output, success, withSpinner } from "../lib/output.js";
+import { FEATURE_IDS, FEATURES, featureCommands, printEnabledCommands, printPermissionTable, } from "../lib/permissions.js";
+const CREDENTIALS_URL = "https://create.roblox.com/dashboard/credentials?activeTab=ApiKeysTab";
+export async function introspect(apiKey) {
+    return request("POST", "/api-keys/v1/introspect", { json: { apiKey }, noAuth: true });
+}
+async function pressEnter(message) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        await rl.question(message);
+    }
+    finally {
+        rl.close();
+    }
+}
+function requireTty() {
+    if (!process.stdin.isTTY) {
+        throw new CliError("This command is interactive. In non-interactive environments, set RAVEN_API_KEY instead.");
+    }
+}
+/** The checklist of commands to enable. `previous` pre-checks an earlier selection. */
+async function pickFeatures(previous) {
+    return checkbox({
+        message: "Which commands do you want to use?",
+        choices: FEATURES.map((f) => ({
+            value: f.id,
+            name: f.name,
+            description: `raven ${featureCommands(f).replaceAll(", ", ", raven ")}`,
+            checked: previous?.includes(f.id) ?? false,
+        })),
+        required: true,
+        loop: false,
+        pageSize: FEATURES.length,
+        theme: { style: { renderSelectedChoices: (selected) => `${selected.length} selected` } },
+    });
+}
+function printKeyInstructions(features, heading) {
+    console.log();
+    console.log(heading);
+    console.log();
+    printPermissionTable(FEATURES.filter((f) => features.includes(f.id)));
+    console.log();
+    console.log(pc.dim("  For each API system, select the experiences you want Raven to manage."));
+}
+async function verify(apiKey) {
+    const info = await withSpinner("Verifying token...", async () => {
+        try {
+            return await introspect(apiKey);
+        }
+        catch (err) {
+            if (err instanceof ApiError && (err.status === 400 || err.status === 401 || err.status === 403)) {
+                throw new CliError("That token is invalid. Double check you copied the whole key and try again.");
+            }
+            throw err;
+        }
+    });
+    if (info.enabled === false)
+        throw new CliError("That API key is disabled. Enable it on the Creator Dashboard.");
+    if (info.expired)
+        throw new CliError("That API key has expired. Create a new one and try again.");
+    return info;
+}
+function printMissingHint(ok) {
+    if (ok)
+        return;
+    console.log();
+    console.log(pc.yellow("Some enabled commands need permissions this key doesn't have."));
+    console.log(pc.yellow(`Edit the key at ${pc.underline(CREDENTIALS_URL)} and add them.`));
+}
+async function login() {
+    requireTty();
+    const previous = await loadCredentials();
+    console.log();
+    console.log(pc.bold("Welcome to Raven!") + " Let's get you logged in with a Roblox Open Cloud API key.");
+    console.log(pc.dim("Pick only what you need. Your key will only need permissions for those commands."));
+    console.log();
+    const features = await pickFeatures(previous?.features);
+    console.log();
+    await pressEnter(`${pc.cyan("?")} Press ${pc.bold("Enter")} to open ${pc.underline(CREDENTIALS_URL)} `);
+    const opened = await openBrowser(CREDENTIALS_URL);
+    if (!opened)
+        console.log(pc.dim(`  Couldn't open a browser. Visit the link above manually.`));
+    printKeyInstructions(features, `Click ${pc.bold("Create API Key")}, give it a name, then click ${pc.bold("Add API System")} and add:`);
+    console.log(pc.dim("  Under Security, add your IP address (or 0.0.0.0/0 to allow any IP)."));
+    console.log(pc.dim(`  Click ${pc.bold("Save & Generate Key")}, then copy the key.`));
+    console.log();
+    await pressEnter(`${pc.cyan("?")} Press ${pc.bold("Enter")} once you've created and copied the key `);
+    console.log();
+    const apiKey = (await password({
+        message: "Enter token:",
+        mask: "*",
+        validate: (v) => (v.trim().length > 0 ? true : "Token cannot be empty."),
+    })).trim();
+    console.log();
+    const info = await verify(apiKey);
+    await saveCredentials({
+        apiKey,
+        name: info.name,
+        ownerId: info.authorizedUserId !== undefined ? String(info.authorizedUserId) : undefined,
+        features,
+        savedAt: new Date().toISOString(),
+    });
+    success(pc.bold("Success!"));
+    console.log(`You are now logged into Raven${info.name ? ` with key ${pc.cyan(info.name)}` : ""}.`);
+    console.log();
+    printMissingHint(printEnabledCommands(features, info.scopes));
+    console.log();
+    console.log(pc.dim(`Change which commands are enabled any time with ${pc.cyan("raven auth commands")}.`));
+}
+async function changeCommands() {
+    requireTty();
+    const creds = await loadCredentials();
+    if (!creds)
+        throw new CliError("You are not logged in. Run `raven auth` to log in.");
+    const before = creds.features ?? FEATURE_IDS;
+    const features = await pickFeatures(before);
+    const added = features.filter((f) => !before.includes(f));
+    await saveCredentials({ ...creds, features });
+    console.log();
+    success("Saved.");
+    if (added.length) {
+        printKeyInstructions(added, `Make sure your API key has these permissions for the newly enabled commands (${pc.underline(CREDENTIALS_URL)}):`);
+    }
+    console.log();
+    const info = await withSpinner("Checking token...", () => introspect(creds.apiKey)).catch(() => undefined);
+    printMissingHint(printEnabledCommands(features, info?.scopes));
+}
+export function authCommand() {
+    const auth = new Command("auth")
+        .description("log in with a Roblox Open Cloud API key")
+        .addHelpText("after", `
+Running \`raven auth\` asks which commands you want, tells you exactly which
+permissions to give your API key, then verifies and saves it.
+${examples(["raven auth", "log in interactively"], ["raven auth commands", "change which commands are enabled"], ["raven auth status", "show the saved key and enabled commands"], ["raven auth logout", "remove the saved key"])}
+
+In CI, set RAVEN_API_KEY instead of running \`raven auth\`. All commands are
+enabled when using RAVEN_API_KEY or --api-key.`)
+        .action(login);
+    auth.command("commands").description("choose which commands are enabled").action(changeCommands);
+    auth
+        .command("status")
+        .description("show the saved API key and enabled commands")
+        .action(async () => {
+        const creds = await loadCredentials();
+        if (!creds)
+            throw new CliError("You are not logged in. Run `raven auth` to log in.");
+        const info = await withSpinner("Checking token...", () => introspect(creds.apiKey));
+        const features = creds.features ?? FEATURE_IDS;
+        output({ ...info, enabledCommands: features, savedAt: creds.savedAt, path: credentialsPath() }, () => {
+            success(`Logged in${info.name ? ` as ${pc.cyan(info.name)}` : ""}`);
+            field("Owner", info.authorizedUserId);
+            field("Enabled", info.enabled);
+            field("Expires", info.expirationTime ?? "never");
+            field("Saved", creds.savedAt);
+            field("Stored at", credentialsPath());
+            console.log();
+            printMissingHint(printEnabledCommands(features, info.scopes));
+        });
+    });
+    auth
+        .command("logout")
+        .description("remove the saved API key")
+        .action(async () => {
+        const removed = await clearCredentials();
+        success(removed ? "Logged out." : "You weren't logged in.");
+    });
+    return auth;
+}