@evcraddock/slug-cli 0.4.0 → 0.6.0

package/README.md

@@ -29,18 +29,37 @@ Run `slug init --help` for template options. In repository-local development, `s
 
 ## Login and configuration
 
-Run `slug login` to open the site's browser auth flow, paste the generated API key, verify it, and save the config. Use `slug doctor` to check configured site reachability and compatibility. Use `slug --config ./dev.slug.yaml login` to run with a specific config file.
+The CLI stores named Slug API websites. There is no default or current site; API-backed commands require `--site <name>` so the target is explicit.
 
-The CLI stores YAML config at `${XDG_CONFIG_HOME:-~/.config}/slug/config.yaml` by default. Tests and isolated runs can set `SLUG_CONFIG_HOME` to override the config directory. `slug config show` reports whether an API key is configured without printing the key.
+Add a site and API key directly:
 
-Use `slug site config show` to read supported runtime site configuration through the Slugkit API. Use `slug site config set <field> <value>` to update supported fields such as `name`, `url`, `tagline`, `description`, `homepage.intro`, and `homepage.body`.
+```bash
+slug config site add slugkit --api-base-url https://slugkit.com/api/v1 --api-key <key>
+slug --site slugkit doctor
+```
+
+Or use browser-assisted login for a named site:
+
+```bash
+slug --site slugkit login https://slugkit.com/api/v1
+slug --site slugkit doctor
+```
+
+The CLI stores YAML config at `${XDG_CONFIG_HOME:-~/.config}/slug/config.yaml` by default. Tests and isolated runs can set `SLUG_CONFIG_HOME` to override the config directory. `slug config show` and `slug config site list` report whether API keys are configured without printing key values.
+
+Use `slug --site <name> site config show` to read supported runtime site configuration through the Slugkit API. Use `slug --site <name> site config set <field> <value>` to update supported fields such as `name`, `url`, `tagline`, `description`, `homepage.intro`, and `homepage.body`.
 
-Use `slug post list`, `slug post show <slug>`, `slug post create`, `slug post edit <slug>`, `slug post publish <slug>`, `slug post unpublish <slug>`, and `slug post delete <slug>` to manage posts through the Slugkit posts API.
+Use `slug --site <name> post list`, `slug --site <name> post show <slug>`, `slug --site <name> post create`, `slug --site <name> post edit <slug>`, `slug --site <name> post publish <slug>`, `slug --site <name> post unpublish <slug>`, and `slug --site <name> post delete <slug>` to manage posts through the Slugkit posts API.
 
 Use `slug tag list` to list tags and post usage counts through the Slugkit tags API.
 
 Example config:
 
 ```yaml
-apiBaseUrl: https://example.com/api/v1
+sites:
+  slugkit:
+    apiBaseUrl: https://slugkit.com/api/v1
+    apiKey: slug_...
+  testapp:
+    apiBaseUrl: http://localhost:3000/api/v1
 ```

package/dist/commands.d.ts

@@ -3,6 +3,7 @@ import { type OutputWriter } from "./output.js";
 export interface CommandContext {
     args: string[];
     configPath: string;
+    siteName?: string;
     packageVersion: string;
     writer: OutputWriter;
     fetchImpl?: typeof fetch;

package/dist/commands.js

@@ -4,20 +4,20 @@ 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 { isValidSiteName, readConfig, removeConfigSite, setConfigSiteApiBaseUrl, setConfigSiteApiKey, 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>] [--site <name>] --help
+  slug [--config <file>] [--site <name>] --version
+  slug [--config <file>] [--site <name>] version [--json]
+  slug [--config <file>] --site <name> doctor [--json]
+  slug [--config <file>] --site <name> login [api-base-url]
   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>] --site <name> 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>] [--credit-contact-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>] [--credit-contact-id <id>]... [--json]
@@ -53,14 +53,19 @@ Usage:
   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>] --site <name> site config show [--json]
+  slug [--config <file>] --site <name> 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>
+  slug [--config <file>] config site add <name> --api-base-url <url> [--api-key <key>]
+  slug [--config <file>] config site set-api-base-url <name> <url>
+  slug [--config <file>] config site set-api-key <name> <key>
+  slug [--config <file>] config site list [--json]
+  slug [--config <file>] config site show <name> [--json]
+  slug [--config <file>] config site remove <name>
 
 Options:
   --config <file>  Use a specific YAML config file.
+  --site <name>    Target a named configured Slug API website.
   --help           Show this help.
   --version        Show the CLI version.
   --json           Print command output as JSON when supported.`;
@@ -478,12 +483,13 @@ function isNodeErrorWithCode(error, code) {
 }
 async function runDoctorCommand(context, args) {
     const json = readJsonFlag(args);
-    const config = await readConfig(context.configPath);
+    const siteResult = await readDoctorSiteConfig(context);
     const checks = [];
-    if (config.apiBaseUrl === undefined || config.apiBaseUrl.trim() === "") {
-        checks.push({ name: "config", status: "fail", message: "apiBaseUrl is not configured" });
+    if (!siteResult.ok) {
+        checks.push({ name: "config", status: "fail", message: siteResult.message });
         return finishDoctor(context, { ok: false, checks }, json, ExitCode.InvalidUsage);
     }
+    const config = siteResult.site;
     const apiBaseUrl = normalizeUrl(config.apiBaseUrl);
     checks.push({ name: "config", status: "pass", message: `apiBaseUrl: ${apiBaseUrl}` });
     const health = await requestDoctorJson(context, apiBaseUrl, "/health");
@@ -502,6 +508,17 @@ async function runDoctorCommand(context, args) {
     const result = { ok: checks.every((check) => check.status !== "fail"), checks };
     return finishDoctor(context, result, json, getDoctorExitCode(checks));
 }
+async function readDoctorSiteConfig(context) {
+    try {
+        return { ok: true, site: await readSelectedSiteConfig(context) };
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            return { ok: false, message: error.message };
+        }
+        throw error;
+    }
+}
 function finishDoctor(context, result, json, exitCode) {
     if (json) {
         writeJson(context.writer, result);
@@ -658,10 +675,14 @@ function readApiErrorMessage(value) {
 }
 async function runLoginCommand(context, args) {
     if (args.length > 1) {
-        throw createInvalidUsageError("Usage: slug login [api-base-url]");
+        throw createInvalidUsageError("Usage: slug --site <name> login [api-base-url]");
+    }
+    if (context.siteName === undefined || context.siteName.trim() === "") {
+        throw createInvalidUsageError("--site <name> is required for login");
     }
     const config = await readConfig(context.configPath);
-    const apiBaseUrl = normalizeUrl(args[0] ?? config.apiBaseUrl ?? (await promptForValue(context, "API base URL: ")));
+    const configuredSite = config.sites[context.siteName];
+    const apiBaseUrl = normalizeUrl(args[0] ?? configuredSite?.apiBaseUrl ?? (await promptForValue(context, "API base URL: ")));
     const authUrl = createBrowserAuthUrl(apiBaseUrl);
     context.writer.stdout("Open this URL to log in and create an API key:");
     context.writer.stdout(authUrl);
@@ -685,8 +706,9 @@ async function runLoginCommand(context, args) {
         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.");
+    const configWithSite = setConfigSiteApiBaseUrl(config, context.siteName, apiBaseUrl);
+    await writeConfig(context.configPath, setConfigSiteApiKey(configWithSite, context.siteName, apiKey));
+    context.writer.stdout(`Login successful. API key saved for site ${context.siteName}.`);
     return { exitCode: ExitCode.Ok };
 }
 async function runPostsCommand(context, args) {
@@ -2086,31 +2108,44 @@ 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");
+    const site = await readSelectedSiteConfig(context);
+    if (site.apiKey === undefined || site.apiKey.trim() === "") {
+        throw createInvalidUsageError(`apiKey is not configured for site ${context.siteName ?? ""}. Run slug --site <name> login first.`);
     }
-    if (config.apiKey === undefined || config.apiKey.trim() === "") {
-        throw createInvalidUsageError("apiKey is not configured. Run slug login first.");
-    }
-    const apiBaseUrl = normalizeUrl(config.apiBaseUrl);
+    const apiBaseUrl = normalizeUrl(site.apiBaseUrl);
     return {
         apiBaseUrl,
         client: new SlugHttpClient({
             apiBaseUrl,
-            apiKey: config.apiKey,
+            apiKey: site.apiKey,
             fetchImpl: context.fetchImpl,
         }),
     };
 }
+async function readSelectedSiteConfig(context) {
+    if (context.siteName === undefined || context.siteName.trim() === "") {
+        throw createInvalidUsageError("--site <name> is required for this command");
+    }
+    const config = await readConfig(context.configPath);
+    const site = config.sites[context.siteName];
+    if (site === undefined) {
+        const names = Object.keys(config.sites).sort();
+        const suffix = names.length === 0 ? "No sites are configured." : `Configured sites: ${names.join(", ")}`;
+        throw createInvalidUsageError(`Unknown site: ${context.siteName}. ${suffix}`);
+    }
+    if (site.apiBaseUrl.trim() === "") {
+        throw createInvalidUsageError(`apiBaseUrl is not configured for site ${context.siteName}`);
+    }
+    return site;
+}
 async function runConfigCommand(context, args) {
     switch (args[0]) {
         case "show":
             return runConfigShowCommand(context, args.slice(1));
-        case "set":
-            return runConfigSetCommand(context, args.slice(1));
+        case "site":
+            return runConfigSiteCommand(context, args.slice(1));
         default:
-            throw createInvalidUsageError("Usage: slug config <show|set>");
+            throw createInvalidUsageError("Usage: slug config <show|site>");
     }
 }
 async function runConfigShowCommand(context, args) {
@@ -2120,33 +2155,158 @@ async function runConfigShowCommand(context, args) {
     if (json) {
         writeJson(context.writer, displayConfig);
     }
+    else if (displayConfig.sites.length === 0) {
+        context.writer.stdout("No sites configured.");
+    }
     else {
-        context.writer.stdout(`apiBaseUrl: ${displayConfig.apiBaseUrl ?? "not configured"}`);
-        context.writer.stdout(`apiKeyConfigured: ${displayConfig.apiKeyConfigured ? "true" : "false"}`);
+        for (const site of displayConfig.sites) {
+            context.writer.stdout(`${site.name}: ${site.apiBaseUrl} (apiKeyConfigured: ${site.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>");
+async function runConfigSiteCommand(context, args) {
+    switch (args[0]) {
+        case "add":
+            return runConfigSiteAddCommand(context, args.slice(1));
+        case "set-api-base-url":
+            return runConfigSiteSetApiBaseUrlCommand(context, args.slice(1));
+        case "set-api-key":
+            return runConfigSiteSetApiKeyCommand(context, args.slice(1));
+        case "list":
+            return runConfigSiteListCommand(context, args.slice(1));
+        case "show":
+            return runConfigSiteShowCommand(context, args.slice(1));
+        case "remove":
+            return runConfigSiteRemoveCommand(context, args.slice(1));
+        default:
+            throw createInvalidUsageError("Usage: slug config site <add|set-api-base-url|set-api-key|list|show|remove>");
+    }
+}
+async function runConfigSiteAddCommand(context, args) {
+    const name = args[0];
+    if (name === undefined) {
+        throw createInvalidUsageError("Usage: slug config site add <name> --api-base-url <url> [--api-key <key>]");
     }
+    validateSiteName(name);
+    const parsed = parseConfigSiteAddArgs(args.slice(1));
     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}`);
+    let nextConfig = setConfigSiteApiBaseUrl(config, name, parsed.apiBaseUrl);
+    if (parsed.apiKey !== undefined) {
+        nextConfig = setConfigSiteApiKey(nextConfig, name, parsed.apiKey);
     }
-    context.writer.stdout(`Updated ${key}.`);
+    await writeConfig(context.configPath, nextConfig);
+    context.writer.stdout(`Configured site ${name}.`);
     return { exitCode: ExitCode.Ok };
 }
+async function runConfigSiteSetApiBaseUrlCommand(context, args) {
+    const [name, apiBaseUrl] = args;
+    if (name === undefined || apiBaseUrl === undefined || args.length !== 2) {
+        throw createInvalidUsageError("Usage: slug config site set-api-base-url <name> <url>");
+    }
+    validateSiteName(name);
+    validateUrl(apiBaseUrl);
+    const config = await readConfig(context.configPath);
+    await writeConfig(context.configPath, setConfigSiteApiBaseUrl(config, name, apiBaseUrl));
+    context.writer.stdout(`Updated site ${name} api-base-url.`);
+    return { exitCode: ExitCode.Ok };
+}
+async function runConfigSiteSetApiKeyCommand(context, args) {
+    const [name, apiKey] = args;
+    if (name === undefined || apiKey === undefined || args.length !== 2) {
+        throw createInvalidUsageError("Usage: slug config site set-api-key <name> <key>");
+    }
+    validateSiteName(name);
+    const config = await readConfig(context.configPath);
+    if (config.sites[name] === undefined) {
+        throw createInvalidUsageError(`Unknown site: ${name}`);
+    }
+    await writeConfig(context.configPath, setConfigSiteApiKey(config, name, apiKey));
+    context.writer.stdout(`Updated site ${name} api-key.`);
+    return { exitCode: ExitCode.Ok };
+}
+async function runConfigSiteListCommand(context, args) {
+    const json = readJsonFlag(args);
+    const config = await readConfig(context.configPath);
+    const sites = toDisplayConfig(config).sites;
+    if (json) {
+        writeJson(context.writer, { sites });
+    }
+    else if (sites.length === 0) {
+        context.writer.stdout("No sites configured.");
+    }
+    else {
+        for (const site of sites) {
+            context.writer.stdout(`${site.name}: ${site.apiBaseUrl} (apiKeyConfigured: ${site.apiKeyConfigured ? "true" : "false"})`);
+        }
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runConfigSiteShowCommand(context, args) {
+    const json = args.includes("--json");
+    const positional = args.filter((arg) => arg !== "--json");
+    const name = positional[0];
+    if (name === undefined || positional.length !== 1) {
+        throw createInvalidUsageError("Usage: slug config site show <name> [--json]");
+    }
+    const site = toDisplayConfig(await readConfig(context.configPath)).sites.find((candidate) => candidate.name === name);
+    if (site === undefined) {
+        throw createInvalidUsageError(`Unknown site: ${name}`);
+    }
+    if (json) {
+        writeJson(context.writer, site);
+    }
+    else {
+        context.writer.stdout(`name: ${site.name}`);
+        context.writer.stdout(`apiBaseUrl: ${site.apiBaseUrl}`);
+        context.writer.stdout(`apiKeyConfigured: ${site.apiKeyConfigured ? "true" : "false"}`);
+    }
+    return { exitCode: ExitCode.Ok };
+}
+async function runConfigSiteRemoveCommand(context, args) {
+    const name = args[0];
+    if (name === undefined || args.length !== 1) {
+        throw createInvalidUsageError("Usage: slug config site remove <name>");
+    }
+    const config = await readConfig(context.configPath);
+    if (config.sites[name] === undefined) {
+        throw createInvalidUsageError(`Unknown site: ${name}`);
+    }
+    await writeConfig(context.configPath, removeConfigSite(config, name));
+    context.writer.stdout(`Removed site ${name}.`);
+    return { exitCode: ExitCode.Ok };
+}
+function parseConfigSiteAddArgs(args) {
+    let apiBaseUrl;
+    let apiKey;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const value = args[index + 1];
+        if ((arg === "--api-base-url" || arg === "--api-key") &&
+            value !== undefined &&
+            !value.startsWith("--")) {
+            if (arg === "--api-base-url") {
+                apiBaseUrl = value;
+            }
+            else {
+                apiKey = value;
+            }
+            index += 1;
+            continue;
+        }
+        throw createInvalidUsageError("Usage: slug config site add <name> --api-base-url <url> [--api-key <key>]");
+    }
+    if (apiBaseUrl === undefined) {
+        throw createInvalidUsageError("Missing required option: --api-base-url");
+    }
+    validateUrl(apiBaseUrl);
+    return { apiBaseUrl, apiKey };
+}
+function validateSiteName(name) {
+    if (!isValidSiteName(name)) {
+        throw createInvalidUsageError("Site names may contain only letters, numbers, dots, underscores, and hyphens");
+    }
+}
 function readJsonFlag(args) {
     if (args.length === 0) {
         return false;

package/dist/config.d.ts

@@ -1,17 +1,26 @@
-export interface SlugConfig {
-    apiBaseUrl?: string;
+export interface SlugSiteConfig {
+    apiBaseUrl: string;
     apiKey?: string;
     apiKeyReference?: string;
 }
-export interface DisplayConfig {
-    apiBaseUrl?: string;
+export interface SlugConfig {
+    sites: Record<string, SlugSiteConfig>;
+}
+export interface DisplaySiteConfig {
+    name: string;
+    apiBaseUrl: string;
     apiKeyConfigured: boolean;
     apiKeyReference?: string;
 }
+export interface DisplayConfig {
+    sites: DisplaySiteConfig[];
+}
 export declare function createDefaultConfig(): SlugConfig;
 export declare function getConfigPath(environment?: NodeJS.ProcessEnv): string;
 export declare function readConfig(configPath: string): Promise<SlugConfig>;
 export declare function writeConfig(configPath: string, config: SlugConfig): Promise<void>;
-export declare function setConfigApiBaseUrl(config: SlugConfig, apiBaseUrl: string): SlugConfig;
-export declare function setConfigApiKey(config: SlugConfig, apiKey: string): SlugConfig;
+export declare function setConfigSiteApiBaseUrl(config: SlugConfig, siteName: string, apiBaseUrl: string): SlugConfig;
+export declare function setConfigSiteApiKey(config: SlugConfig, siteName: string, apiKey: string): SlugConfig;
+export declare function removeConfigSite(config: SlugConfig, siteName: string): SlugConfig;
 export declare function toDisplayConfig(config: SlugConfig): DisplayConfig;
+export declare function isValidSiteName(name: string): boolean;

package/dist/config.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 export function createDefaultConfig() {
-    return {};
+    return { sites: {} };
 }
 export function getConfigPath(environment = process.env) {
     const configHome = environment.SLUG_CONFIG_HOME ?? environment.XDG_CONFIG_HOME ?? join(homedir(), ".config");
@@ -24,19 +24,46 @@ export async function writeConfig(configPath, config) {
     await mkdir(dirname(configPath), { recursive: true });
     await writeFile(configPath, serializeConfig(config), "utf8");
 }
-export function setConfigApiBaseUrl(config, apiBaseUrl) {
-    return { ...config, apiBaseUrl };
+export function setConfigSiteApiBaseUrl(config, siteName, apiBaseUrl) {
+    const site = config.sites[siteName] ?? { apiBaseUrl };
+    return {
+        ...config,
+        sites: {
+            ...config.sites,
+            [siteName]: { ...site, apiBaseUrl },
+        },
+    };
+}
+export function setConfigSiteApiKey(config, siteName, apiKey) {
+    const site = config.sites[siteName];
+    if (site === undefined) {
+        throw new Error(`Site is not configured: ${siteName}`);
+    }
+    const nextSite = { ...site, apiKey };
+    delete nextSite.apiKeyReference;
+    return {
+        ...config,
+        sites: {
+            ...config.sites,
+            [siteName]: nextSite,
+        },
+    };
 }
-export function setConfigApiKey(config, apiKey) {
-    const nextConfig = { ...config, apiKey };
-    delete nextConfig.apiKeyReference;
-    return nextConfig;
+export function removeConfigSite(config, siteName) {
+    const sites = { ...config.sites };
+    delete sites[siteName];
+    return { ...config, sites };
 }
 export function toDisplayConfig(config) {
     return {
-        apiBaseUrl: config.apiBaseUrl,
-        apiKeyConfigured: config.apiKey !== undefined || config.apiKeyReference !== undefined,
-        apiKeyReference: config.apiKeyReference,
+        sites: Object.entries(config.sites)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, site]) => ({
+            name,
+            apiBaseUrl: site.apiBaseUrl,
+            apiKeyConfigured: site.apiKey !== undefined || site.apiKeyReference !== undefined,
+            apiKeyReference: site.apiKeyReference,
+        })),
     };
 }
 function parseConfig(content) {
@@ -47,47 +74,75 @@ function parseConfig(content) {
     if (trimmed.startsWith("{")) {
         return normalizeParsedConfig(JSON.parse(trimmed));
     }
-    const parsed = {};
-    for (const [index, rawLine] of content.split(/\r?\n/).entries()) {
-        const line = stripComment(rawLine).trim();
-        if (line === "" || line === "---") {
+    const lines = content.split(/\r?\n/);
+    const sites = {};
+    let currentSite;
+    for (const [index, rawLine] of lines.entries()) {
+        const uncommented = stripComment(rawLine);
+        const line = uncommented.trimEnd();
+        if (line.trim() === "" || line.trim() === "---") {
             continue;
         }
-        const match = /^(apiBaseUrl|apiKey|apiKeyReference):(?:\s*(.*))?$/.exec(line);
-        if (match === null) {
-            throw new Error(`Invalid slug config YAML at line ${index + 1}`);
+        if (line === "sites:" || line === "sites: {}") {
+            currentSite = undefined;
+            continue;
+        }
+        const siteMatch = /^ {2}([A-Za-z0-9._-]+):\s*$/.exec(line);
+        if (siteMatch !== null) {
+            currentSite = siteMatch[1];
+            sites[currentSite] = sites[currentSite] ?? {};
+            continue;
         }
-        const [, key, rawValue = ""] = match;
-        parsed[key] = parseScalar(rawValue.trim());
+        const fieldMatch = /^ {4}(apiBaseUrl|apiKey|apiKeyReference):(?:\s*(.*))?$/.exec(line);
+        if (fieldMatch !== null && currentSite !== undefined) {
+            const [, key, rawValue = ""] = fieldMatch;
+            sites[currentSite][key] = parseScalar(rawValue.trim());
+            continue;
+        }
+        throw new Error(`Invalid slug config YAML at line ${index + 1}`);
     }
-    return normalizeParsedConfig(parsed);
+    return normalizeParsedConfig({ sites: sites });
 }
 function serializeConfig(config) {
-    const lines = [];
-    if (config.apiBaseUrl !== undefined) {
-        lines.push(`apiBaseUrl: ${formatScalar(config.apiBaseUrl)}`);
-    }
-    if (config.apiKey !== undefined) {
-        lines.push(`apiKey: ${formatScalar(config.apiKey)}`);
-    }
-    if (config.apiKeyReference !== undefined) {
-        lines.push(`apiKeyReference: ${formatScalar(config.apiKeyReference)}`);
+    const lines = ["sites:"];
+    const entries = Object.entries(config.sites).sort(([left], [right]) => left.localeCompare(right));
+    for (const [name, site] of entries) {
+        lines.push(`  ${name}:`);
+        lines.push(`    apiBaseUrl: ${formatScalar(site.apiBaseUrl)}`);
+        if (site.apiKey !== undefined) {
+            lines.push(`    apiKey: ${formatScalar(site.apiKey)}`);
+        }
+        if (site.apiKeyReference !== undefined) {
+            lines.push(`    apiKeyReference: ${formatScalar(site.apiKeyReference)}`);
+        }
     }
-    return lines.length === 0 ? "{}\n" : `${lines.join("\n")}\n`;
+    return entries.length === 0 ? "sites: {}\n" : `${lines.join("\n")}\n`;
 }
 function normalizeParsedConfig(config) {
-    const normalized = {};
-    if (typeof config.apiBaseUrl === "string") {
-        normalized.apiBaseUrl = config.apiBaseUrl;
-    }
-    if (typeof config.apiKey === "string") {
-        normalized.apiKey = config.apiKey;
-    }
-    if (typeof config.apiKeyReference === "string") {
-        normalized.apiKeyReference = config.apiKeyReference;
+    const normalized = createDefaultConfig();
+    if (config.sites !== undefined && typeof config.sites === "object" && config.sites !== null) {
+        for (const [name, site] of Object.entries(config.sites)) {
+            if (!isValidSiteName(name) || typeof site !== "object" || site === null) {
+                continue;
+            }
+            const partial = site;
+            if (typeof partial.apiBaseUrl !== "string") {
+                continue;
+            }
+            normalized.sites[name] = { apiBaseUrl: partial.apiBaseUrl };
+            if (typeof partial.apiKey === "string") {
+                normalized.sites[name].apiKey = partial.apiKey;
+            }
+            if (typeof partial.apiKeyReference === "string") {
+                normalized.sites[name].apiKeyReference = partial.apiKeyReference;
+            }
+        }
     }
     return normalized;
 }
+export function isValidSiteName(name) {
+    return /^[A-Za-z0-9._-]+$/u.test(name);
+}
 function stripComment(line) {
     let quote;
     for (let index = 0; index < line.length; index += 1) {

package/dist/index.js

@@ -15,6 +15,7 @@ export async function main(args = process.argv.slice(2)) {
         const result = await runCommand({
             args: parsedArgs.commandArgs,
             configPath: parsedArgs.configPath ?? getConfigPath(),
+            siteName: parsedArgs.siteName,
             packageVersion: readPackageVersion(),
             writer,
             openUrl,
@@ -60,6 +61,7 @@ async function promptUser(message) {
 function parseGlobalOptions(args) {
     const commandArgs = [];
     let configPath;
+    let siteName;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--config") {
@@ -79,9 +81,26 @@ function parseGlobalOptions(args) {
             configPath = value;
             continue;
         }
+        if (arg === "--site") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("--")) {
+                throw createInvalidUsageError("Usage: slug --site <name> <command>");
+            }
+            siteName = value;
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--site=")) {
+            const value = arg.slice("--site=".length);
+            if (value === "") {
+                throw createInvalidUsageError("Usage: slug --site <name> <command>");
+            }
+            siteName = value;
+            continue;
+        }
         commandArgs.push(arg);
     }
-    return { commandArgs, configPath };
+    return { commandArgs, configPath, siteName };
 }
 function getOpenCommand(url) {
     if (process.platform === "darwin") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evcraddock/slug-cli",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Command-line tool for Slugkit sites.",
   "private": false,
   "type": "module",