@evcraddock/slug-cli 0.5.0 → 0.6.1

package/README.md

@@ -25,22 +25,43 @@ Create a standalone site with:
 slug init ./my-site --name my-site --site-title "My Site"
 ```
 
-Run `slug init --help` for template options. In repository-local development, `slug init` copies `template/site` directly. Installed CLI releases download the matching versioned template asset from the Forgejo release unless `--template-url` or `--template-dir` is provided.
+Run `slug init --help` for template options. By default, `slug init` consumes the package-backed `@evcraddock/slug-template` default template. `--template-dir` and `--template-url` remain available for local or remote template testing, and `--template` reserves the selection path for future named or external template packages.
 
 ## 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 --site <name> doctor` to check API compatibility and package metadata. Use `slug --site <name> upgrade` for advisory, non-destructive package update recommendations; it reports suggested dependency changes without rewriting site files.
 
-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,23 @@ 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 { SLUGKIT_API_MAJOR_VERSION, SLUGKIT_API_NAME, compareSlugkitApiVersions, normalizeApiBaseUrl, readSlugkitApiMajorVersion, } from "@evcraddock/slug-core";
+import { GENERATED_SITE_SLUGKIT_DEPENDENCIES, SLUGKIT_TEMPLATE_PACKAGE_NAME, getTemplateMetadata, getTemplateRoot, isTemplateEntryIncluded, } from "@evcraddock/slug-template";
+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>] 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>] --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> upgrade [--json]
+  slug [--config <file>] --site <name> login [api-base-url]
+  slug [--config <file>] init <directory> --name <name> [--site-title <title>] [--template <name>] [--template-url <url>] [--template-dir <dir>] [--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 +56,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.`;
@@ -79,6 +87,8 @@ export async function runCommand(context) {
             return runVersionCommand(context, args.slice(1));
         case "doctor":
             return runDoctorCommand(context, args.slice(1));
+        case "upgrade":
+            return runUpgradeCommand(context, args.slice(1));
         case "login":
             return runLoginCommand(context, args.slice(1));
         case "init":
@@ -123,24 +133,25 @@ async function runVersionCommand(context, args) {
     }
     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 SUPPORTED_API_MAJOR_VERSION = SLUGKIT_API_MAJOR_VERSION;
+const SITE_TEMPLATE_PACKAGE_NAME = getTemplateMetadata().templateSitePackageName;
+const DEFAULT_TEMPLATE_METADATA = getTemplateMetadata();
+const DEFAULT_TEMPLATE_NAME = DEFAULT_TEMPLATE_METADATA.name;
 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]
+  slug init <directory> --name <name> [--site-title <title>] [--template <name>] [--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 <name>      Template name or package. Defaults to ${DEFAULT_TEMPLATE_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.`;
+By default, slug init uses ${SLUGKIT_TEMPLATE_PACKAGE_NAME}. Template packages are initialization sources only; generated sites do not depend on them at runtime.`;
 const SITE_INIT_NEXT_STEPS = [
     "Install dependencies",
     "Copy and edit .env",
@@ -150,14 +161,6 @@ const SITE_INIT_NEXT_STEPS = [
     "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);
@@ -200,6 +203,7 @@ function parseInitArgs(args) {
     let directory;
     let name;
     let siteTitle;
+    let template;
     let templateUrl;
     let templateDir;
     let json = false;
@@ -219,6 +223,11 @@ function parseInitArgs(args) {
             index += 1;
             continue;
         }
+        if (arg === "--template") {
+            template = readRequiredInitOptionValue(args, index, "template");
+            index += 1;
+            continue;
+        }
         if (arg === "--template-url") {
             templateUrl = readRequiredInitOptionValue(args, index, "template-url");
             index += 1;
@@ -233,15 +242,18 @@ function parseInitArgs(args) {
             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]");
+            throw createInvalidUsageError("Usage: slug init <directory> --name <name> [--site-title <title>] [--template <name>] [--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]");
+        throw createInvalidUsageError("Usage: slug init <directory> --name <name> [--site-title <title>] [--template <name>] [--template-url <url>] [--template-dir <dir>] [--json]");
     }
     const normalizedName = name.trim();
     validatePackageName(normalizedName);
+    if (template !== undefined && (templateUrl !== undefined || templateDir !== undefined)) {
+        throw createInvalidUsageError("Use --template, --template-url, or --template-dir, not more than one");
+    }
     if (templateUrl !== undefined && templateDir !== undefined) {
         throw createInvalidUsageError("Use only one of --template-url or --template-dir");
     }
@@ -250,6 +262,7 @@ function parseInitArgs(args) {
         name: normalizedName,
         siteTitle: siteTitle?.trim() || humanizePackageName(normalizedName),
         json,
+        template: template?.trim() || undefined,
         templateUrl: templateUrl?.trim() || undefined,
         templateDir: templateDir?.trim() || undefined,
     };
@@ -318,20 +331,15 @@ async function copyTemplateSite(source, destination, relativeDirectory = "") {
         }
     }
 }
-const GENERATED_SITE_TEST_EXCLUDES = new Set([
-    join("src", "__tests__", "dev-environment.test.ts"),
-    join("src", "federation", "__tests__", "follow.test.ts"),
-]);
-function shouldExcludeTemplateEntry(relativePath, name) {
-    return (GENERATED_SITE_TEST_EXCLUDES.has(relativePath) ||
-        TEMPLATE_COPY_EXCLUDES.has(name) ||
-        name.endsWith(".log") ||
-        name.endsWith(".tsbuildinfo"));
+function shouldExcludeTemplateEntry(relativePath, _name) {
+    return !isTemplateEntryIncluded(relativePath);
 }
 async function replaceGeneratedSitePlaceholders(directory, options) {
     await updateJsonFile(join(directory, "package.json"), (value) => ({
         ...value,
         name: options.name,
+        dependencies: replaceGeneratedSiteWorkspaceDependencies(value.dependencies),
+        devDependencies: replaceGeneratedSiteWorkspaceDependencies(value.devDependencies),
     }));
     await replaceTextFile(join(directory, "src", "config", "site.ts"), [
         ['name: "slugkit"', `name: ${JSON.stringify(options.siteTitle)}`],
@@ -360,6 +368,16 @@ async function replaceGeneratedSitePlaceholders(directory, options) {
         ],
     ]);
 }
+function replaceGeneratedSiteWorkspaceDependencies(value) {
+    if (!isRecord(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([name, version]) => [
+        name,
+        version === "workspace:*" && GENERATED_SITE_SLUGKIT_DEPENDENCIES[name] !== undefined
+            ? GENERATED_SITE_SLUGKIT_DEPENDENCIES[name]
+            : version,
+    ]));
+}
 async function updateJsonFile(path, update) {
     const value = JSON.parse(await readFile(path, "utf8"));
     await writeFile(path, `${JSON.stringify(update(value), null, 2)}\n`, "utf8");
@@ -376,11 +394,24 @@ async function writeGeneratedSiteMarker(directory, options) {
         slugkitSite: true,
         name: options.name,
         siteTitle: options.siteTitle,
-        template: "slugkit/template-site",
+        template: `${SLUGKIT_TEMPLATE_PACKAGE_NAME}/${DEFAULT_TEMPLATE_NAME}`,
         generatedAt: new Date().toISOString(),
+        packageMetadata: createGeneratedSitePackageMetadata(DEFAULT_TEMPLATE_METADATA),
     };
     await writeFile(join(directory, ".slugkit-site.json"), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
 }
+function createGeneratedSitePackageMetadata(metadata) {
+    return {
+        template: {
+            packageName: metadata.packageName,
+            name: metadata.name,
+            version: metadata.version,
+        },
+        packages: { ...metadata.includedSlugkitPackages },
+        advisoryOnly: true,
+        migrationNotesUrl: "https://slugkit.com/docs/package-updates",
+    };
+}
 async function resolveInitTemplateSource(context, options) {
     if (options.templateDir !== undefined) {
         const directory = resolve(options.templateDir);
@@ -390,20 +421,20 @@ async function resolveInitTemplateSource(context, options) {
     if (options.templateUrl !== undefined) {
         return downloadTemplateSite(context, options.templateUrl);
     }
+    if (options.template !== undefined) {
+        return resolveNamedTemplateSource(options.template);
+    }
     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)}`;
+    return { directory: getTemplateRoot() };
 }
-function getTemplateAssetName(version) {
-    return `slugkit-site-template-v${version}.tgz`;
+function resolveNamedTemplateSource(template) {
+    if (template === DEFAULT_TEMPLATE_NAME || template === SLUGKIT_TEMPLATE_PACKAGE_NAME) {
+        return { directory: getTemplateRoot() };
+    }
+    throw createInvalidUsageError(`Unsupported template: ${template}. This CLI currently includes ${DEFAULT_TEMPLATE_NAME}; future releases may resolve external template packages.`);
 }
 async function downloadTemplateSite(context, templateUrl) {
     let parsedUrl;
@@ -478,18 +509,20 @@ 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");
     checks.push(createHealthCheck(health));
     const meta = await requestDoctorJson(context, apiBaseUrl, "/meta");
     checks.push(createMetaCheck(meta));
+    checks.push(createPackageMetadataCheck(meta));
     const openapi = await requestDoctorJson(context, apiBaseUrl, "/openapi.json");
     checks.push(createOpenApiCheck(openapi));
     if (config.apiKey === undefined || config.apiKey.trim() === "") {
@@ -502,6 +535,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);
@@ -578,10 +622,10 @@ function createMetaCheck(result) {
     if (!isMetaDocument(result.data)) {
         return { name: "meta", status: "fail", message: "Metadata response is invalid" };
     }
-    if (result.data.api.name !== "slugkit") {
+    if (result.data.api.name !== SLUGKIT_API_NAME) {
         return { name: "meta", status: "fail", message: "API name is not slugkit" };
     }
-    if (readMajorVersion(result.data.api.version) !== SUPPORTED_API_MAJOR_VERSION) {
+    if (readSlugkitApiMajorVersion(result.data.api.version) !== SUPPORTED_API_MAJOR_VERSION) {
         return {
             name: "meta",
             status: "fail",
@@ -590,6 +634,35 @@ function createMetaCheck(result) {
     }
     return { name: "meta", status: "pass", message: `API version ${result.data.api.version}` };
 }
+function createPackageMetadataCheck(result) {
+    if (!result.ok) {
+        return { name: "packages", status: "warn", message: "Package metadata is unavailable" };
+    }
+    if (!isMetaDocument(result.data) || result.data.packageMetadata === undefined) {
+        return {
+            name: "packages",
+            status: "warn",
+            message: "Package metadata is not exposed by this site",
+        };
+    }
+    const metadata = result.data.packageMetadata;
+    const stalePackages = findStaleSlugkitPackages(metadata.packages);
+    if (stalePackages.length > 0) {
+        return {
+            name: "packages",
+            status: "warn",
+            message: `Updates available: ${stalePackages
+                .map((entry) => `${entry.packageName} ${entry.currentVersion} → ${entry.recommendedVersion}`)
+                .join(", ")}`,
+        };
+    }
+    const packageCount = Object.keys(metadata.packages).length;
+    return {
+        name: "packages",
+        status: "pass",
+        message: `${packageCount} Slugkit package versions reported; upgrades are advisory`,
+    };
+}
 function createOpenApiCheck(result) {
     if (!result.ok) {
         return { name: "openapi", status: "fail", message: result.message };
@@ -628,13 +701,108 @@ function getDoctorExitCode(checks) {
     }
     return ExitCode.ApiError;
 }
+async function runUpgradeCommand(context, args) {
+    const json = readJsonFlag(args);
+    const siteResult = await readDoctorSiteConfig(context);
+    if (!siteResult.ok) {
+        const result = {
+            ok: false,
+            advisoryOnly: true,
+            message: siteResult.message,
+            recommendations: [],
+        };
+        return finishUpgrade(context, result, json, ExitCode.InvalidUsage);
+    }
+    const apiBaseUrl = normalizeUrl(siteResult.site.apiBaseUrl);
+    const meta = await requestDoctorJson(context, apiBaseUrl, "/meta");
+    if (!meta.ok) {
+        const result = {
+            ok: false,
+            advisoryOnly: true,
+            message: meta.message,
+            recommendations: [],
+        };
+        return finishUpgrade(context, result, json, getDoctorExitCode([{ name: "meta", status: "fail", message: meta.message }]));
+    }
+    if (!isMetaDocument(meta.data) || meta.data.packageMetadata === undefined) {
+        const result = {
+            ok: true,
+            advisoryOnly: true,
+            message: "Package metadata is unavailable; no files were changed.",
+            recommendations: [],
+        };
+        return finishUpgrade(context, result, json, ExitCode.Ok);
+    }
+    const metadata = meta.data.packageMetadata;
+    const recommendations = findStaleSlugkitPackages(metadata.packages);
+    const result = {
+        ok: true,
+        advisoryOnly: true,
+        message: recommendations.length === 0
+            ? "No Slugkit package updates are currently recommended. No files were changed."
+            : "Slugkit package updates are available. Review and apply them manually; no files were changed.",
+        recommendations,
+        migrationNotesUrl: metadata.migrationNotesUrl,
+    };
+    if (metadata.template !== undefined) {
+        result.template = `${metadata.template.packageName}/${metadata.template.name}@${metadata.template.version}`;
+    }
+    return finishUpgrade(context, result, json, ExitCode.Ok);
+}
+function finishUpgrade(context, result, json, exitCode) {
+    if (json) {
+        writeJson(context.writer, result);
+    }
+    else {
+        context.writer.stdout("Slug upgrade: advisory only");
+        context.writer.stdout(result.message);
+        if (result.template !== undefined) {
+            context.writer.stdout(`Template: ${result.template}`);
+        }
+        if (result.recommendations.length > 0) {
+            context.writer.stdout("Recommended package updates:");
+            for (const recommendation of result.recommendations) {
+                context.writer.stdout(`- ${recommendation.packageName}: ${recommendation.currentVersion} -> ${recommendation.recommendedVersion}`);
+            }
+        }
+        if (result.migrationNotesUrl !== undefined) {
+            context.writer.stdout(`Migration notes: ${result.migrationNotesUrl}`);
+        }
+    }
+    return { exitCode };
+}
 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");
+        typeof value.api.openapiUrl === "string" &&
+        (value.packageMetadata === undefined || isPackageMetadata(value.packageMetadata)));
+}
+function isPackageMetadata(value) {
+    return (isRecord(value) &&
+        isRecord(value.packages) &&
+        value.advisoryOnly === true &&
+        Object.values(value.packages).every((version) => typeof version === "string") &&
+        (value.template === undefined ||
+            (isRecord(value.template) &&
+                typeof value.template.packageName === "string" &&
+                typeof value.template.name === "string" &&
+                typeof value.template.version === "string")) &&
+        (value.migrationNotesUrl === undefined || typeof value.migrationNotesUrl === "string"));
+}
+function findStaleSlugkitPackages(packages) {
+    return Object.entries(GENERATED_SITE_SLUGKIT_DEPENDENCIES)
+        .map(([packageName, recommendedVersion]) => {
+        const currentVersion = packages[packageName];
+        if (currentVersion === undefined)
+            return undefined;
+        if (compareSlugkitApiVersions(currentVersion, recommendedVersion) >= 0)
+            return undefined;
+        return { packageName, currentVersion, recommendedVersion };
+    })
+        .filter((entry) => entry !== undefined);
 }
 function isOpenApiDocument(value) {
     return (isRecord(value) &&
@@ -646,10 +814,6 @@ function isOpenApiDocument(value) {
 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;
@@ -658,10 +822,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 +853,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 +2255,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");
-    }
-    if (config.apiKey === undefined || config.apiKey.trim() === "") {
-        throw createInvalidUsageError("apiKey is not configured. Run slug login first.");
+    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.`);
     }
-    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 +2302,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);
+    }
+    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"}`);
     }
-    context.writer.stdout(`Updated ${key}.`);
     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;
@@ -2176,17 +2483,13 @@ export function createBrowserAuthUrl(apiBaseUrl) {
     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");
-        }
+        return normalizeApiBaseUrl(value);
     }
     catch {
         throw createInvalidUsageError("api-base-url must be a valid HTTP or HTTPS URL");
     }
 }
+function validateUrl(value) {
+    normalizeUrl(value);
+}

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/http.d.ts

@@ -8,13 +8,6 @@ export interface HttpRequestOptions {
     path: string;
     body?: unknown;
 }
-export interface ApiErrorBody {
-    error?: {
-        code?: string;
-        message?: string;
-        operation?: string;
-    };
-}
 export declare class SlugHttpClient {
     private readonly apiBaseUrl;
     private readonly apiKey;

package/dist/http.js

@@ -1,10 +1,11 @@
+import { normalizeApiBaseUrl } from "@evcraddock/slug-core";
 import { CliError, ExitCode } from "./errors.js";
 export class SlugHttpClient {
     apiBaseUrl;
     apiKey;
     fetchImpl;
     constructor(options) {
-        this.apiBaseUrl = options.apiBaseUrl.replace(/\/$/, "");
+        this.apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
         this.apiKey = options.apiKey;
         this.fetchImpl = options.fetchImpl ?? fetch;
     }

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.5.0",
+  "version": "0.6.1",
   "description": "Command-line tool for Slugkit sites.",
   "private": false,
   "type": "module",
@@ -26,6 +26,8 @@
     "test:watch": "vitest --config ../vitest.config.ts src"
   },
   "dependencies": {
+    "@evcraddock/slug-core": "0.1.1",
+    "@evcraddock/slug-template": "0.1.1",
     "tar": "^7.5.16"
   }
 }