@hogsend/cli 0.0.1 → 0.2.0

package/src/commands/studio.ts

@@ -0,0 +1,261 @@
+import { spawn } from "node:child_process";
+import { createReadStream, existsSync, readFileSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { extname, join, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { color } from "../lib/output.js";
+import type { Command, CommandContext } from "./types.js";
+
+const usage = `hogsend studio [options]
+
+Serve the bundled Hogsend Studio (the admin SPA) locally and open it in a
+browser. The Studio is a static single-page app; this command starts a tiny
+local web server for it on a port of your choosing.
+
+By default the Studio talks to the API at the same origin it is served from,
+which won't be a running API here — so point it at your instance with
+--base-url (the SPA uses cookie auth, so the instance must allow CORS from the
+Studio origin, or you can simply open the Studio that the engine mounts at
+\`<instance>/studio\` instead).
+
+Options:
+  --port <n>          Local port to serve on (default 3333).
+  --base-url <url>    API instance the Studio should call (injected at runtime).
+                      Omit to use same-origin (the local server, for static
+                      preview only).
+  --open              Open the Studio in your default browser after starting.
+  --dist <path>       Override the Studio dist directory (advanced).
+  -h, --help          Show this help.
+
+Examples:
+  hogsend studio --open
+  hogsend studio --base-url https://api.example.com --open
+  hogsend studio --port 4000`;
+
+/**
+ * Resolve the built Studio `dist/` directory.
+ *
+ * Resolution order:
+ *  1. Explicit --dist override (positional path; absolute or cwd-relative).
+ *  2. The dist bundled inside this CLI package (shipped via package.json files[];
+ *     at runtime bin.js is <pkg>/dist/bin.js, so the bundled studio is one level
+ *     up at <pkg>/studio).
+ *  3. Monorepo source layout: packages/studio/dist relative to this file.
+ *  4. cwd-relative packages/studio/dist (running from repo root).
+ */
+function resolveStudioDist(distFlag: string | undefined): string | null {
+  const candidates: string[] = [];
+
+  if (distFlag && distFlag.length > 0) {
+    candidates.push(resolve(process.cwd(), distFlag));
+  }
+
+  // Bundled in the published CLI tarball at <pkg>/studio.
+  candidates.push(fileURLToPath(new URL("../studio", import.meta.url)));
+
+  // Monorepo: this file is packages/cli/src/commands/studio.ts (or built into
+  // dist/), so the studio dist sits at ../../studio/dist relative to dist/.
+  candidates.push(
+    fileURLToPath(new URL("../../studio/dist", import.meta.url)),
+    fileURLToPath(new URL("../../../studio/dist", import.meta.url)),
+  );
+
+  candidates.push(resolve(process.cwd(), "packages/studio/dist"));
+
+  for (const dir of candidates) {
+    if (existsSync(join(dir, "index.html"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+
+const MIME: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+};
+
+function mimeFor(path: string): string {
+  return MIME[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+
+/**
+ * Read index.html and, when a base URL is provided, inject a runtime global the
+ * Studio reads (`window.__HOGSEND_STUDIO__ = { baseUrl }`) so the static bundle
+ * can be pointed at a remote instance without a rebuild.
+ */
+function indexHtml(distPath: string, baseUrl: string | undefined): string {
+  const raw = readFileSync(join(distPath, "index.html"), "utf8");
+  if (!baseUrl) return raw;
+  const inject = `<script>window.__HOGSEND_STUDIO__=${JSON.stringify({
+    baseUrl,
+  })};</script>`;
+  if (raw.includes("</head>")) {
+    return raw.replace("</head>", `${inject}</head>`);
+  }
+  return `${inject}${raw}`;
+}
+
+/** Open a URL in the OS default browser (best-effort, never throws). */
+function openBrowser(url: string): void {
+  const platform = process.platform;
+  const cmd =
+    platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    // best-effort
+  }
+}
+
+async function run(ctx: CommandContext): Promise<void> {
+  const { values, positionals } = parseArgs({
+    args: ctx.argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      port: { type: "string" },
+      "base-url": { type: "string" },
+      open: { type: "boolean", default: false },
+      dist: { type: "string" },
+      help: { type: "boolean", short: "h", default: false },
+    },
+  });
+
+  if (values.help) {
+    ctx.out.log(usage);
+    return;
+  }
+
+  const port = Number(values.port ?? "3333");
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    ctx.out.fail(`invalid --port "${values.port}" (expected 1-65535)`);
+  }
+
+  // --base-url flag, else the resolved CLI config base URL (so it "just works"
+  // against the same instance the other commands target), unless that's the
+  // local default placeholder. Keep undefined for pure static preview.
+  const baseUrl =
+    typeof values["base-url"] === "string" ? values["base-url"] : undefined;
+
+  const distPath = resolveStudioDist(
+    typeof values.dist === "string" ? values.dist : positionals[0],
+  );
+
+  if (!distPath) {
+    ctx.out.fail(
+      "could not find a built Studio (dist/). Build it with " +
+        "`pnpm --filter @hogsend/studio build`, or pass --dist <path>.",
+    );
+  }
+
+  const cleanBase = baseUrl ? baseUrl.replace(/\/+$/, "") : undefined;
+  const index = indexHtml(distPath, cleanBase);
+
+  const server = createServer((req, res) => {
+    const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0] ?? "/");
+
+    // The Studio bundle is built under base "/studio/", so all asset URLs are
+    // prefixed with /studio. Strip that prefix to map onto the dist root.
+    const rel = urlPath.replace(/^\/studio/, "");
+    if (rel === "" || rel === "/") {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(index);
+      return;
+    }
+
+    // Resolve safely inside distPath (defend against path traversal).
+    const target = normalize(join(distPath, rel));
+    if (target !== distPath && !target.startsWith(distPath + sep)) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
+
+    if (existsSync(target) && statSync(target).isFile()) {
+      res.writeHead(200, { "content-type": mimeFor(target) });
+      createReadStream(target).pipe(res);
+      return;
+    }
+
+    // SPA fallback: unknown paths serve index.html so client-side routes work.
+    res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+    res.end(index);
+  });
+
+  await new Promise<void>((resolveListen, reject) => {
+    server.once("error", reject);
+    server.listen(port, () => resolveListen());
+  }).catch((err: unknown) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    ctx.out.fail(`could not start server on port ${port}: ${msg}`);
+  });
+
+  const localUrl = `http://localhost:${port}/studio/`;
+
+  if (ctx.json) {
+    ctx.out.json({
+      url: localUrl,
+      port,
+      baseUrl: cleanBase ?? null,
+      dist: distPath,
+    });
+    // In json mode we still keep the server running (foreground). Agents that
+    // don't want a long-running process should not pass --json to `studio`.
+  } else {
+    ctx.out.intro(`${color.bgMagenta(color.black(" hogsend "))} studio`);
+    ctx.out.note(
+      [
+        `${color.green("●")} Studio serving at ${color.cyan(localUrl)}`,
+        cleanBase
+          ? color.dim(`API instance: ${cleanBase}`)
+          : color.dim(
+              "No --base-url set (same-origin / static preview). The API " +
+                "calls will hit this local server and fail — pass --base-url " +
+                "<instance>, or open <instance>/studio directly.",
+            ),
+        "",
+        color.dim("First load shows a create-admin screen if no admin exists."),
+        color.dim("Press Ctrl+C to stop."),
+      ].join("\n"),
+      "Studio",
+    );
+  }
+
+  if (values.open) {
+    openBrowser(localUrl);
+  }
+
+  // Keep the process alive until interrupted.
+  await new Promise<void>((resolveForever) => {
+    const stop = () => {
+      server.close(() => resolveForever());
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+}
+
+export const studioCommand: Command = {
+  name: "studio",
+  summary: "Serve the bundled Hogsend Studio admin SPA locally",
+  usage,
+  run,
+};

package/src/commands/types.ts

@@ -0,0 +1,41 @@
+import type { ResolvedConfig } from "../lib/config.js";
+import type { AdminClient } from "../lib/http.js";
+import type { Output } from "../lib/output.js";
+
+/**
+ * Per-invocation context handed to every command's `run()`. The router builds
+ * this once (after parsing global flags + resolving config) and passes it in,
+ * so command files never touch process.argv directly, never resolve config,
+ * and never construct an HTTP client themselves.
+ */
+export interface CommandContext {
+  /**
+   * The args AFTER the command token. e.g. for `hogsend journeys list --json`
+   * the router strips `journeys` and the global `--json`, leaving `["list"]`.
+   * Subcommand dispatch (list/get/...) is the command's own responsibility.
+   */
+  argv: string[];
+  /** Base URL + admin key, already resolved via flags > env > .env. */
+  cfg: ResolvedConfig;
+  /** Pre-built admin HTTP client, bound to `cfg`. */
+  http: AdminClient;
+  /** Output sink — human (TTY clack) vs json, already mode-selected. */
+  out: Output;
+  /** True when the global `--json` flag was passed. Mirrors `out.isJson`. */
+  json: boolean;
+}
+
+/**
+ * The descriptor every command file implements. The router matches `name`
+ * against the leading argv token and dispatches to `run()`.
+ */
+export interface Command {
+  /** Command token, e.g. "journeys", "eject". */
+  name: string;
+  /** One-line help shown in the root command list. */
+  summary: string;
+  /** Multiline usage block shown on `hogsend <name> --help`. */
+  usage: string;
+  /** Execute the command. Throw to fail (router renders + exits 1). */
+  run(ctx: CommandContext): Promise<void>;
+}

package/src/commands/upgrade.ts

@@ -0,0 +1,245 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { confirm } from "@clack/prompts";
+import { color } from "../lib/output.js";
+import { bail } from "../lib/prompt.js";
+import {
+  copySkill,
+  installDir,
+  listBundledSkills,
+  writeSkillsStamp,
+} from "../lib/skills.js";
+import type { Command, CommandContext } from "./types.js";
+
+const usage = `hogsend upgrade [--cwd <dir>] [--pm <pnpm|npm|yarn|bun>] [options]
+
+Upgrade a scaffolded Hogsend app in one step:
+  1. bump every @hogsend/* dependency to latest (or --to <version>), then
+  2. refresh the vendored Claude Code skills in ./.claude/skills to match.
+
+Run this after a new engine release so your app AND the agent guidance move
+together. Skills are version-stamped so \`hogsend doctor\` can warn when they
+fall behind.
+
+Options:
+  --cwd <dir>        Project root to upgrade (defaults to the current directory).
+  --pm <manager>     Package manager (default: detected from the lockfile, else pnpm).
+  --to <version>     Target version for @hogsend/* deps (default: latest).
+  --deps-only        Bump dependencies only; don't touch skills.
+  --skills-only      Refresh skills only; don't touch dependencies.
+  --yes, -y          Skip the confirmation prompt. Implied by --json.
+  --json             Run non-interactively and emit a single JSON result.
+  -h, --help         Show this help.`;
+
+type Pm = "pnpm" | "npm" | "yarn" | "bun";
+const VALID_PMS: Pm[] = ["pnpm", "npm", "yarn", "bun"];
+
+/** Detect the package manager from a lockfile, defaulting to pnpm. */
+function detectPm(cwd: string): Pm {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock")))
+    return "bun";
+  if (existsSync(join(cwd, "package-lock.json"))) return "npm";
+  return "pnpm";
+}
+
+/** The @hogsend/* deps declared in the app's package.json. */
+function hogsendDeps(cwd: string): string[] {
+  const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8")) as {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+  };
+  const all = { ...pkg.dependencies, ...pkg.devDependencies };
+  return Object.keys(all)
+    .filter((n) => n.startsWith("@hogsend/"))
+    .sort();
+}
+
+/** Build the install verb + args for the given pm (all but npm use `add`). */
+function addArgs(pm: Pm, specs: string[]): string[] {
+  return [pm === "npm" ? "install" : "add", ...specs];
+}
+
+interface StepResult {
+  step: string;
+  status: "ok" | "skipped" | "failed";
+  detail: string;
+}
+
+async function run(ctx: CommandContext): Promise<void> {
+  const { values } = parseArgs({
+    args: ctx.argv,
+    allowPositionals: true,
+    options: {
+      cwd: { type: "string" },
+      pm: { type: "string" },
+      to: { type: "string" },
+      "deps-only": { type: "boolean", default: false },
+      "skills-only": { type: "boolean", default: false },
+      yes: { type: "boolean", short: "y", default: false },
+      help: { type: "boolean", short: "h", default: false },
+    },
+  });
+
+  if (values.help) {
+    ctx.out.log(usage);
+    return;
+  }
+
+  if (values["deps-only"] && values["skills-only"]) {
+    ctx.out.fail("--deps-only and --skills-only are mutually exclusive.");
+  }
+
+  const cwd = values.cwd ?? process.cwd();
+  if (!existsSync(join(cwd, "package.json"))) {
+    ctx.out.fail(
+      `no package.json in ${cwd} — run upgrade from a scaffolded Hogsend app (or pass --cwd).`,
+    );
+  }
+
+  let pm: Pm;
+  if (values.pm !== undefined) {
+    if (!(VALID_PMS as string[]).includes(values.pm)) {
+      ctx.out.fail(
+        `invalid --pm "${values.pm}". Expected one of: ${VALID_PMS.join(", ")}.`,
+      );
+    }
+    pm = values.pm as Pm;
+  } else {
+    pm = detectPm(cwd);
+  }
+
+  const target = values.to ?? "latest";
+  const doDeps = !values["skills-only"];
+  const doSkills = !values["deps-only"];
+  const deps = doDeps ? hogsendDeps(cwd) : [];
+
+  if (doDeps && deps.length === 0) {
+    ctx.out.fail(
+      `no @hogsend/* dependencies found in ${join(cwd, "package.json")}.`,
+    );
+  }
+
+  const skipConfirm = ctx.json || values.yes;
+  if (!ctx.json) {
+    ctx.out.intro(
+      `${color.bgMagenta(color.black(" hogsend "))} ${color.dim("upgrade")}`,
+    );
+  }
+  if (ctx.out.interactive && !skipConfirm) {
+    const plan = [
+      doDeps
+        ? `bump ${deps.length} @hogsend/* dep(s) to ${target} (${pm})`
+        : null,
+      doSkills ? "refresh .claude/skills" : null,
+    ]
+      .filter(Boolean)
+      .join(" + ");
+    const proceed = bail(
+      await confirm({ message: `Upgrade ${color.cyan(cwd)}: ${plan}?` }),
+    );
+    if (!proceed) {
+      ctx.out.outro(color.dim("Nothing changed."));
+      return;
+    }
+  }
+
+  const results: StepResult[] = [];
+
+  // 1. bump @hogsend/* deps via the package manager.
+  if (doDeps) {
+    const specs = deps.map((n) => `${n}@${target}`);
+    const dep = await ctx.out.step(
+      `Bumping @hogsend/* -> ${target} (${pm})`,
+      async () =>
+        spawnSync(pm, addArgs(pm, specs), {
+          cwd,
+          stdio: ctx.json ? "ignore" : "inherit",
+          shell: process.platform === "win32",
+        }),
+    );
+    results.push({
+      step: "deps",
+      status: dep.status === 0 ? "ok" : "failed",
+      detail:
+        dep.status === 0
+          ? `${deps.join(", ")} -> ${target}`
+          : `${pm} exited with code ${dep.status ?? "?"}`,
+    });
+  } else {
+    results.push({ step: "deps", status: "skipped", detail: "--skills-only" });
+  }
+
+  // 2. refresh vendored skills + re-stamp (only if deps didn't hard-fail).
+  const depsFailed = results.some(
+    (r) => r.step === "deps" && r.status === "failed",
+  );
+  if (!doSkills) {
+    results.push({
+      step: "skills",
+      status: "skipped",
+      detail: "--deps-only",
+    });
+  } else if (depsFailed) {
+    results.push({
+      step: "skills",
+      status: "skipped",
+      detail: "skipped — dependency bump failed; fix it then re-run",
+    });
+  } else {
+    const bundled = listBundledSkills(cwd);
+    const copied = bundled.map((s) => copySkill(s.name, cwd, true));
+    writeSkillsStamp(
+      cwd,
+      bundled.map((s) => s.name),
+    );
+    results.push({
+      step: "skills",
+      status: "ok",
+      detail: `refreshed ${copied.length} skill(s) -> ${installDir(cwd)}`,
+    });
+  }
+
+  const failed = results.filter((r) => r.status === "failed");
+  const ok = failed.length === 0;
+
+  if (ctx.json) {
+    ctx.out.json({ ok, cwd, pm, target, steps: results });
+    if (!ok) process.exit(1);
+    return;
+  }
+
+  ctx.out.table(
+    results.map((r) => ({
+      step: r.step,
+      status:
+        r.status === "ok"
+          ? color.green("ok")
+          : r.status === "skipped"
+            ? color.dim("skipped")
+            : color.red("failed"),
+      detail: r.detail,
+    })),
+    ["step", "status", "detail"],
+  );
+
+  if (!ok) {
+    ctx.out.fail(
+      `${failed.length} step(s) failed — see the table above. Fix and re-run hogsend upgrade.`,
+    );
+  }
+
+  ctx.out.outro(
+    `${color.green("Upgraded.")} ${color.dim("Engine + agent skills are on the latest line.")}`,
+  );
+}
+
+export const upgradeCommand: Command = {
+  name: "upgrade",
+  summary: "Bump @hogsend/* deps to latest + refresh vendored skills",
+  usage,
+  run,
+};

package/src/index.ts

@@ -1,4 +1,6 @@
 // @hogsend/cli — programmatic entry. The `hogsend` bin lives in ./bin.ts.
+
+export type { Command, CommandContext } from "./commands/types.js";
 export {
   EjectError,
   type EjectOptions,

package/src/lib/config.ts

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+/** Resolved target for the admin HTTP client. */
+export interface ResolvedConfig {
+  /** Base URL of the target instance, no trailing slash. */
+  baseUrl: string;
+  /** Admin bearer token, if resolvable. `doctor`/health works without it. */
+  adminKey: string | undefined;
+}
+
+/** Global flags parsed off the front of any command's argv. */
+export interface GlobalFlags {
+  url?: string;
+  adminKey?: string;
+  json: boolean;
+  help: boolean;
+  /** The remaining args after global flags are stripped. */
+  rest: string[];
+}
+
+const DEFAULT_BASE_URL = "http://localhost:3002";
+
+/**
+ * Parse the global flags that every command honours (`--url`, `--admin-key`,
+ * `--json`, `-h`/`--help`) off an argv slice, returning the parsed values plus
+ * the leftover `rest` (positionals + unknown flags) for the command to handle.
+ *
+ * `strict: false` so command-specific flags (e.g. `--enabled`, `--limit`) pass
+ * through untouched in `rest` rather than throwing here.
+ */
+export function parseGlobalFlags(argv: string[]): GlobalFlags {
+  const { values, tokens } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+    options: {
+      url: { type: "string" },
+      "admin-key": { type: "string" },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false },
+    },
+  });
+
+  // Rebuild `rest` from the token stream, dropping only the global flags we
+  // own (and their values). Everything else — positionals and unknown option
+  // tokens — is preserved verbatim for the command's own parser.
+  const owned = new Set(["url", "admin-key", "json", "help", "h"]);
+  const rest: string[] = [];
+  for (const token of tokens) {
+    if (token.kind === "positional") {
+      rest.push(token.value);
+    } else if (token.kind === "option") {
+      if (owned.has(token.name)) continue;
+      rest.push(token.rawName);
+      if (token.value !== undefined && !token.inlineValue) {
+        rest.push(token.value);
+      } else if (token.inlineValue && token.value !== undefined) {
+        // already captured in rawName? no — rebuild as --name=value
+        rest[rest.length - 1] = `${token.rawName}=${token.value}`;
+      }
+    }
+  }
+
+  return {
+    url: typeof values.url === "string" ? values.url : undefined,
+    adminKey:
+      typeof values["admin-key"] === "string" ? values["admin-key"] : undefined,
+    json: values.json === true,
+    help: values.help === true,
+    rest,
+  };
+}
+
+/**
+ * Manually parse a `.env` file into a flat record. No dotenv dependency: a
+ * small, forgiving parser (KEY=VALUE per line, `#` comments, optional quotes,
+ * `export ` prefix tolerated). Never throws — a missing/unreadable file yields
+ * an empty record so config resolution stays robust in any cwd.
+ */
+export function loadDotEnv(
+  cwd: string = process.cwd(),
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  const file = join(cwd, ".env");
+  if (!existsSync(file)) return out;
+  let raw: string;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return out;
+  }
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) continue;
+    const withoutExport = line.startsWith("export ")
+      ? line.slice("export ".length)
+      : line;
+    const eq = withoutExport.indexOf("=");
+    if (eq === -1) continue;
+    const key = withoutExport.slice(0, eq).trim();
+    if (key === "") continue;
+    let value = withoutExport.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+/**
+ * Resolve the target config with precedence flags > process.env > .env, falling
+ * back to the local-dev default base URL.
+ *
+ *   baseUrl: --url > HOGSEND_API_URL (env) > HOGSEND_API_URL (.env) > localhost:3002
+ *   adminKey: --admin-key > HOGSEND_ADMIN_KEY|ADMIN_API_KEY (env) > (.env equiv)
+ */
+export function resolveConfig(
+  flags: GlobalFlags,
+  cwd: string = process.cwd(),
+): ResolvedConfig {
+  const dotenv = loadDotEnv(cwd);
+
+  const baseUrlRaw =
+    flags.url ??
+    process.env.HOGSEND_API_URL ??
+    dotenv.HOGSEND_API_URL ??
+    DEFAULT_BASE_URL;
+
+  const adminKey =
+    flags.adminKey ??
+    process.env.HOGSEND_ADMIN_KEY ??
+    process.env.ADMIN_API_KEY ??
+    dotenv.HOGSEND_ADMIN_KEY ??
+    dotenv.ADMIN_API_KEY;
+
+  return {
+    baseUrl: baseUrlRaw.replace(/\/+$/, ""),
+    adminKey: adminKey && adminKey.length > 0 ? adminKey : undefined,
+  };
+}