@evcraddock/slug-cli 0.2.0

package/dist/commands.js

@@ -0,0 +1,2184 @@
+import { readFileSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, basename, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { x as extractTarball } from "tar";
+import { readConfig, setConfigApiBaseUrl, setConfigApiKey, toDisplayConfig, writeConfig, } from "./config.js";
+import { CliError, createInvalidUsageError, ExitCode } from "./errors.js";
+import { SlugHttpClient } from "./http.js";
+import { writeJson } from "./output.js";
+const HELP_TEXT = `slug - manage Slugkit sites
+
+Usage:
+  slug [--config <file>] --help
+  slug [--config <file>] --version
+  slug [--config <file>] version [--json]
+  slug [--config <file>] doctor [--json]
+  slug [--config <file>] login
+  slug [--config <file>] init <directory> --name <name> [--site-title <title>] [--template-url <url>] [--template-dir <dir>] [--json]
+  slug [--config <file>] post list [--type article|link|note] [--status draft|published|all] [--tag <slug>] [--json]
+  slug [--config <file>] post show <slug> [--json]
+  slug [--config <file>] post create --type article|link|note --slug <slug> --content <text> [--title <text>] [--url <url>] [--excerpt <text>] [--tag <slug>]... [--source-id <id>] [--author-id <id>]... [--json]
+  slug [--config <file>] post edit <slug> [--slug <new-slug>] [--title <text>] [--content <text>] [--url <url>] [--excerpt <text>] [--tag <slug>]... [--source-id <id>] [--author-id <id>]... [--json]
+  slug [--config <file>] post delete <slug> [--json]
+  slug [--config <file>] post publish <slug> [--json]
+  slug [--config <file>] post unpublish <slug> [--json]
+  slug [--config <file>] comment list [--post <slug>] [--status pending|approved|hidden|all] [--json]
+  slug [--config <file>] comment approve <id> [--json]
+  slug [--config <file>] comment hide <id> [--json]
+  slug [--config <file>] comments create <post-slug> --content <text> [--json]
+  slug [--config <file>] media upload <file> [--alt <text>] [--key <key>] [--json]
+  slug [--config <file>] media show <id> [--json]
+  slug [--config <file>] media delete <id> [--json]
+  slug [--config <file>] tag list [--json]
+  slug [--config <file>] sources list [--json]
+  slug [--config <file>] sources show <id> [--json]
+  slug [--config <file>] sources create --name <name> [--url <url>] [--description <text>] [--image-url <url>] [--favicon-url <url>] [--contact-id <id>]... [--json]
+  slug [--config <file>] sources edit <id> [--name <name>] [--url <url>] [--description <text>] [--image-url <url>] [--favicon-url <url>] [--contact-id <id>]... [--json]
+  slug [--config <file>] sources delete <id> [--json]
+  slug [--config <file>] accounts list [--owner-type contact|source|site] [--owner-id <id>] [--json]
+  slug [--config <file>] accounts show <id> [--json]
+  slug [--config <file>] accounts create --owner-type contact|source|site [--owner-id <id>] --label <label> --url <url> [--avatar-url <url>] [--kind <kind>] [--protocol <protocol>] [--default] [--sort-order <number>] [--json]
+  slug [--config <file>] accounts edit <id> [--label <label>] [--url <url>] [--avatar-url <url>] [--kind <kind>] [--protocol <protocol>] [--default] [--sort-order <number>] [--json]
+  slug [--config <file>] accounts delete <id> [--json]
+  slug [--config <file>] followers list [--json]
+  slug [--config <file>] engagement summary --post <slug> [--json]
+  slug [--config <file>] engagement list --post <slug> --type like|boost [--json]
+  slug [--config <file>] following list [--json]
+  slug [--config <file>] following follow <target> [--json]
+  slug [--config <file>] following unfollow <id> [--json]
+  slug [--config <file>] contact list [--json]
+  slug [--config <file>] contact show <id> [--json]
+  slug [--config <file>] contact create --name <name> [--url <url>] [--json]
+  slug [--config <file>] contact edit <id> [--name <name>] [--url <url>] [--json]
+  slug [--config <file>] contact delete <id> [--json]
+  slug [--config <file>] site config show [--json]
+  slug [--config <file>] site config set <field> <value> [--json]
+  slug [--config <file>] config show [--json]
+  slug [--config <file>] config set api-base-url <url>
+  slug [--config <file>] config set api-key <key>
+
+Options:
+  --config <file>  Use a specific YAML config file.
+  --help           Show this help.
+  --version        Show the CLI version.
+  --json           Print command output as JSON when supported.`;
+export async function runCommand(context) {
+    const args = context.args;
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        context.writer.stdout(HELP_TEXT);
+        return { exitCode: ExitCode.Ok };
+    }
+    if (args[0] === "--version") {
+        context.writer.stdout(`slug ${context.packageVersion}`);
+        return { exitCode: ExitCode.Ok };
+    }
+    switch (args[0]) {
+        case "version":
+            return runVersionCommand(context, args.slice(1));
+        case "doctor":
+            return runDoctorCommand(context, args.slice(1));
+        case "login":
+            return runLoginCommand(context, args.slice(1));
+        case "init":
+            return runInitCommand(context, args.slice(1));
+        case "post":
+            return runPostsCommand(context, args.slice(1));
+        case "comment":
+            return runCommentCommand(context, args.slice(1));
+        case "comments":
+            return runCommentsCommand(context, args.slice(1));
+        case "media":
+            return runMediaCommand(context, args.slice(1));
+        case "tag":
+            return runTagsCommand(context, args.slice(1));
+        case "sources":
+            return runSourcesCommand(context, args.slice(1));
+        case "accounts":
+            return runAccountsCommand(context, args.slice(1));
+        case "followers":
+            return runFollowersCommand(context, args.slice(1));
+        case "engagement":
+            return runEngagementCommand(context, args.slice(1));
+        case "following":
+            return runFollowingCommand(context, args.slice(1));
+        case "contact":
+            return runContactCommand(context, args.slice(1));
+        case "site":
+            return runSiteCommand(context, args.slice(1));
+        case "config":
+            return runConfigCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError(`Unknown command: ${args[0]}`);
+    }
+}
+async function runVersionCommand(context, args) {
+    const json = readJsonFlag(args);
+    if (json) {
+        writeJson(context.writer, { version: context.packageVersion });
+    }
+    else {
+        context.writer.stdout(`slug ${context.packageVersion}`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+const SUPPORTED_API_MAJOR_VERSION = 1;
+const SITE_TEMPLATE_PACKAGE_NAME = "@slugkit/template-site";
+const SITE_TEMPLATE_RELEASE_BASE_URL = "https://forge.caradoc.com/erik/slugkit/releases/download";
+const INIT_HELP_TEXT = `slug init - create a standalone Slugkit-compatible website
+
+Usage:
+  slug init <directory> --name <name> [--site-title <title>] [--template-url <url>] [--template-dir <dir>] [--json]
+
+Options:
+  --name <name>          npm package name for the generated site.
+  --site-title <title>   Human-readable site title. Defaults to a title derived from --name.
+  --template-url <url>   Download a template tarball from a custom URL.
+  --template-dir <dir>   Copy a template from a local directory.
+  --json                 Print command output as JSON.
+  --help, -h             Show this help.
+
+By default, slug init uses the repository-local template/site directory when available.
+Installed CLI releases download the versioned template asset that matches the CLI version.`;
+const SITE_INIT_NEXT_STEPS = [
+    "Install dependencies",
+    "Copy and edit .env",
+    "Run migrations",
+    "Start the dev server",
+    "Create an API key",
+    "Configure ActivityPub domain and actor settings",
+    "Configure slug and run slug doctor",
+];
+const TEMPLATE_COPY_EXCLUDES = new Set([
+    ".env",
+    "node_modules",
+    "dist",
+    "build",
+    "data",
+    "coverage",
+]);
+async function runInitCommand(context, args) {
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        context.writer.stdout(INIT_HELP_TEXT);
+        return { exitCode: ExitCode.Ok };
+    }
+    const options = parseInitArgs(args);
+    const targetDirectory = resolve(options.directory);
+    const templateSource = await resolveInitTemplateSource(context, options);
+    try {
+        await assertDirectoryIsMissingOrEmpty(targetDirectory);
+        await mkdir(targetDirectory, { recursive: true });
+        await copyTemplateSite(templateSource.directory, targetDirectory);
+        await replaceGeneratedSitePlaceholders(targetDirectory, options);
+        await writeGeneratedSiteMarker(targetDirectory, options);
+    }
+    finally {
+        await templateSource.cleanup?.();
+    }
+    const data = {
+        directory: options.directory,
+        name: options.name,
+        siteTitle: options.siteTitle,
+        nextSteps: SITE_INIT_NEXT_STEPS,
+    };
+    if (options.json) {
+        writeJson(context.writer, { data });
+    }
+    else {
+        context.writer.stdout(`Created Slugkit site: ${options.directory}`);
+        context.writer.stdout(`Package name: ${options.name}`);
+        context.writer.stdout(`Site title: ${options.siteTitle}`);
+        context.writer.stdout("Next steps:");
+        for (const step of SITE_INIT_NEXT_STEPS) {
+            context.writer.stdout(`- ${step}`);
+        }
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseInitArgs(args) {
+    let directory;
+    let name;
+    let siteTitle;
+    let templateUrl;
+    let templateDir;
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--name") {
+            name = readRequiredInitOptionValue(args, index, "name");
+            index += 1;
+            continue;
+        }
+        if (arg === "--site-title") {
+            siteTitle = readRequiredInitOptionValue(args, index, "site-title");
+            index += 1;
+            continue;
+        }
+        if (arg === "--template-url") {
+            templateUrl = readRequiredInitOptionValue(args, index, "template-url");
+            index += 1;
+            continue;
+        }
+        if (arg === "--template-dir") {
+            templateDir = readRequiredInitOptionValue(args, index, "template-dir");
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported option: ${arg}`);
+        }
+        if (directory !== undefined || arg === undefined) {
+            throw createInvalidUsageError("Usage: slug init <directory> --name <name> [--site-title <title>] [--template-url <url>] [--template-dir <dir>] [--json]");
+        }
+        directory = arg;
+    }
+    if (directory === undefined || name === undefined) {
+        throw createInvalidUsageError("Usage: slug init <directory> --name <name> [--site-title <title>] [--template-url <url>] [--template-dir <dir>] [--json]");
+    }
+    const normalizedName = name.trim();
+    validatePackageName(normalizedName);
+    if (templateUrl !== undefined && templateDir !== undefined) {
+        throw createInvalidUsageError("Use only one of --template-url or --template-dir");
+    }
+    return {
+        directory,
+        name: normalizedName,
+        siteTitle: siteTitle?.trim() || humanizePackageName(normalizedName),
+        json,
+        templateUrl: templateUrl?.trim() || undefined,
+        templateDir: templateDir?.trim() || undefined,
+    };
+}
+function readRequiredInitOptionValue(args, index, name) {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) {
+        throw createInvalidUsageError(`Option --${name} requires a value`);
+    }
+    return value;
+}
+function validatePackageName(name) {
+    if (name === "" || name.length > 214) {
+        throw createInvalidUsageError("--name must be a valid npm package name");
+    }
+    const packageNamePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*|[a-z0-9][a-z0-9._-]*)$/u;
+    if (!packageNamePattern.test(name) || name.includes("..")) {
+        throw createInvalidUsageError("--name must be a valid npm package name");
+    }
+}
+function humanizePackageName(name) {
+    const unscoped = name.includes("/") ? (name.split("/").at(-1) ?? name) : name;
+    return unscoped
+        .replace(/[._-]+/gu, " ")
+        .trim()
+        .replace(/\b\w/gu, (letter) => letter.toUpperCase());
+}
+async function assertDirectoryIsMissingOrEmpty(directory) {
+    try {
+        const stats = await stat(directory);
+        if (!stats.isDirectory()) {
+            throw createInvalidUsageError(`Target path is not a directory: ${directory}`);
+        }
+        const entries = await readdir(directory);
+        if (entries.length > 0) {
+            throw createInvalidUsageError(`Target directory is not empty: ${directory}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        if (isNodeErrorWithCode(error, "ENOENT")) {
+            return;
+        }
+        throw createInvalidUsageError(`Cannot inspect target directory: ${directory}`);
+    }
+}
+async function copyTemplateSite(source, destination) {
+    const entries = await readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+        if (shouldExcludeTemplateEntry(entry.name)) {
+            continue;
+        }
+        const sourcePath = join(source, entry.name);
+        const destinationPath = join(destination, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(destinationPath, { recursive: true });
+            await copyTemplateSite(sourcePath, destinationPath);
+            continue;
+        }
+        if (entry.isFile()) {
+            await mkdir(dirname(destinationPath), { recursive: true });
+            await writeFile(destinationPath, await readFile(sourcePath));
+        }
+    }
+}
+function shouldExcludeTemplateEntry(name) {
+    return TEMPLATE_COPY_EXCLUDES.has(name) || name.endsWith(".log") || name.endsWith(".tsbuildinfo");
+}
+async function replaceGeneratedSitePlaceholders(directory, options) {
+    await updateJsonFile(join(directory, "package.json"), (value) => ({
+        ...value,
+        name: options.name,
+    }));
+    await replaceTextFile(join(directory, "src", "config", "site.ts"), [
+        ['name: "slugkit"', `name: ${JSON.stringify(options.siteTitle)}`],
+        [
+            'intro: "A personal website starter with feeds, posts, and federation in mind."',
+            `intro: ${JSON.stringify(`${options.siteTitle} is ready for posts, feeds, and federation.`)}`,
+        ],
+    ]);
+    await replaceTextFile(join(directory, "README.md"), [
+        ["# Slugkit Template Site", `# ${options.siteTitle}`],
+        [
+            "This is the in-repo Slugkit template website. It is used for local CLI/API testing and is the source directory that future `slug init` work should copy into standalone site projects.\n\nGenerated sites should contain this website code, not the `slug` CLI source code.",
+            "This is a standalone Slugkit-compatible website generated from the Slugkit template. This site owns its code and can be customized freely while preserving the Slugkit API contract.",
+        ],
+        [
+            "From the repository root:\n\n```bash\nmake dev\n```\n\nFrom this directory:\n\n```bash\nnpm run dev\n```",
+            "From this generated site directory:\n\n```bash\nnpm run dev\n```",
+        ],
+        [
+            "Run migrations from the repository root:",
+            "Run migrations from this generated site directory:",
+        ],
+        ["npm run db:migrate --workspace @slugkit/template-site", "npm run db:migrate"],
+        ["npm run db:status --workspace @slugkit/template-site", "npm run db:status"],
+        [
+            "In repository-local development, run `make garage-setup` once from the repository root to create the local Garage bucket/key and fill the secret values below before normal `make dev` use.",
+            "For local media development, configure these values for a local or remote S3-compatible service before uploading media.",
+        ],
+    ]);
+}
+async function updateJsonFile(path, update) {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    await writeFile(path, `${JSON.stringify(update(value), null, 2)}\n`, "utf8");
+}
+async function replaceTextFile(path, replacements) {
+    let content = await readFile(path, "utf8");
+    for (const [search, replacement] of replacements) {
+        content = content.replace(search, replacement);
+    }
+    await writeFile(path, content, "utf8");
+}
+async function writeGeneratedSiteMarker(directory, options) {
+    const marker = {
+        slugkitSite: true,
+        name: options.name,
+        siteTitle: options.siteTitle,
+        template: "slugkit/template-site",
+        generatedAt: new Date().toISOString(),
+    };
+    await writeFile(join(directory, ".slugkit-site.json"), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+}
+async function resolveInitTemplateSource(context, options) {
+    if (options.templateDir !== undefined) {
+        const directory = resolve(options.templateDir);
+        await assertTemplateSiteDirectory(directory);
+        return { directory };
+    }
+    if (options.templateUrl !== undefined) {
+        return downloadTemplateSite(context, options.templateUrl);
+    }
+    const localTemplateDirectory = findTemplateSiteDirectory(context.templateSiteDirectory);
+    if (localTemplateDirectory !== undefined) {
+        return { directory: localTemplateDirectory };
+    }
+    return downloadTemplateSite(context, getDefaultTemplateAssetUrl(context));
+}
+function getDefaultTemplateAssetUrl(context) {
+    const version = context.packageVersion.trim().replace(/^v/, "");
+    const baseUrl = context.templateAssetBaseUrl ?? SITE_TEMPLATE_RELEASE_BASE_URL;
+    const assetName = getTemplateAssetName(version);
+    return `${baseUrl.replace(/\/$/u, "")}/v${encodeURIComponent(version)}/${encodeURIComponent(assetName)}`;
+}
+function getTemplateAssetName(version) {
+    return `slugkit-site-template-v${version}.tgz`;
+}
+async function downloadTemplateSite(context, templateUrl) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(templateUrl);
+    }
+    catch {
+        throw createInvalidUsageError(`Invalid template URL: ${templateUrl}`);
+    }
+    if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") {
+        throw createInvalidUsageError("Template URL must use http or https");
+    }
+    const fetchImpl = context.fetchImpl ?? fetch;
+    const response = await fetchImpl(parsedUrl);
+    if (!response.ok) {
+        throw new CliError(`Failed to download Slugkit template from ${parsedUrl.toString()}: HTTP ${response.status}`, ExitCode.NetworkError);
+    }
+    const tempDirectory = await mkdtemp(join(tmpdir(), "slug-template-"));
+    const archivePath = join(tempDirectory, "template.tgz");
+    const extractDirectory = join(tempDirectory, "template");
+    await mkdir(extractDirectory, { recursive: true });
+    await writeFile(archivePath, Buffer.from(await response.arrayBuffer()));
+    await extractTarball({ file: archivePath, cwd: extractDirectory });
+    await assertTemplateSiteDirectory(extractDirectory);
+    return {
+        directory: extractDirectory,
+        cleanup: () => rm(tempDirectory, { force: true, recursive: true }),
+    };
+}
+async function assertTemplateSiteDirectory(directory) {
+    try {
+        const packageJson = JSON.parse(await readFile(join(directory, "package.json"), "utf8"));
+        if (packageJson.name !== SITE_TEMPLATE_PACKAGE_NAME) {
+            throw createInvalidUsageError(`Template directory is not a Slugkit site template: ${directory}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw createInvalidUsageError(`Template directory is not readable: ${directory}`);
+    }
+}
+function findTemplateSiteDirectory(templateSiteDirectory) {
+    if (templateSiteDirectory !== undefined) {
+        if (templateSiteDirectory === null) {
+            return undefined;
+        }
+        return templateSiteDirectory;
+    }
+    const commandsDirectory = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(commandsDirectory, "..", "..", "template", "site"),
+        resolve(process.cwd(), "template", "site"),
+        resolve(process.cwd(), "..", "template", "site"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const packageJson = JSON.parse(readFileSync(join(candidate, "package.json"), "utf8"));
+            if (packageJson.name === SITE_TEMPLATE_PACKAGE_NAME) {
+                return candidate;
+            }
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return undefined;
+}
+function isNodeErrorWithCode(error, code) {
+    return isRecord(error) && error.code === code;
+}
+async function runDoctorCommand(context, args) {
+    const json = readJsonFlag(args);
+    const config = await readConfig(context.configPath);
+    const checks = [];
+    if (config.apiBaseUrl === undefined || config.apiBaseUrl.trim() === "") {
+        checks.push({ name: "config", status: "fail", message: "apiBaseUrl is not configured" });
+        return finishDoctor(context, { ok: false, checks }, json, ExitCode.InvalidUsage);
+    }
+    const apiBaseUrl = normalizeUrl(config.apiBaseUrl);
+    checks.push({ name: "config", status: "pass", message: `apiBaseUrl: ${apiBaseUrl}` });
+    const health = await requestDoctorJson(context, apiBaseUrl, "/health");
+    checks.push(createHealthCheck(health));
+    const meta = await requestDoctorJson(context, apiBaseUrl, "/meta");
+    checks.push(createMetaCheck(meta));
+    const openapi = await requestDoctorJson(context, apiBaseUrl, "/openapi.json");
+    checks.push(createOpenApiCheck(openapi));
+    if (config.apiKey === undefined || config.apiKey.trim() === "") {
+        checks.push({ name: "auth", status: "warn", message: "apiKey is not configured" });
+    }
+    else {
+        const auth = await requestDoctorJson(context, apiBaseUrl, "/auth/check", config.apiKey);
+        checks.push(createAuthCheck(auth));
+    }
+    const result = { ok: checks.every((check) => check.status !== "fail"), checks };
+    return finishDoctor(context, result, json, getDoctorExitCode(checks));
+}
+function finishDoctor(context, result, json, exitCode) {
+    if (json) {
+        writeJson(context.writer, result);
+    }
+    else {
+        context.writer.stdout(`Slug doctor: ${result.ok ? "ok" : "failed"}`);
+        for (const check of result.checks) {
+            const suffix = check.message === undefined ? "" : ` - ${check.message}`;
+            context.writer.stdout(`${check.status} ${check.name}${suffix}`);
+        }
+    }
+    return { exitCode };
+}
+async function requestDoctorJson(context, apiBaseUrl, path, apiKey) {
+    const fetchImpl = context.fetchImpl ?? fetch;
+    let response;
+    try {
+        response = await fetchImpl(`${apiBaseUrl}${path}`, {
+            headers: createDoctorHeaders(apiKey),
+        });
+    }
+    catch {
+        return { ok: false, kind: "network", message: "Network request failed" };
+    }
+    const data = await readResponseJson(response);
+    const apiMessage = readApiErrorMessage(data);
+    if (response.status === 501) {
+        return {
+            ok: false,
+            kind: "notImplemented",
+            message: apiMessage ?? "This site does not implement this operation.",
+        };
+    }
+    if (response.status === 401 || response.status === 403) {
+        return { ok: false, kind: "auth", message: apiMessage ?? "Authentication failed" };
+    }
+    if (!response.ok) {
+        return {
+            ok: false,
+            kind: "api",
+            message: apiMessage ?? `API request failed with status ${response.status}`,
+        };
+    }
+    return { ok: true, data };
+}
+function createDoctorHeaders(apiKey) {
+    const headers = { accept: "application/json" };
+    if (apiKey !== undefined) {
+        headers.authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+}
+async function readResponseJson(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function createHealthCheck(result) {
+    if (!result.ok) {
+        return { name: "health", status: "fail", message: result.message };
+    }
+    if (!isRecord(result.data) || result.data.status !== "ok") {
+        return { name: "health", status: "fail", message: "Health response is invalid" };
+    }
+    return { name: "health", status: "pass", message: "API is reachable" };
+}
+function createMetaCheck(result) {
+    if (!result.ok) {
+        return { name: "meta", status: "fail", message: result.message };
+    }
+    if (!isMetaDocument(result.data)) {
+        return { name: "meta", status: "fail", message: "Metadata response is invalid" };
+    }
+    if (result.data.api.name !== "slugkit") {
+        return { name: "meta", status: "fail", message: "API name is not slugkit" };
+    }
+    if (readMajorVersion(result.data.api.version) !== SUPPORTED_API_MAJOR_VERSION) {
+        return {
+            name: "meta",
+            status: "fail",
+            message: `API version ${result.data.api.version} is not compatible`,
+        };
+    }
+    return { name: "meta", status: "pass", message: `API version ${result.data.api.version}` };
+}
+function createOpenApiCheck(result) {
+    if (!result.ok) {
+        return { name: "openapi", status: "fail", message: result.message };
+    }
+    if (!isOpenApiDocument(result.data)) {
+        return { name: "openapi", status: "fail", message: "OpenAPI document is invalid" };
+    }
+    const document = result.data;
+    const missingPath = ["/health", "/meta", "/openapi.json", "/auth/check"].find((path) => !(path in document.paths));
+    if (missingPath !== undefined) {
+        return { name: "openapi", status: "fail", message: `OpenAPI is missing ${missingPath}` };
+    }
+    return { name: "openapi", status: "pass", message: `OpenAPI ${document.openapi}` };
+}
+function createAuthCheck(result) {
+    if (!result.ok) {
+        return { name: "auth", status: "fail", message: result.message };
+    }
+    if (!isRecord(result.data) ||
+        !isRecord(result.data.data) ||
+        result.data.data.authenticated !== true) {
+        return { name: "auth", status: "fail", message: "Authentication check response is invalid" };
+    }
+    return { name: "auth", status: "pass", message: "API key is valid" };
+}
+function getDoctorExitCode(checks) {
+    const failedChecks = checks.filter((check) => check.status === "fail");
+    if (failedChecks.length === 0) {
+        return ExitCode.Ok;
+    }
+    if (failedChecks.some((check) => check.name === "auth")) {
+        return ExitCode.AuthenticationError;
+    }
+    if (failedChecks.some((check) => check.message === "Network request failed")) {
+        return ExitCode.NetworkError;
+    }
+    return ExitCode.ApiError;
+}
+function isMetaDocument(value) {
+    return (isRecord(value) &&
+        isRecord(value.api) &&
+        typeof value.api.name === "string" &&
+        typeof value.api.version === "string" &&
+        typeof value.api.baseUrl === "string" &&
+        typeof value.api.openapiUrl === "string");
+}
+function isOpenApiDocument(value) {
+    return (isRecord(value) &&
+        typeof value.openapi === "string" &&
+        isRecord(value.info) &&
+        typeof value.info.version === "string" &&
+        isRecord(value.paths));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readMajorVersion(value) {
+    const major = Number.parseInt(value.split(".")[0] ?? "", 10);
+    return Number.isInteger(major) ? major : undefined;
+}
+function readApiErrorMessage(value) {
+    if (!isRecord(value) || !isRecord(value.error) || typeof value.error.message !== "string") {
+        return undefined;
+    }
+    return value.error.message;
+}
+async function runLoginCommand(context, args) {
+    if (args.length > 1) {
+        throw createInvalidUsageError("Usage: slug login [api-base-url]");
+    }
+    const config = await readConfig(context.configPath);
+    const apiBaseUrl = normalizeUrl(args[0] ?? config.apiBaseUrl ?? (await promptForValue(context, "API base URL: ")));
+    const authUrl = createBrowserAuthUrl(apiBaseUrl);
+    context.writer.stdout("Open this URL to create an API key:");
+    context.writer.stdout(authUrl);
+    if (context.openUrl !== undefined) {
+        try {
+            await context.openUrl(authUrl);
+        }
+        catch {
+            context.writer.stdout("Could not open a browser automatically.");
+        }
+    }
+    const apiKey = (await promptForValue(context, "API key: ")).trim();
+    if (apiKey === "") {
+        throw createInvalidUsageError("API key is required");
+    }
+    const client = new SlugHttpClient({
+        apiBaseUrl,
+        apiKey,
+        fetchImpl: context.fetchImpl,
+    });
+    await client.requestJson({ path: "/auth/check" });
+    await writeConfig(context.configPath, setConfigApiKey(setConfigApiBaseUrl(config, apiBaseUrl), apiKey));
+    context.writer.stdout("Login successful. API key saved.");
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runPostsListCommand(context, args.slice(1));
+        case "show":
+            return runPostsShowCommand(context, args.slice(1));
+        case "create":
+            return runPostsCreateCommand(context, args.slice(1));
+        case "edit":
+            return runPostsEditCommand(context, args.slice(1));
+        case "delete":
+            return runPostsDeleteCommand(context, args.slice(1));
+        case "publish":
+            return runPostsLifecycleCommand(context, args.slice(1), "publish");
+        case "unpublish":
+            return runPostsLifecycleCommand(context, args.slice(1), "unpublish");
+        default:
+            throw createInvalidUsageError("Usage: slug post <list|show|create|edit|delete|publish|unpublish>");
+    }
+}
+async function runPostsListCommand(context, args) {
+    const parsed = parsePostFlags(args, ["type", "status", "tag"]);
+    const api = await createConfiguredApiContext(context);
+    const query = new URLSearchParams();
+    addOptionalQuery(query, "type", parsed.options.type);
+    addOptionalQuery(query, "status", parsed.options.status);
+    addOptionalQuery(query, "tag", parsed.options.tag);
+    const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+    const response = await api.client.requestJson({ path: `/posts${suffix}` });
+    if (parsed.json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writePostList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsShowCommand(context, args) {
+    const { slug, json } = readSlugCommandArgs(args, "Usage: slug post show <slug> [--json]");
+    const api = await createConfiguredApiContext(context);
+    const response = await api.client.requestJson({
+        path: `/posts/${encodeURIComponent(slug)}`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writePost(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsCreateCommand(context, args) {
+    const parsed = parsePostFlags(args, [
+        "type",
+        "slug",
+        "content",
+        "title",
+        "url",
+        "excerpt",
+        "tag",
+        "source-id",
+        "author-id",
+    ]);
+    const body = createPostMutationInput(parsed.options, true);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/posts",
+        body,
+    });
+    writePostMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsEditCommand(context, args) {
+    const slug = args[0];
+    if (slug === undefined || slug.startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug post edit <slug> [options]");
+    }
+    const parsed = parsePostFlags(args.slice(1), [
+        "slug",
+        "content",
+        "title",
+        "url",
+        "excerpt",
+        "tag",
+        "source-id",
+        "author-id",
+    ]);
+    const body = createPostMutationInput(parsed.options, false);
+    if (Object.keys(body).length === 0) {
+        throw createInvalidUsageError("At least one edit option is required");
+    }
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "PUT",
+        path: `/posts/${encodeURIComponent(slug)}`,
+        body,
+    });
+    writePostMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsDeleteCommand(context, args) {
+    const { slug, json } = readSlugCommandArgs(args, "Usage: slug post delete <slug> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    await api.client.requestVoid({ method: "DELETE", path: `/posts/${encodeURIComponent(slug)}` });
+    if (json) {
+        writeJson(context.writer, { data: { slug, deleted: true } });
+    }
+    else {
+        context.writer.stdout(`Deleted post ${slug}.`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runPostsLifecycleCommand(context, args, action) {
+    const { slug, json } = readSlugCommandArgs(args, `Usage: slug post ${action} <slug> [--json]`);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: `/posts/${encodeURIComponent(slug)}/${action}`,
+    });
+    writePostMutationOutput(context.writer, response, json);
+    return { exitCode: ExitCode.Ok };
+}
+function parsePostFlags(args, allowed) {
+    const options = {};
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === undefined || !arg.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported argument: ${arg ?? ""}`.trim());
+        }
+        const key = arg.slice(2);
+        const value = args[index + 1];
+        if (!allowed.includes(key)) {
+            throw createInvalidUsageError(`Unsupported option: --${key}`);
+        }
+        if (value === undefined || value.startsWith("--")) {
+            throw createInvalidUsageError(`Option --${key} requires a value`);
+        }
+        if (key === "tag" || key === "author-id") {
+            const current = options[key];
+            options[key] = [...(Array.isArray(current) ? current : []), value];
+        }
+        else {
+            options[key] = value;
+        }
+        index += 1;
+    }
+    return { json, options };
+}
+function createPostMutationInput(options, requireCreateFields) {
+    const input = {};
+    copyStringOption(options, input, "type", "type");
+    copyStringOption(options, input, "slug", "slug");
+    copyStringOption(options, input, "title", "title");
+    copyStringOption(options, input, "content", "content");
+    copyStringOption(options, input, "url", "url");
+    copyStringOption(options, input, "excerpt", "excerpt");
+    copyNumberOption(options, input, "source-id", "sourceId");
+    if (Array.isArray(options.tag)) {
+        input.tagSlugs = options.tag;
+    }
+    if (Array.isArray(options["author-id"])) {
+        input.authorIds = options["author-id"].map((value) => readPositiveInteger(value, "author-id"));
+    }
+    if (requireCreateFields) {
+        for (const key of ["type", "slug", "content"]) {
+            if (typeof options[key] !== "string") {
+                throw createInvalidUsageError(`Missing required option: --${key}`);
+            }
+        }
+    }
+    return input;
+}
+function copyStringOption(options, input, optionKey, inputKey) {
+    if (typeof options[optionKey] === "string") {
+        input[inputKey] = options[optionKey];
+    }
+}
+function copyNumberOption(options, input, optionKey, inputKey) {
+    if (typeof options[optionKey] === "string") {
+        input[inputKey] = readPositiveInteger(options[optionKey], optionKey);
+    }
+}
+function readPositiveInteger(value, optionName) {
+    const integer = Number.parseInt(value, 10);
+    if (!Number.isInteger(integer) || integer.toString() !== value || integer < 1) {
+        throw createInvalidUsageError(`--${optionName} must be a positive integer`);
+    }
+    return integer;
+}
+function readSlugCommandArgs(args, usage) {
+    const json = args.includes("--json");
+    const positional = args.filter((arg) => arg !== "--json");
+    if (positional.length !== 1 || positional[0] === undefined || positional[0].startsWith("--")) {
+        throw createInvalidUsageError(usage);
+    }
+    return { slug: positional[0], json };
+}
+function addOptionalQuery(query, key, value) {
+    if (typeof value === "string") {
+        query.set(key, value);
+    }
+    else if (Array.isArray(value) && value[0] !== undefined) {
+        query.set(key, value[0]);
+    }
+}
+function writePostList(writer, posts) {
+    if (posts.length === 0) {
+        writer.stdout("No posts found.");
+        return;
+    }
+    for (const post of posts) {
+        writer.stdout(`${post.slug} • ${post.type} • ${post.title ?? "(untitled)"} • ${post.publishedAt ?? "draft"}`);
+    }
+}
+function writePost(writer, post) {
+    writer.stdout(`slug: ${post.slug}`);
+    writer.stdout(`type: ${post.type}`);
+    writer.stdout(`title: ${post.title ?? ""}`);
+    writer.stdout(`publishedAt: ${post.publishedAt ?? "draft"}`);
+}
+function writePostMutationOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writer.stdout(`Post ${response.data.slug}: ${response.data.type} (${response.data.publishedAt ?? "draft"})`);
+    }
+}
+function writeMutationTarget(writer, apiBaseUrl, json) {
+    if (!json) {
+        writer.stdout(`Target: ${apiBaseUrl}`);
+    }
+}
+async function runCommentCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runCommentListCommand(context, args.slice(1));
+        case "approve":
+            return runCommentModerationCommand(context, args.slice(1), "approve");
+        case "hide":
+            return runCommentModerationCommand(context, args.slice(1), "hide");
+        default:
+            throw createInvalidUsageError("Usage: slug comment <list|approve|hide>");
+    }
+}
+async function runCommentListCommand(context, args) {
+    const parsed = parseCommentListFlags(args);
+    const client = await createConfiguredClient(context);
+    const query = new URLSearchParams();
+    addOptionalQuery(query, "status", parsed.options.status);
+    const path = parsed.options.post === undefined
+        ? `/comments?${createCommentStatusQuery(parsed.options.status)}`
+        : `/posts/${encodeURIComponent(parsed.options.post)}/comments${query.size === 0 ? "" : `?${query.toString()}`}`;
+    const response = await client.requestJson({ path });
+    if (parsed.json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeCommentList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runCommentModerationCommand(context, args, action) {
+    const { id, json } = readIdCommandArgs(args, `Usage: slug comment ${action} <id> [--json]`);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: `/comments/${encodeURIComponent(id.toString())}/${action}`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        context.writer.stdout(`Comment ${response.data.id}: ${response.data.moderationStatus}`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseCommentListFlags(args) {
+    const parsed = parsePostFlags(args, ["post", "status"]);
+    const post = readOptionalStringOption(parsed.options, "post");
+    const status = readOptionalCommentStatus(parsed.options.status);
+    return { json: parsed.json, options: { post, status } };
+}
+function readOptionalStringOption(options, key) {
+    const value = options[key];
+    return typeof value === "string" ? value : undefined;
+}
+function readOptionalCommentStatus(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "pending" || value === "approved" || value === "hidden" || value === "all") {
+        return value;
+    }
+    throw createInvalidUsageError("--status must be pending, approved, hidden, or all");
+}
+function createCommentStatusQuery(status) {
+    const query = new URLSearchParams({ status: status ?? "pending" });
+    return query.toString();
+}
+function writeCommentList(writer, comments) {
+    if (comments.length === 0) {
+        writer.stdout("No comments found.");
+        return;
+    }
+    for (const comment of comments) {
+        writer.stdout(`${comment.id} • ${comment.postSlug} • ${comment.authorName} • ${comment.moderationStatus} • ${comment.contentText}`);
+    }
+}
+async function runCommentsCommand(context, args) {
+    switch (args[0]) {
+        case "create":
+            return runCommentsCreateCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug comments create <post-slug> --content <text> [--json]");
+    }
+}
+async function runCommentsCreateCommand(context, args) {
+    const slug = args[0];
+    if (slug === undefined || slug.startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug comments create <post-slug> --content <text> [--json]");
+    }
+    const parsed = parseCommentCreateFlags(args.slice(1));
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: `/posts/${encodeURIComponent(slug)}/comments`,
+        body: { content: parsed.content },
+    });
+    writeCommentMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+function parseCommentCreateFlags(args) {
+    const parsed = parsePostFlags(args, ["content"]);
+    const content = parsed.options.content;
+    if (typeof content !== "string") {
+        throw createInvalidUsageError("Missing required option: --content");
+    }
+    return { content, json: parsed.json };
+}
+function writeCommentMutationOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writer.stdout(`Comment ${response.data.id} on ${response.data.postSlug}: ${response.data.moderationStatus}`);
+    }
+}
+async function runMediaCommand(context, args) {
+    switch (args[0]) {
+        case "upload":
+            return runMediaUploadCommand(context, args.slice(1));
+        case "show":
+            return runMediaShowCommand(context, args.slice(1));
+        case "delete":
+            return runMediaDeleteCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug media <upload|show|delete>");
+    }
+}
+async function runMediaUploadCommand(context, args) {
+    const parsed = parseMediaUploadFlags(args);
+    const file = await readMediaUploadFile(parsed.file);
+    const fileBody = file.body.buffer.slice(file.body.byteOffset, file.body.byteOffset + file.body.byteLength);
+    const body = new FormData();
+    body.set("file", new File([fileBody], file.filename, { type: file.mimeType }));
+    if (parsed.altText !== undefined)
+        body.set("altText", parsed.altText);
+    if (parsed.key !== undefined)
+        body.set("key", parsed.key);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/media",
+        body,
+    });
+    writeMediaOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runMediaShowCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug media show <id> [--json]");
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/media/${encodeURIComponent(id.toString())}`,
+    });
+    writeMediaOutput(context.writer, response, json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runMediaDeleteCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug media delete <id> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    await api.client.requestVoid({
+        method: "DELETE",
+        path: `/media/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, { data: { id, deleted: true } });
+    }
+    else {
+        context.writer.stdout(`Deleted media ${id}.`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseMediaUploadFlags(args) {
+    let json = false;
+    let altText;
+    let key;
+    const positional = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--alt" || arg === "--key") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                throw createInvalidUsageError(`Option ${arg} requires a value`);
+            }
+            if (arg === "--alt") {
+                altText = value;
+            }
+            else {
+                key = value;
+            }
+            index += 1;
+            continue;
+        }
+        if (arg === undefined || arg.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported option: ${arg ?? ""}`.trim());
+        }
+        positional.push(arg);
+    }
+    if (positional.length !== 1 || positional[0] === undefined) {
+        throw createInvalidUsageError("Usage: slug media upload <file> [--alt <text>] [--key <key>] [--json]");
+    }
+    return { file: positional[0], altText, key, json };
+}
+async function readMediaUploadFile(filePath) {
+    try {
+        const stats = await stat(filePath);
+        if (!stats.isFile()) {
+            throw createInvalidUsageError(`Media upload path is not a file: ${filePath}`);
+        }
+        return {
+            filename: basename(filePath),
+            mimeType: inferMimeType(filePath),
+            body: await readFile(filePath),
+        };
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        throw createInvalidUsageError(`Cannot read media file: ${filePath}`);
+    }
+}
+function inferMimeType(filePath) {
+    switch (extname(filePath).toLowerCase()) {
+        case ".avif":
+            return "image/avif";
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".webp":
+            return "image/webp";
+        case ".mp4":
+            return "video/mp4";
+        case ".webm":
+            return "video/webm";
+        case ".mp3":
+            return "audio/mpeg";
+        case ".wav":
+            return "audio/wav";
+        default:
+            return "application/octet-stream";
+    }
+}
+function writeMediaOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writeMedia(writer, response.data);
+    }
+}
+function writeMedia(writer, media) {
+    writer.stdout(`id: ${media.id}`);
+    writer.stdout(`filename: ${media.filename}`);
+    writer.stdout(`mimeType: ${media.mimeType}`);
+    writer.stdout(`key: ${media.key}`);
+    writer.stdout(`altText: ${media.altText ?? ""}`);
+    writer.stdout(`url: ${media.url}`);
+    if (media.createdAt !== undefined)
+        writer.stdout(`createdAt: ${media.createdAt}`);
+}
+async function runTagsCommand(context, args) {
+    if (args[0] !== "list") {
+        throw createInvalidUsageError("Usage: slug tag list [--json]");
+    }
+    const json = readJsonFlag(args.slice(1));
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/tags" });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeTagList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function writeTagList(writer, tags) {
+    if (tags.length === 0) {
+        writer.stdout("No tags found.");
+        return;
+    }
+    for (const tag of tags) {
+        writer.stdout(`${tag.slug} • ${tag.name} • ${tag.count}`);
+    }
+}
+async function runSourcesCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runSourcesListCommand(context, args.slice(1));
+        case "show":
+            return runSourcesShowCommand(context, args.slice(1));
+        case "create":
+            return runSourcesCreateCommand(context, args.slice(1));
+        case "edit":
+            return runSourcesEditCommand(context, args.slice(1));
+        case "delete":
+            return runSourcesDeleteCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug sources <list|show|create|edit|delete>");
+    }
+}
+async function runSourcesListCommand(context, args) {
+    const json = readJsonFlag(args);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/sources" });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeSourceList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runSourcesShowCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug sources show <id> [--json]");
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/sources/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeSource(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runSourcesCreateCommand(context, args) {
+    const parsed = parseSourceFlags(args);
+    const body = createSourceMutationInput(parsed.options, true);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/sources",
+        body,
+    });
+    writeSourceMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runSourcesEditCommand(context, args) {
+    const idArg = args[0];
+    if (idArg === undefined || idArg.startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug sources edit <id> [options]");
+    }
+    const id = readPositiveInteger(idArg, "id");
+    const parsed = parseSourceFlags(args.slice(1));
+    const body = createSourceMutationInput(parsed.options, false);
+    if (Object.keys(body).length === 0) {
+        throw createInvalidUsageError("At least one edit option is required");
+    }
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "PUT",
+        path: `/sources/${encodeURIComponent(id.toString())}`,
+        body,
+    });
+    writeSourceMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runSourcesDeleteCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug sources delete <id> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    await api.client.requestVoid({
+        method: "DELETE",
+        path: `/sources/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, { data: { id, deleted: true } });
+    }
+    else {
+        context.writer.stdout(`Deleted source ${id}.`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseSourceFlags(args) {
+    const options = {};
+    let json = false;
+    const allowed = ["name", "url", "description", "image-url", "favicon-url", "contact-id"];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === undefined || !arg.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported argument: ${arg ?? ""}`.trim());
+        }
+        const key = arg.slice(2);
+        const value = args[index + 1];
+        if (!allowed.includes(key)) {
+            throw createInvalidUsageError(`Unsupported option: --${key}`);
+        }
+        if (value === undefined || value.startsWith("--")) {
+            throw createInvalidUsageError(`Option --${key} requires a value`);
+        }
+        if (key === "contact-id") {
+            const current = options[key];
+            options[key] = [...(Array.isArray(current) ? current : []), value];
+        }
+        else {
+            options[key] = value;
+        }
+        index += 1;
+    }
+    return { json, options };
+}
+function createSourceMutationInput(options, requireName) {
+    const input = {};
+    copySourceStringOption(options, input, "name", "name");
+    copySourceStringOption(options, input, "url", "url");
+    copySourceStringOption(options, input, "description", "description");
+    copySourceStringOption(options, input, "image-url", "imageUrl");
+    copySourceStringOption(options, input, "favicon-url", "faviconUrl");
+    if (Array.isArray(options["contact-id"])) {
+        input.contactIds = options["contact-id"].map((value) => readPositiveInteger(value, "contact-id"));
+    }
+    if (requireName && typeof options.name !== "string") {
+        throw createInvalidUsageError("Missing required option: --name");
+    }
+    return input;
+}
+function copySourceStringOption(options, input, optionKey, inputKey) {
+    if (typeof options[optionKey] === "string") {
+        input[inputKey] = options[optionKey];
+    }
+}
+function writeSourceList(writer, sources) {
+    if (sources.length === 0) {
+        writer.stdout("No sources found.");
+        return;
+    }
+    for (const source of sources) {
+        writer.stdout(`${source.id} • ${source.name} • ${source.url ?? ""} • ${source.contacts?.length ?? 0} contacts • ${source.accounts?.length ?? 0} accounts`);
+    }
+}
+function writeSource(writer, source) {
+    writer.stdout(`id: ${source.id}`);
+    writer.stdout(`name: ${source.name}`);
+    writer.stdout(`url: ${source.url ?? ""}`);
+    writer.stdout(`description: ${source.description ?? ""}`);
+    writer.stdout(`imageUrl: ${source.imageUrl ?? ""}`);
+    writer.stdout(`faviconUrl: ${source.faviconUrl ?? ""}`);
+    if (source.contacts !== undefined && source.contacts.length > 0) {
+        writer.stdout("contacts:");
+        for (const contact of source.contacts) {
+            writer.stdout(`- ${contact.id} • ${contact.name} • ${contact.url ?? ""}`);
+        }
+    }
+    if (source.accounts !== undefined && source.accounts.length > 0) {
+        writer.stdout("accounts:");
+        for (const account of source.accounts) {
+            writer.stdout(`- ${formatAccountSummary(account)}`);
+        }
+    }
+}
+function writeSourceMutationOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writer.stdout(`Source ${response.data.id}: ${response.data.name}`);
+    }
+}
+async function runAccountsCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runAccountsListCommand(context, args.slice(1));
+        case "show":
+            return runAccountsShowCommand(context, args.slice(1));
+        case "create":
+            return runAccountsCreateCommand(context, args.slice(1));
+        case "edit":
+            return runAccountsEditCommand(context, args.slice(1));
+        case "delete":
+            return runAccountsDeleteCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug accounts <list|show|create|edit|delete>");
+    }
+}
+async function runAccountsListCommand(context, args) {
+    const parsed = parseAccountFlags(args);
+    const client = await createConfiguredClient(context);
+    const query = new URLSearchParams();
+    addOptionalAccountQuery(query, "ownerType", parsed.options["owner-type"]);
+    addOptionalAccountQuery(query, "ownerId", parsed.options["owner-id"]);
+    const response = await client.requestJson({
+        path: `/accounts${query.size === 0 ? "" : `?${query.toString()}`}`,
+    });
+    if (parsed.json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeAccountList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runAccountsShowCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug accounts show <id> [--json]");
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/accounts/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeAccount(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runAccountsCreateCommand(context, args) {
+    const parsed = parseAccountFlags(args);
+    const body = createAccountMutationInput(parsed.options, true);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/accounts",
+        body,
+    });
+    writeAccountMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runAccountsEditCommand(context, args) {
+    const idArg = args[0];
+    if (idArg === undefined || idArg.startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug accounts edit <id> [options]");
+    }
+    const id = readPositiveInteger(idArg, "id");
+    const parsed = parseAccountFlags(args.slice(1));
+    const body = createAccountMutationInput(parsed.options, false);
+    if (Object.keys(body).length === 0) {
+        throw createInvalidUsageError("At least one edit option is required");
+    }
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "PUT",
+        path: `/accounts/${encodeURIComponent(id.toString())}`,
+        body,
+    });
+    writeAccountMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runAccountsDeleteCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug accounts delete <id> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    await api.client.requestVoid({
+        method: "DELETE",
+        path: `/accounts/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, { data: { id, deleted: true } });
+    }
+    else {
+        context.writer.stdout(`Deleted account ${id}.`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function addOptionalAccountQuery(query, key, value) {
+    if (typeof value === "string") {
+        query.set(key, value);
+    }
+}
+function parseAccountFlags(args) {
+    const options = {};
+    let json = false;
+    const valueOptions = [
+        "owner-type",
+        "owner-id",
+        "label",
+        "url",
+        "avatar-url",
+        "kind",
+        "protocol",
+        "sort-order",
+    ];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--default") {
+            options.default = true;
+            continue;
+        }
+        if (arg === undefined || !arg.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported argument: ${arg ?? ""}`.trim());
+        }
+        const key = arg.slice(2);
+        const value = args[index + 1];
+        if (!valueOptions.includes(key)) {
+            throw createInvalidUsageError(`Unsupported option: --${key}`);
+        }
+        if (value === undefined || value.startsWith("--")) {
+            throw createInvalidUsageError(`Option --${key} requires a value`);
+        }
+        options[key] = value;
+        index += 1;
+    }
+    return { json, options };
+}
+function createAccountMutationInput(options, requireCreateFields) {
+    const input = {};
+    if (typeof options["owner-type"] === "string") {
+        input.ownerType = readAccountOwnerType(options["owner-type"]);
+    }
+    copyAccountStringOption(options, input, "label", "label");
+    copyAccountStringOption(options, input, "url", "url");
+    copyAccountStringOption(options, input, "avatar-url", "avatarUrl");
+    copyAccountStringOption(options, input, "kind", "kind");
+    copyAccountStringOption(options, input, "protocol", "protocol");
+    if (typeof options["owner-id"] === "string") {
+        input.ownerId = readPositiveInteger(options["owner-id"], "owner-id");
+    }
+    if (typeof options["sort-order"] === "string") {
+        input.sortOrder = readInteger(options["sort-order"], "sort-order");
+    }
+    if (options.default === true) {
+        input.isDefault = true;
+    }
+    if (requireCreateFields) {
+        for (const key of ["owner-type", "label", "url"]) {
+            if (typeof options[key] !== "string") {
+                throw createInvalidUsageError(`Missing required option: --${key}`);
+            }
+        }
+    }
+    return input;
+}
+function readAccountOwnerType(value) {
+    if (value === "contact" || value === "source" || value === "site") {
+        return value;
+    }
+    throw createInvalidUsageError("--owner-type must be contact, source, or site");
+}
+function copyAccountStringOption(options, input, optionKey, inputKey) {
+    if (typeof options[optionKey] === "string") {
+        input[inputKey] = options[optionKey];
+    }
+}
+function readInteger(value, optionName) {
+    const integer = Number.parseInt(value, 10);
+    if (!Number.isInteger(integer) || integer.toString() !== value) {
+        throw createInvalidUsageError(`--${optionName} must be an integer`);
+    }
+    return integer;
+}
+function writeAccountList(writer, accounts) {
+    if (accounts.length === 0) {
+        writer.stdout("No accounts found.");
+        return;
+    }
+    for (const account of accounts) {
+        writer.stdout(`${account.id} • ${account.ownerType}${account.ownerId === null ? "" : `:${account.ownerId}`} • ${formatAccountSummary(account)}${account.isDefault ? " • default" : ""}`);
+    }
+}
+function writeAccount(writer, account) {
+    writer.stdout(`id: ${account.id}`);
+    writer.stdout(`ownerType: ${account.ownerType}`);
+    writer.stdout(`ownerId: ${account.ownerId ?? ""}`);
+    writer.stdout(`label: ${account.label}`);
+    writer.stdout(`url: ${account.url}`);
+    writer.stdout(`avatarUrl: ${account.avatarUrl ?? ""}`);
+    writer.stdout(`kind: ${account.kind ?? ""}`);
+    writer.stdout(`protocol: ${account.protocol ?? ""}`);
+    writer.stdout(`isDefault: ${account.isDefault ? "true" : "false"}`);
+    writer.stdout(`sortOrder: ${account.sortOrder}`);
+}
+function writeAccountMutationOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writer.stdout(`Account ${response.data.id}: ${response.data.label}`);
+    }
+}
+async function runFollowersCommand(context, args) {
+    if (args[0] !== "list") {
+        throw createInvalidUsageError("Usage: slug followers list [--json]");
+    }
+    const json = readJsonFlag(args.slice(1));
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/followers" });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeFollowerList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function writeFollowerList(writer, followers) {
+    if (followers.length === 0) {
+        writer.stdout("No followers found.");
+        return;
+    }
+    for (const follower of followers) {
+        const displayName = follower.displayName ?? "";
+        const followedAt = follower.followedAt ?? "";
+        writer.stdout(`${follower.id} • ${follower.handle} • ${displayName} • ${follower.profileUrl} • ${followedAt}`);
+    }
+}
+async function runEngagementCommand(context, args) {
+    switch (args[0]) {
+        case "summary":
+            return runEngagementSummaryCommand(context, args.slice(1));
+        case "list":
+            return runEngagementListCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug engagement <summary|list>");
+    }
+}
+async function runEngagementSummaryCommand(context, args) {
+    const parsed = parseEngagementFlags(args, false);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/posts/${encodeURIComponent(parsed.post)}/engagement`,
+    });
+    if (parsed.json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeEngagementSummary(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runEngagementListCommand(context, args) {
+    const parsed = parseEngagementFlags(args, true);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/posts/${encodeURIComponent(parsed.post)}/${parsed.type === "like" ? "likes" : "boosts"}`,
+    });
+    if (parsed.json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeEngagementActorList(context.writer, response.data, parsed.type);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseEngagementFlags(args, requireType) {
+    let json = false;
+    let post;
+    let type;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg !== "--post" && arg !== "--type") {
+            throw createInvalidUsageError(`Unsupported option: ${arg ?? ""}`.trim());
+        }
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            throw createInvalidUsageError(`Option ${arg} requires a value`);
+        }
+        if (arg === "--post") {
+            post = value;
+        }
+        else {
+            if (value !== "like" && value !== "boost") {
+                throw createInvalidUsageError("--type must be like or boost");
+            }
+            type = value;
+        }
+        index += 1;
+    }
+    if (post === undefined) {
+        throw createInvalidUsageError("Missing required option: --post");
+    }
+    if (requireType && type === undefined) {
+        throw createInvalidUsageError("Missing required option: --type");
+    }
+    return { json, post, type };
+}
+function writeEngagementSummary(writer, summary) {
+    writer.stdout(`post: ${summary.postSlug}`);
+    writer.stdout(`likes: ${summary.likes.count}`);
+    writer.stdout(`boosts: ${summary.boosts.count}`);
+    writer.stdout(`comments: ${summary.comments.count}`);
+    writer.stdout(`pendingComments: ${summary.comments.pendingCount}`);
+}
+function writeEngagementActorList(writer, actors, type) {
+    if (actors.length === 0) {
+        writer.stdout(`No ${type === "boost" ? "boosts" : "likes"} found.`);
+        return;
+    }
+    for (const actor of actors) {
+        writer.stdout(`${actor.handle} • ${actor.displayName} • ${actor.profileUrl} • ${actor.activityUrl} • ${actor.receivedAt}`);
+    }
+}
+async function runFollowingCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runFollowingListCommand(context, args.slice(1));
+        case "follow":
+            return runFollowingFollowCommand(context, args.slice(1));
+        case "unfollow":
+            return runFollowingUnfollowCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug following <list|follow|unfollow>");
+    }
+}
+async function runFollowingListCommand(context, args) {
+    const json = readJsonFlag(args);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/following" });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeFollowingList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runFollowingFollowCommand(context, args) {
+    const { target, json } = readFollowingTargetArgs(args);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/following",
+        body: { target },
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeFollowingMutationOutput(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runFollowingUnfollowCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug following unfollow <id> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: `/following/${encodeURIComponent(id.toString())}/unfollow`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        context.writer.stdout(`Following ${response.data.id}: ${response.data.status}`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function readFollowingTargetArgs(args) {
+    const json = args.includes("--json");
+    const positional = args.filter((arg) => arg !== "--json");
+    if (positional.length !== 1 || positional[0] === undefined || positional[0].startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug following follow <target> [--json]");
+    }
+    return { target: positional[0], json };
+}
+function writeFollowingList(writer, following) {
+    if (following.length === 0) {
+        writer.stdout("No following records found.");
+        return;
+    }
+    for (const record of following) {
+        writer.stdout(formatFollowingRecord(record));
+    }
+}
+function writeFollowingMutationOutput(writer, following) {
+    writer.stdout(`Following ${following.id}: ${following.handle} • ${following.status}`);
+    writer.stdout(`Profile: ${following.profileUrl}`);
+}
+function formatFollowingRecord(record) {
+    const displayName = record.displayName ?? "";
+    return `${record.id} • ${record.handle} • ${displayName} • ${record.status} • ${record.profileUrl}`;
+}
+async function runContactCommand(context, args) {
+    switch (args[0]) {
+        case "list":
+            return runContactListCommand(context, args.slice(1));
+        case "show":
+            return runContactShowCommand(context, args.slice(1));
+        case "create":
+            return runContactCreateCommand(context, args.slice(1));
+        case "edit":
+            return runContactEditCommand(context, args.slice(1));
+        case "delete":
+            return runContactDeleteCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug contact <list|show|create|edit|delete>");
+    }
+}
+async function runContactListCommand(context, args) {
+    const json = readJsonFlag(args);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/contacts" });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeContactList(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runContactShowCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug contact show <id> [--json]");
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        path: `/contacts/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, response);
+    }
+    else {
+        writeContact(context.writer, response.data);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runContactCreateCommand(context, args) {
+    const parsed = parseContactFlags(args);
+    const body = createContactMutationInput(parsed.options, true);
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "POST",
+        path: "/contacts",
+        body,
+    });
+    writeContactMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runContactEditCommand(context, args) {
+    const idArg = args[0];
+    if (idArg === undefined || idArg.startsWith("--")) {
+        throw createInvalidUsageError("Usage: slug contact edit <id> [options]");
+    }
+    const id = readPositiveInteger(idArg, "id");
+    const parsed = parseContactFlags(args.slice(1));
+    const body = createContactMutationInput(parsed.options, false);
+    if (Object.keys(body).length === 0) {
+        throw createInvalidUsageError("At least one edit option is required");
+    }
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, parsed.json);
+    const response = await api.client.requestJson({
+        method: "PUT",
+        path: `/contacts/${encodeURIComponent(id.toString())}`,
+        body,
+    });
+    writeContactMutationOutput(context.writer, response, parsed.json);
+    return { exitCode: ExitCode.Ok };
+}
+async function runContactDeleteCommand(context, args) {
+    const { id, json } = readIdCommandArgs(args, "Usage: slug contact delete <id> [--json]");
+    const api = await createConfiguredApiContext(context);
+    writeMutationTarget(context.writer, api.apiBaseUrl, json);
+    await api.client.requestVoid({
+        method: "DELETE",
+        path: `/contacts/${encodeURIComponent(id.toString())}`,
+    });
+    if (json) {
+        writeJson(context.writer, { data: { id, deleted: true } });
+    }
+    else {
+        context.writer.stdout(`Deleted contact ${id}.`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function parseContactFlags(args) {
+    const options = {};
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === undefined || !arg.startsWith("--")) {
+            throw createInvalidUsageError(`Unsupported argument: ${arg ?? ""}`.trim());
+        }
+        const key = arg.slice(2);
+        const value = args[index + 1];
+        if (!["name", "url", "avatar-url", "description"].includes(key)) {
+            throw createInvalidUsageError(`Unsupported option: --${key}`);
+        }
+        if (value === undefined || value.startsWith("--")) {
+            throw createInvalidUsageError(`Option --${key} requires a value`);
+        }
+        options[key] = value;
+        index += 1;
+    }
+    return { json, options };
+}
+function createContactMutationInput(options, requireName) {
+    const input = {};
+    if (options.name !== undefined)
+        input.name = options.name;
+    if (options.url !== undefined)
+        input.url = options.url;
+    if (options["avatar-url"] !== undefined)
+        input.avatarUrl = options["avatar-url"];
+    if (options.description !== undefined)
+        input.description = options.description;
+    if (requireName && options.name === undefined) {
+        throw createInvalidUsageError("Missing required option: --name");
+    }
+    return input;
+}
+function readIdCommandArgs(args, usage) {
+    const json = args.includes("--json");
+    const positional = args.filter((arg) => arg !== "--json");
+    if (positional.length !== 1 || positional[0] === undefined || positional[0].startsWith("--")) {
+        throw createInvalidUsageError(usage);
+    }
+    return { id: readPositiveInteger(positional[0], "id"), json };
+}
+function writeContactList(writer, contacts) {
+    if (contacts.length === 0) {
+        writer.stdout("No contacts found.");
+        return;
+    }
+    for (const contact of contacts) {
+        const url = contact.url ?? "";
+        const accountSummary = contact.accounts === undefined ? "" : ` • ${contact.accounts.length} accounts`;
+        writer.stdout(`${contact.id} • ${contact.name} • ${url}${accountSummary}`);
+    }
+}
+function writeContact(writer, contact) {
+    writer.stdout(`id: ${contact.id}`);
+    writer.stdout(`name: ${contact.name}`);
+    writer.stdout(`url: ${contact.url ?? ""}`);
+    if (contact.avatarUrl !== undefined)
+        writer.stdout(`avatarUrl: ${contact.avatarUrl ?? ""}`);
+    if (contact.description !== undefined)
+        writer.stdout(`description: ${contact.description ?? ""}`);
+    if (contact.defaultAccount !== undefined && contact.defaultAccount !== null) {
+        writer.stdout(`defaultAccount: ${formatAccountSummary(contact.defaultAccount)}`);
+    }
+    if (contact.accounts !== undefined && contact.accounts.length > 0) {
+        writer.stdout("accounts:");
+        for (const account of contact.accounts) {
+            writer.stdout(`- ${formatAccountSummary(account)}`);
+        }
+    }
+}
+function writeContactMutationOutput(writer, response, json) {
+    if (json) {
+        writeJson(writer, response);
+    }
+    else {
+        writer.stdout(`Contact ${response.data.id}: ${response.data.name}`);
+    }
+}
+function formatAccountSummary(account) {
+    const suffix = [account.kind, account.protocol]
+        .filter((value) => value !== undefined && value !== null)
+        .join("/");
+    return suffix === ""
+        ? `${account.label} <${account.url}>`
+        : `${account.label} <${account.url}> (${suffix})`;
+}
+async function runSiteCommand(context, args) {
+    if (args[0] !== "config") {
+        throw createInvalidUsageError("Usage: slug site config <show|set>");
+    }
+    switch (args[1]) {
+        case "show":
+            return runSiteConfigShowCommand(context, args.slice(2));
+        case "set":
+            return runSiteConfigSetCommand(context, args.slice(2));
+        default:
+            throw createInvalidUsageError("Usage: slug site config <show|set>");
+    }
+}
+async function runSiteConfigShowCommand(context, args) {
+    const json = readJsonFlag(args);
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({ path: "/site-config" });
+    if (json) {
+        writeJson(context.writer, response.data);
+    }
+    else {
+        writeSiteConfig(context.writer, response.data.core);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runSiteConfigSetCommand(context, args) {
+    const json = args[2] === "--json";
+    if (args.length !== (json ? 3 : 2)) {
+        throw createInvalidUsageError("Usage: slug site config set <field> <value> [--json]");
+    }
+    const [field, value] = args;
+    if (field === undefined || value === undefined) {
+        throw createInvalidUsageError("Usage: slug site config set <field> <value> [--json]");
+    }
+    const client = await createConfiguredClient(context);
+    const response = await client.requestJson({
+        method: "PATCH",
+        path: "/site-config",
+        body: createSiteConfigUpdate(field, value),
+    });
+    if (json) {
+        writeJson(context.writer, response.data);
+    }
+    else {
+        context.writer.stdout(`Updated site config ${field}.`);
+        writeSiteConfig(context.writer, response.data.core);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+function createSiteConfigUpdate(field, value) {
+    switch (field) {
+        case "name":
+            return { core: { name: value } };
+        case "url":
+            return { core: { url: value } };
+        case "tagline":
+            return { core: { tagline: value } };
+        case "description":
+            return { core: { description: value } };
+        case "homepage.intro":
+            return { core: { homepage: { intro: value } } };
+        case "homepage.body":
+            return { core: { homepage: { body: value } } };
+        default:
+            throw createInvalidUsageError(`Unknown site config field: ${field}`);
+    }
+}
+function writeSiteConfig(writer, config) {
+    writer.stdout(`name: ${config.name}`);
+    writer.stdout(`url: ${config.url}`);
+    writer.stdout(`tagline: ${config.tagline}`);
+    writer.stdout(`description: ${config.description}`);
+    writer.stdout(`homepage.intro: ${config.homepage.intro}`);
+    writer.stdout(`homepage.body: ${config.homepage.body}`);
+}
+async function createConfiguredClient(context) {
+    return (await createConfiguredApiContext(context)).client;
+}
+async function createConfiguredApiContext(context) {
+    const config = await readConfig(context.configPath);
+    if (config.apiBaseUrl === undefined || config.apiBaseUrl.trim() === "") {
+        throw createInvalidUsageError("apiBaseUrl is not configured");
+    }
+    if (config.apiKey === undefined || config.apiKey.trim() === "") {
+        throw createInvalidUsageError("apiKey is not configured. Run slug login first.");
+    }
+    const apiBaseUrl = normalizeUrl(config.apiBaseUrl);
+    return {
+        apiBaseUrl,
+        client: new SlugHttpClient({
+            apiBaseUrl,
+            apiKey: config.apiKey,
+            fetchImpl: context.fetchImpl,
+        }),
+    };
+}
+async function runConfigCommand(context, args) {
+    switch (args[0]) {
+        case "show":
+            return runConfigShowCommand(context, args.slice(1));
+        case "set":
+            return runConfigSetCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug config <show|set>");
+    }
+}
+async function runConfigShowCommand(context, args) {
+    const json = readJsonFlag(args);
+    const config = await readConfig(context.configPath);
+    const displayConfig = toDisplayConfig(config);
+    if (json) {
+        writeJson(context.writer, displayConfig);
+    }
+    else {
+        context.writer.stdout(`apiBaseUrl: ${displayConfig.apiBaseUrl ?? "not configured"}`);
+        context.writer.stdout(`apiKeyConfigured: ${displayConfig.apiKeyConfigured ? "true" : "false"}`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runConfigSetCommand(context, args) {
+    const key = args[0];
+    const value = args[1];
+    if (key === undefined || value === undefined || args.length !== 2) {
+        throw createInvalidUsageError("Usage: slug config set <api-base-url|api-key> <value>");
+    }
+    const config = await readConfig(context.configPath);
+    switch (key) {
+        case "api-base-url":
+            validateUrl(value);
+            await writeConfig(context.configPath, setConfigApiBaseUrl(config, value));
+            break;
+        case "api-key":
+            await writeConfig(context.configPath, setConfigApiKey(config, value));
+            break;
+        default:
+            throw createInvalidUsageError(`Unknown config key: ${key}`);
+    }
+    context.writer.stdout(`Updated ${key}.`);
+    return { exitCode: ExitCode.Ok };
+}
+function readJsonFlag(args) {
+    if (args.length === 0) {
+        return false;
+    }
+    if (args.length === 1 && args[0] === "--json") {
+        return true;
+    }
+    throw createInvalidUsageError(`Unsupported option: ${args.join(" ")}`);
+}
+async function promptForValue(context, message) {
+    if (context.prompt === undefined) {
+        throw createInvalidUsageError(`${message.replace(/: $/, "")} is required`);
+    }
+    return await context.prompt(message);
+}
+export function createBrowserAuthUrl(apiBaseUrl) {
+    const url = new URL(apiBaseUrl);
+    const normalizedPath = url.pathname.replace(/\/+$/, "");
+    if (normalizedPath.endsWith("/api/v1")) {
+        url.pathname = `${normalizedPath.slice(0, -"/api/v1".length)}/cli/auth`;
+    }
+    else {
+        url.pathname = "/cli/auth";
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+function normalizeUrl(value) {
+    validateUrl(value);
+    return value.replace(/\/+$/, "");
+}
+function validateUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new Error("Unsupported protocol");
+        }
+    }
+    catch {
+        throw createInvalidUsageError("api-base-url must be a valid HTTP or HTTPS URL");
+    }
+}