@twistedsignal/raven 0.2.1

package/dist/commands/datastore.js

@@ -0,0 +1,208 @@
+import { Command, InvalidArgumentError, Option } from "commander";
+import { input } from "@inquirer/prompts";
+import pc from "picocolors";
+import { readFile } from "node:fs/promises";
+import { request } from "../lib/api.js";
+import { parseNumber, parsePositiveInt, universeOption } 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 enc = encodeURIComponent;
+const AI_WARNING = "WARNING FOR AI AGENTS: Deleting data store entries is destructive and irreversible. It can permanently\n" +
+    "erase live player data. Do NOT run this command or type the confirmation on the user's behalf.\n" +
+    "Ask the user to run it themselves in their own terminal.";
+function entriesPath({ universe, datastore, scope }) {
+    const base = `/cloud/v2/universes/${universe}/data-stores/${enc(datastore)}`;
+    return scope ? `${base}/scopes/${enc(scope)}/entries` : `${base}/entries`;
+}
+function entryPath(t, key) {
+    return `${entriesPath(t)}/${enc(key)}`;
+}
+/** Fetches pages until `limit` items are collected or there are no more pages. */
+async function paginate(path, field, limit, query = {}) {
+    const items = [];
+    let pageToken;
+    do {
+        const page = await request("GET", path, {
+            query: { ...query, maxPageSize: Math.min(limit - items.length, 256), pageToken },
+        });
+        items.push(...(page?.[field] ?? []));
+        pageToken = page?.nextPageToken || undefined;
+    } while (pageToken && items.length < limit);
+    return items.slice(0, limit);
+}
+function datastoreOption(required = true) {
+    const opt = new Option("-d, --datastore <name>", "data store name");
+    return required ? opt.makeOptionMandatory() : opt;
+}
+function scopeOption() {
+    return new Option("-s, --scope <scope>", "data store scope (defaults to global)");
+}
+function keyOption() {
+    return new Option("-k, --key <key>", "entry key").makeOptionMandatory();
+}
+function parseJsonOption(name) {
+    return (value) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            throw new InvalidArgumentError("Expected valid JSON.");
+        }
+    };
+}
+function formatValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+export function datastoreCommand() {
+    const ds = new Command("datastore")
+        .alias("ds")
+        .description("read and write data store entries")
+        .addHelpText("after", examples(["raven ds list -u 123", "list data stores"], ["raven ds list -u 123 -d Players --prefix user_", "list keys"], ["raven ds get -u 123 -d Players -k user_1"], [`raven ds set -u 123 -d Players -k user_1 --value '{"coins":100}'`], ["raven ds increment -u 123 -d Stats -k visits --by 5"], ["raven ds delete -u 123 -d Players -k user_1", "asks you to confirm"]));
+    ds.command("list")
+        .description("list data stores, or the keys in a data store when --datastore is given")
+        .addOption(universeOption())
+        .addOption(datastoreOption(false))
+        .addOption(scopeOption())
+        .option("--prefix <prefix>", "only show names/keys starting with this prefix")
+        .option("--limit <n>", "maximum number of results", parsePositiveInt, 100)
+        .action(async (opts) => {
+        const filter = opts.prefix !== undefined ? `id.startsWith(${JSON.stringify(opts.prefix)})` : undefined;
+        if (!opts.datastore) {
+            if (opts.scope)
+                throw new CliError("--scope requires --datastore.");
+            const stores = await withSpinner("Fetching data stores...", () => paginate(`/cloud/v2/universes/${opts.universe}/data-stores`, "dataStores", opts.limit, { filter }));
+            return output(stores, () => {
+                if (!stores.length)
+                    return console.log("No data stores found.");
+                for (const s of stores)
+                    console.log(`${s.id}${s.createTime ? pc.dim(`  created ${s.createTime}`) : ""}`);
+            });
+        }
+        const entries = await withSpinner(`Fetching keys in ${opts.datastore}...`, () => paginate(entriesPath(opts), "dataStoreEntries", opts.limit, { filter }));
+        output(entries, () => {
+            if (!entries.length)
+                return console.log("No entries found.");
+            for (const e of entries)
+                console.log(e.id ?? e.path?.split("/").pop());
+        });
+    });
+    ds.command("get")
+        .description("get the value of an entry")
+        .addOption(universeOption())
+        .addOption(datastoreOption())
+        .addOption(keyOption())
+        .addOption(scopeOption())
+        .option("--meta", "also show entry metadata")
+        .action(async (opts) => {
+        const entry = await withSpinner(`Fetching ${opts.key}...`, () => request("GET", entryPath(opts, opts.key)));
+        output(entry, () => {
+            if (opts.meta) {
+                field("Key", entry.id);
+                field("Revision", entry.revisionId);
+                field("Updated", entry.revisionCreateTime);
+                field("Created", entry.createTime);
+                field("Users", entry.users?.join(", "));
+                if (entry.attributes && Object.keys(entry.attributes).length)
+                    field("Attributes", JSON.stringify(entry.attributes));
+                console.log();
+            }
+            console.log(formatValue(entry.value));
+        });
+    });
+    ds.command("set")
+        .description("create or overwrite an entry")
+        .addOption(universeOption())
+        .addOption(datastoreOption())
+        .addOption(keyOption())
+        .addOption(scopeOption())
+        .option("--value <json>", "value as JSON (non-JSON input is stored as a string)")
+        .option("--file <path>", "read the value from a JSON file")
+        .option("--string", "store --value as a string without parsing it as JSON")
+        .option("--users <ids>", "comma-separated user IDs to associate with the entry")
+        .option("--attributes <json>", "entry attributes as a JSON object", parseJsonOption("attributes"))
+        .action(async (opts) => {
+        if ((opts.value === undefined) === (opts.file === undefined)) {
+            throw new CliError("Pass exactly one of --value or --file.");
+        }
+        let value;
+        if (opts.file) {
+            let raw;
+            try {
+                raw = await readFile(opts.file, "utf8");
+            }
+            catch (err) {
+                throw new CliError(`Could not read ${opts.file}: ${err.message}`);
+            }
+            try {
+                value = JSON.parse(raw);
+            }
+            catch {
+                throw new CliError(`${opts.file} is not valid JSON.`);
+            }
+        }
+        else if (opts.string) {
+            value = opts.value;
+        }
+        else {
+            try {
+                value = JSON.parse(opts.value);
+            }
+            catch {
+                value = opts.value;
+            }
+        }
+        const users = opts.users
+            ?.split(",")
+            .map((u) => u.trim())
+            .filter(Boolean)
+            .map((u) => (u.startsWith("users/") ? u : `users/${u}`));
+        const entry = await withSpinner(`Writing ${opts.key}...`, () => request("PATCH", entryPath(opts, opts.key), {
+            query: { allowMissing: true },
+            json: { value, users, attributes: opts.attributes },
+        }));
+        output(entry, () => {
+            success(`Set ${pc.cyan(opts.key)} in ${pc.cyan(opts.datastore)}`);
+            field("Revision", entry?.revisionId);
+        });
+    });
+    ds.command("increment")
+        .description("atomically increment a numeric entry")
+        .addOption(universeOption())
+        .addOption(datastoreOption())
+        .addOption(keyOption())
+        .addOption(scopeOption())
+        .option("--by <amount>", "amount to increment by (can be negative)", parseNumber, 1)
+        .action(async (opts) => {
+        const entry = await withSpinner(`Incrementing ${opts.key}...`, () => request("POST", `${entryPath(opts, opts.key)}:increment`, { json: { amount: opts.by } }));
+        output(entry, () => success(`${pc.cyan(opts.key)} is now ${pc.bold(formatValue(entry?.value))}`));
+    });
+    ds.command("delete")
+        .description("permanently delete an entry (interactive confirmation required)")
+        .addOption(universeOption())
+        .addOption(datastoreOption())
+        .addOption(keyOption())
+        .addOption(scopeOption())
+        .addHelpText("after", `\n${AI_WARNING}`)
+        .action(async (opts) => {
+        const where = `${opts.datastore}${opts.scope ? ` (scope ${opts.scope})` : ""} in universe ${opts.universe}`;
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new CliError(`Refusing to delete: \`raven datastore delete\` must be confirmed interactively in a terminal.\n\n${AI_WARNING}`);
+        }
+        console.error();
+        console.error(pc.bgRed(pc.white(pc.bold(" DANGER "))) + pc.red(pc.bold(" This action cannot be undone.")));
+        console.error();
+        console.error(`This will permanently delete the key ${pc.bold(opts.key)} from ${pc.bold(where)}.`);
+        console.error("Any player data or game state stored under this key will be lost.");
+        console.error();
+        console.error(pc.yellow(AI_WARNING));
+        console.error();
+        const typed = await input({ message: `To confirm, type the data store name ${pc.bold(`"${opts.datastore}"`)}:` });
+        if (typed !== opts.datastore) {
+            throw new CliError("Data store name did not match. Nothing was deleted.");
+        }
+        await withSpinner(`Deleting ${opts.key}...`, () => request("DELETE", entryPath(opts, opts.key)));
+        output({ deleted: opts.key, datastore: opts.datastore, scope: opts.scope }, () => success(`Deleted ${pc.cyan(opts.key)} from ${pc.cyan(opts.datastore)}`));
+    });
+    return ds;
+}

package/dist/commands/product.js

@@ -0,0 +1,242 @@
+import { Command, InvalidArgumentError, Option } from "commander";
+import pc from "picocolors";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { request } from "../lib/api.js";
+import { parseId, parsePositiveInt, universeOption } 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";
+/** The game pass and developer product APIs are near-identical; these are the parts that differ. */
+const TYPES = {
+    gamepass: {
+        label: "game pass",
+        base: (u) => `/game-passes/v1/universes/${u}/game-passes`,
+        idField: "gamePassId",
+        iconField: "iconAssetId",
+        listField: "gamePasses",
+        createIconField: "imageFile",
+        updateIconField: "file",
+        url: (id) => `https://www.roblox.com/game-pass/${id}`,
+    },
+    devProduct: {
+        label: "developer product",
+        base: (u) => `/developer-products/v2/universes/${u}/developer-products`,
+        idField: "productId",
+        iconField: "iconImageAssetId",
+        listField: "developerProducts",
+        createIconField: "imageFile",
+        updateIconField: "imageFile",
+    },
+};
+const TYPE_ALIASES = {
+    gamepass: "gamepass",
+    "game-pass": "gamepass",
+    pass: "gamepass",
+    devproduct: "devProduct",
+    "dev-product": "devProduct",
+    developerproduct: "devProduct",
+    "developer-product": "devProduct",
+    product: "devProduct",
+};
+function parseType(value) {
+    const type = TYPE_ALIASES[value.toLowerCase()];
+    if (!type)
+        throw new InvalidArgumentError("Expected `gamepass` or `devProduct`.");
+    return type;
+}
+function typeOption() {
+    return new Option("-t, --type <type>", "product type")
+        .choices(["gamepass", "devProduct"])
+        .argParser(parseType)
+        .makeOptionMandatory();
+}
+const IMAGE_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".bmp": "image/bmp",
+    ".tga": "image/tga",
+};
+async function readIcon(path) {
+    const type = IMAGE_TYPES[extname(path).toLowerCase()];
+    if (!type)
+        throw new CliError(`Icons must be one of: ${Object.keys(IMAGE_TYPES).join(", ")}`);
+    try {
+        return new Blob([await readFile(path)], { type });
+    }
+    catch (err) {
+        throw new CliError(`Could not read ${path}: ${err.message}`);
+    }
+}
+/** Maps a raw API response onto the shared Product shape. */
+function normalize(type, raw) {
+    const t = TYPES[type];
+    return { ...raw, id: raw[t.idField], iconAssetId: raw[t.iconField] };
+}
+async function getProduct(type, universe, id) {
+    return normalize(type, await request("GET", `${TYPES[type].base(universe)}/${id}/creator`));
+}
+function price(p) {
+    const robux = p.priceInformation?.defaultPriceInRobux;
+    return robux == null ? "not set" : `R$${robux}`;
+}
+function managedPricing(p) {
+    return p.priceInformation?.enabledFeatures?.includes("RegionalPricing") ?? false;
+}
+function printProduct(type, p) {
+    field("ID", p.id);
+    field("Type", TYPES[type].label);
+    field("Name", p.name);
+    field("Description", p.description);
+    field("Price", price(p));
+    field("Status", p.isForSale ? pc.green("on sale") : pc.yellow("off sale"));
+    field("Managed price", managedPricing(p) ? "on" : "off");
+    field("Icon asset", p.iconAssetId || undefined);
+    field("Updated", p.updatedTimestamp);
+    if (TYPES[type].url)
+        field("URL", pc.underline(TYPES[type].url(p.id)));
+}
+async function buildForm(opts, iconField) {
+    if (opts.onsale && opts.offsale)
+        throw new CliError("Pass only one of --onsale or --offsale.");
+    const form = new FormData();
+    if (opts.name !== undefined)
+        form.append("name", opts.name);
+    if (opts.description !== undefined)
+        form.append("description", opts.description);
+    if (opts.price !== undefined)
+        form.append("price", String(opts.price));
+    if (opts.onsale)
+        form.append("isForSale", "true");
+    if (opts.offsale)
+        form.append("isForSale", "false");
+    if (opts.managedPricing !== undefined)
+        form.append("isRegionalPricingEnabled", String(opts.managedPricing));
+    if (opts.icon)
+        form.append(iconField, await readIcon(opts.icon), basename(opts.icon));
+    return form;
+}
+async function updateAndFetch(type, universe, id, form) {
+    await request("PATCH", `${TYPES[type].base(universe)}/${id}`, { body: form });
+    return getProduct(type, universe, id);
+}
+function managedPricingOptions(cmd) {
+    return cmd
+        .option("--managed-pricing", "turn on managed (regional) pricing")
+        .option("--no-managed-pricing", "turn off managed (regional) pricing");
+}
+export function productCommand() {
+    const product = new Command("product")
+        .description("create and manage game passes and developer products")
+        .addHelpText("after", `
+Every subcommand needs --type gamepass or --type devProduct.
+${examples(["raven product add -t gamepass -u 123 --name VIP --price 100 --icon vip.png"], ["raven product add -t devProduct -u 123 --name Coins --price 25 --managed-pricing"], ["raven product update -t devProduct -u 123 --id 456 --no-managed-pricing"], ["raven product disable -t gamepass -u 123 --id 456", "take off sale"], ["raven product list -t devProduct -u 123"])}`);
+    managedPricingOptions(product
+        .command("add")
+        .description("create a new game pass or developer product")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .requiredOption("--name <name>", "product name")
+        .option("--description <text>", "product description")
+        .option("--price <robux>", "price in Robux (puts it on sale unless --offsale is given)", parsePositiveInt)
+        .option("--icon <file>", "icon image (.png, .jpg, .bmp, .tga)")
+        .option("--offsale", "create it without putting it on sale")).action(async (opts) => {
+        const t = TYPES[opts.type];
+        const form = await buildForm({ ...opts, onsale: opts.price !== undefined && !opts.offsale }, t.createIconField);
+        const created = await withSpinner(`Creating ${t.label} ${opts.name}...`, async () => normalize(opts.type, await request("POST", t.base(opts.universe), { body: form })));
+        output(created, () => {
+            success(`Created ${t.label} ${pc.cyan(created.name)}`);
+            printProduct(opts.type, created);
+        });
+    });
+    managedPricingOptions(product
+        .command("update")
+        .description("update a game pass or developer product")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .requiredOption("--id <id>", "game pass or developer product ID", parseId)
+        .option("--name <name>", "new name")
+        .option("--description <text>", "new description")
+        .option("--price <robux>", "new price in Robux", parsePositiveInt)
+        .option("--icon <file>", "new icon image (.png, .jpg, .bmp, .tga)")
+        .option("--onsale", "put it on sale")
+        .option("--offsale", "take it off sale")).action(async (opts) => {
+        const t = TYPES[opts.type];
+        const form = await buildForm(opts, t.updateIconField);
+        if ([...form.keys()].length === 0) {
+            throw new CliError("Nothing to update. Pass at least one of --name, --description, --price, --icon, --onsale, --offsale, or --[no-]managed-pricing.");
+        }
+        const updated = await withSpinner(`Updating ${t.label} ${opts.id}...`, () => updateAndFetch(opts.type, opts.universe, opts.id, form));
+        output(updated, () => {
+            success(`Updated ${t.label} ${pc.cyan(updated.name)}`);
+            printProduct(opts.type, updated);
+        });
+    });
+    product
+        .command("disable")
+        .alias("offsale")
+        .description("take a game pass or developer product off sale (they can't be deleted)")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .requiredOption("--id <id>", "game pass or developer product ID", parseId)
+        .action(async (opts) => {
+        const t = TYPES[opts.type];
+        const updated = await withSpinner(`Disabling ${t.label} ${opts.id}...`, async () => updateAndFetch(opts.type, opts.universe, opts.id, await buildForm({ offsale: true }, t.updateIconField)));
+        output(updated, () => success(`${pc.cyan(updated.name)} is now off sale.`));
+    });
+    product
+        .command("enable")
+        .alias("onsale")
+        .description("put a game pass or developer product back on sale")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .requiredOption("--id <id>", "game pass or developer product ID", parseId)
+        .option("--price <robux>", "price in Robux (required if it has no price yet)", parsePositiveInt)
+        .action(async (opts) => {
+        const t = TYPES[opts.type];
+        const updated = await withSpinner(`Enabling ${t.label} ${opts.id}...`, async () => updateAndFetch(opts.type, opts.universe, opts.id, await buildForm({ onsale: true, price: opts.price }, t.updateIconField)));
+        output(updated, () => success(`${pc.cyan(updated.name)} is now on sale for ${price(updated)}.`));
+    });
+    product
+        .command("get")
+        .description("show a game pass or developer product")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .requiredOption("--id <id>", "game pass or developer product ID", parseId)
+        .action(async (opts) => {
+        const p = await withSpinner(`Fetching ${TYPES[opts.type].label} ${opts.id}...`, () => getProduct(opts.type, opts.universe, opts.id));
+        output(p, () => printProduct(opts.type, p));
+    });
+    product
+        .command("list")
+        .description("list game passes or developer products in an experience")
+        .addOption(typeOption())
+        .addOption(universeOption())
+        .option("--limit <n>", "maximum number of results", parsePositiveInt, 100)
+        .action(async (opts) => {
+        const t = TYPES[opts.type];
+        const items = await withSpinner(`Fetching ${t.label}s...`, async () => {
+            const items = [];
+            let pageToken;
+            do {
+                const page = await request("GET", `${t.base(opts.universe)}/creator`, {
+                    query: { pageSize: Math.min(opts.limit - items.length, 100), pageToken },
+                });
+                items.push(...(page[t.listField] ?? []).map((raw) => normalize(opts.type, raw)));
+                pageToken = page.nextPageToken || undefined;
+            } while (pageToken && items.length < opts.limit);
+            return items.slice(0, opts.limit);
+        });
+        output(items, () => {
+            if (!items.length)
+                return console.log(`No ${t.label}s found.`);
+            for (const p of items) {
+                const status = p.isForSale ? pc.green(price(p)) : pc.yellow("off sale");
+                const managed = managedPricing(p) ? pc.dim(" managed") : "";
+                console.log(`${pc.dim(String(p.id).padEnd(14))} ${p.name}  ${status}${managed}`);
+            }
+        });
+    });
+    return product;
+}

package/dist/commands/publish.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { request } from "../lib/api.js";
+import { placeOption, universeOption } 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 CONTENT_TYPES = {
+    ".rbxl": "application/octet-stream",
+    ".rbxlx": "application/xml",
+};
+export function publishCommand() {
+    return new Command("publish")
+        .description("publish a place file to an experience")
+        .requiredOption("--path <file>", "place file (.rbxl or .rbxlx)")
+        .addOption(universeOption())
+        .addOption(placeOption())
+        .option("--saved", "save the version without publishing it live")
+        .addHelpText("after", examples(["raven publish --path game.rbxlx --universe 123 --place 456"], ["raven publish --path game.rbxl -u 123 -p 456 --saved", "save without going live"]))
+        .action(async (opts) => {
+        const contentType = CONTENT_TYPES[extname(opts.path).toLowerCase()];
+        if (!contentType)
+            throw new CliError("Place files must be .rbxl or .rbxlx.");
+        let file;
+        try {
+            file = await readFile(opts.path);
+        }
+        catch (err) {
+            throw new CliError(`Could not read ${opts.path}: ${err.message}`);
+        }
+        const versionType = opts.saved ? "Saved" : "Published";
+        const result = await withSpinner(`${opts.saved ? "Saving" : "Publishing"} ${basename(opts.path)}...`, () => request("POST", `/universes/v1/${opts.universe}/places/${opts.place}/versions`, {
+            query: { versionType },
+            body: new Uint8Array(file),
+            headers: { "content-type": contentType },
+        }));
+        output(result, () => {
+            success(`${opts.saved ? "Saved" : "Published"} ${pc.cyan(basename(opts.path))} as version ${pc.bold(String(result.versionNumber))}`);
+            field("Universe", opts.universe);
+            field("Place", opts.place);
+            field("URL", pc.underline(`https://www.roblox.com/games/${opts.place}`));
+        });
+    });
+}

package/dist/commands/server.js

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { confirm } from "@inquirer/prompts";
+import pc from "picocolors";
+import { request } from "../lib/api.js";
+import { universeOption } from "../lib/args.js";
+import { CliError } from "../lib/config.js";
+import { examples } from "../lib/help.js";
+import { output, success, withSpinner } from "../lib/output.js";
+export function serverCommand() {
+    const server = new Command("server")
+        .description("restart servers and message them")
+        .addHelpText("after", examples(["raven server restart --universe 123"], [`raven server message -u 123 --topic Announcements --message "Restarting soon"`]));
+    server
+        .command("restart")
+        .description("restart all servers running an outdated version of the experience")
+        .addOption(universeOption())
+        .option("-y, --yes", "skip the confirmation prompt")
+        .action(async (opts) => {
+        if (!opts.yes) {
+            if (!process.stdin.isTTY)
+                throw new CliError("Refusing to restart servers without --yes in a non-interactive shell.");
+            const ok = await confirm({
+                message: `Restart servers for universe ${opts.universe}? Players will be disconnected.`,
+                default: false,
+            });
+            if (!ok)
+                return console.log(pc.dim("Cancelled."));
+        }
+        await withSpinner("Restarting servers...", () => request("POST", `/cloud/v2/universes/${opts.universe}:restartServers`, { json: {} }));
+        output({ restarted: true, universe: opts.universe }, () => success(`Restarting servers for universe ${pc.cyan(opts.universe)}`));
+    });
+    server
+        .command("message")
+        .description("publish a message to live servers via MessagingService")
+        .addOption(universeOption())
+        .requiredOption("-t, --topic <topic>", "MessagingService topic")
+        .requiredOption("-m, --message <message>", "message to send")
+        .action(async (opts) => {
+        await withSpinner(`Publishing to ${opts.topic}...`, () => request("POST", `/cloud/v2/universes/${opts.universe}:publishMessage`, {
+            json: { topic: opts.topic, message: opts.message },
+        }));
+        output({ published: true, topic: opts.topic }, () => success(`Published message to ${pc.cyan(opts.topic)}`));
+    });
+    return server;
+}

package/dist/commands/update.js

@@ -0,0 +1,93 @@
+import { Command } from "commander";
+import pc from "picocolors";
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CliError } from "../lib/config.js";
+import { examples } from "../lib/help.js";
+import { info, success, withSpinner } from "../lib/output.js";
+const REPO = "twistedsignal/raven";
+const PACKAGE_JSON_URL = `https://raw.githubusercontent.com/${REPO}/main/package.json`;
+const TARBALL_URL = `https://github.com/${REPO}/archive/refs/heads/main.tar.gz`;
+async function latestVersion() {
+    let res;
+    try {
+        res = await fetch(PACKAGE_JSON_URL, { headers: { "cache-control": "no-cache" } });
+    }
+    catch (err) {
+        throw new CliError(`Couldn't reach GitHub: ${err.message}`);
+    }
+    if (!res.ok)
+        throw new CliError(`Couldn't check for updates (GitHub returned ${res.status}).`);
+    return (await res.json()).version;
+}
+/** Returns >0 if a is newer than b. */
+function compareVersions(a, b) {
+    const pa = a.split(/[.-]/).map(Number);
+    const pb = b.split(/[.-]/).map(Number);
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] || 0) - (pb[i] || 0);
+        if (diff)
+            return diff;
+    }
+    return 0;
+}
+/** The directory Raven is installed in (the package root). */
+function installRoot() {
+    return dirname(dirname(dirname(realpathSync(fileURLToPath(import.meta.url)))));
+}
+/** Picks the install command matching the package manager Raven was installed with. */
+function installCommand(root) {
+    if (/[\\/]\.?pnpm[\\/]/.test(root))
+        return ["pnpm", ["add", "-g", TARBALL_URL]];
+    if (/[\\/]\.bun[\\/]/.test(root))
+        return ["bun", ["add", "-g", TARBALL_URL]];
+    return ["npm", ["install", "-g", TARBALL_URL]];
+}
+function run(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: "inherit", shell: process.platform === "win32" });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+export function updateCommand(version) {
+    return new Command("update")
+        .description("update Raven to the latest version")
+        .option("--check", "only check whether an update is available")
+        .option("-f, --force", "reinstall even if already up to date")
+        .addHelpText("after", examples(["raven update"], ["raven update --check", "just check, don't install"]))
+        .action(async (opts) => {
+        const root = installRoot();
+        if (existsSync(join(root, ".git"))) {
+            throw new CliError(`Raven is running from a git checkout (${root}).\nUpdate it with: git pull && pnpm install && pnpm build`);
+        }
+        const latest = await withSpinner("Checking for updates...", latestVersion);
+        const newer = compareVersions(latest, version) > 0;
+        if (!newer && !opts.force) {
+            success(`Raven is up to date (v${version}).`);
+            return;
+        }
+        if (opts.check) {
+            info(`Update available: ${pc.dim(`v${version}`)} → ${pc.green(`v${latest}`)}. Run ${pc.cyan("raven update")} to install it.`);
+            return;
+        }
+        const [cmd, args] = installCommand(root);
+        info(newer ? `Updating Raven ${pc.dim(`v${version}`)} → ${pc.green(`v${latest}`)}...` : `Reinstalling Raven v${latest}...`);
+        info(pc.dim(`$ ${cmd} ${args.join(" ")}`));
+        info("");
+        let code;
+        try {
+            code = await run(cmd, args);
+        }
+        catch (err) {
+            throw new CliError(`Couldn't run ${cmd}: ${err.message}`);
+        }
+        if (code !== 0) {
+            throw new CliError(`Update failed (${cmd} exited with code ${code}). If it's a permissions error, try running it with sudo or fix your npm prefix.`);
+        }
+        info("");
+        success(`Raven updated to v${latest}.`);
+    });
+}