@botlr/cli 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,715 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, InvalidArgumentError } from "commander";
+import { createRequire } from "module";
+
+// src/config.ts
+import { access, readFile } from "fs/promises";
+import path from "path";
+var CONFIG_FILE = "botlr.config.json";
+var DEFAULT_FRAMEWORK = "react-next";
+var DEFAULT_SECTIONS_DIR = "components/sections";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+async function exists(file) {
+  try {
+    await access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findConfigFile(startDir) {
+  let dir = path.resolve(startDir);
+  for (; ; ) {
+    const candidate = path.join(dir, CONFIG_FILE);
+    if (await exists(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function readConfigFile(file) {
+  const raw = await readFile(file, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new ConfigError(`${file} must hold a JSON object`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof ConfigError) throw error;
+    throw new ConfigError(`${file} is not valid JSON: ${error.message}`);
+  }
+}
+async function loadConfig(cwd, overrides2 = {}, env = process.env) {
+  const configPath = await findConfigFile(cwd);
+  const file = configPath ? await readConfigFile(configPath) : {};
+  const root = configPath ? path.dirname(configPath) : path.resolve(cwd);
+  const baseUrl = overrides2.baseUrl ?? env.BOTLR_BASE_URL ?? file.baseUrl;
+  const appId = overrides2.appId ?? env.BOTLR_APP_ID ?? file.appId;
+  if (!baseUrl) {
+    throw new ConfigError(`No baseUrl: set it in ${CONFIG_FILE} or BOTLR_BASE_URL`);
+  }
+  if (!appId) {
+    throw new ConfigError(`No appId: set it in ${CONFIG_FILE} or BOTLR_APP_ID`);
+  }
+  const sectionsDir = overrides2.dir ? path.resolve(cwd, overrides2.dir) : path.resolve(root, env.BOTLR_SECTIONS_DIR ?? file.sectionsDir ?? DEFAULT_SECTIONS_DIR);
+  return {
+    root,
+    configPath,
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    appId,
+    framework: overrides2.framework ?? env.BOTLR_FRAMEWORK ?? file.framework ?? DEFAULT_FRAMEWORK,
+    sectionsDir,
+    apiKey: env.BOTLR_API_KEY || void 0,
+    personalToken: env.BOTLR_PAT || void 0
+  };
+}
+
+// src/client.ts
+import { createBotlrClient } from "@botlr/sdk";
+function clientFor(config, options = {}) {
+  if (!config.apiKey && !options.needPersonalToken) {
+    process.stderr.write("botlr: BOTLR_API_KEY is not set, requests go out without a site token\n");
+  }
+  if (options.needPersonalToken && !config.personalToken) {
+    throw new ConfigError("Pushing needs BOTLR_PAT: a personal access token with the write:sections scope");
+  }
+  return createBotlrClient({
+    baseUrl: config.baseUrl,
+    appId: config.appId,
+    apiKey: config.apiKey,
+    personalToken: config.personalToken
+  });
+}
+
+// src/commands/list.ts
+async function listSections(config) {
+  const client = clientFor(config);
+  const listing = await client.sections.list({ framework: config.framework });
+  return listing.sections;
+}
+
+// src/commands/pull.ts
+import { contentHash } from "@botlr/sdk";
+
+// src/lock.ts
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
+var LOCK_DIR = ".botlr";
+var LOCK_FILE = "sections.lock.json";
+function lockPath(root) {
+  return path2.join(root, LOCK_DIR, LOCK_FILE);
+}
+async function readLock(root) {
+  try {
+    const raw = await readFile2(lockPath(root), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+async function writeLock(root, lock) {
+  const file = lockPath(root);
+  await mkdir(path2.dirname(file), { recursive: true });
+  const sorted = Object.fromEntries(Object.entries(lock).sort(([a], [b]) => a.localeCompare(b)));
+  await writeFile(file, `${JSON.stringify(sorted, null, 2)}
+`, "utf8");
+}
+async function updateLock(root, name, entry) {
+  const lock = await readLock(root);
+  lock[name] = entry;
+  await writeLock(root, lock);
+  return lock;
+}
+
+// src/manifest.ts
+import { mkdir as mkdir2, readFile as readFile3, readdir, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+import {
+  isValidSectionPath,
+  stripManifestState
+} from "@botlr/sdk";
+var MANIFEST_SUFFIX = ".botlr.json";
+var ManifestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ManifestError";
+  }
+};
+function manifestPath(sectionsDir, name) {
+  return path3.join(sectionsDir, `${name}${MANIFEST_SUFFIX}`);
+}
+async function listManifests(sectionsDir) {
+  let entries;
+  try {
+    entries = await readdir(sectionsDir);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  return entries.filter((entry) => entry.endsWith(MANIFEST_SUFFIX)).map((entry) => entry.slice(0, -MANIFEST_SUFFIX.length)).sort();
+}
+async function readManifest(sectionsDir, name) {
+  const file = manifestPath(sectionsDir, name);
+  let raw;
+  try {
+    raw = await readFile3(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ManifestError(`No manifest for '${name}': expected ${file}`);
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ManifestError(`${file} is not valid JSON: ${error.message}`);
+  }
+  return validateManifest(parsed, file);
+}
+function validateManifest(value, where = "manifest") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ManifestError(`${where} must be a JSON object`);
+  }
+  const m = value;
+  if (typeof m.section !== "string" || !m.section) throw new ManifestError(`${where}: 'section' is required`);
+  if (typeof m.entry !== "string" || !m.entry) throw new ManifestError(`${where}: 'entry' is required`);
+  if (!Array.isArray(m.files) || m.files.length === 0 || !m.files.every((f) => typeof f === "string")) {
+    throw new ManifestError(`${where}: 'files' must list at least one path`);
+  }
+  const files = m.files;
+  for (const file of files) {
+    if (!isValidSectionPath(file)) throw new ManifestError(`${where}: invalid file path '${file}'`);
+  }
+  if (!files.includes(m.entry)) throw new ManifestError(`${where}: 'entry' (${m.entry}) must be listed in 'files'`);
+  if (m.framework !== void 0 && typeof m.framework !== "string") {
+    throw new ManifestError(`${where}: 'framework' must be a string`);
+  }
+  return m;
+}
+async function writeManifest(sectionsDir, name, manifest) {
+  const file = manifestPath(sectionsDir, name);
+  await mkdir2(sectionsDir, { recursive: true });
+  await writeFile2(file, `${JSON.stringify(stripManifestState(manifest), null, 2)}
+`, "utf8");
+  return file;
+}
+async function readSectionFiles(sectionsDir, manifest) {
+  return Promise.all(
+    manifest.files.map(async (relative) => {
+      const file = safeJoin(sectionsDir, relative);
+      try {
+        return { path: relative, content: await readFile3(file, "utf8") };
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          throw new ManifestError(`Missing file '${relative}' listed in ${manifest.section}${MANIFEST_SUFFIX}`);
+        }
+        throw error;
+      }
+    })
+  );
+}
+async function writeSectionFiles(sectionsDir, files) {
+  const written = [];
+  for (const file of files) {
+    const target = safeJoin(sectionsDir, file.path);
+    await mkdir2(path3.dirname(target), { recursive: true });
+    await writeFile2(target, file.content, "utf8");
+    written.push(target);
+  }
+  return written;
+}
+function safeJoin(dir, relative) {
+  if (!isValidSectionPath(relative)) throw new ManifestError(`Invalid file path '${relative}'`);
+  const target = path3.resolve(dir, relative);
+  const base = path3.resolve(dir);
+  if (target !== base && !target.startsWith(base + path3.sep)) {
+    throw new ManifestError(`File path '${relative}' escapes ${dir}`);
+  }
+  return target;
+}
+
+// src/commands/pull.ts
+async function localHash(sectionsDir, name) {
+  try {
+    const manifest = await readManifest(sectionsDir, name);
+    return await contentHash(await readSectionFiles(sectionsDir, manifest));
+  } catch {
+    return null;
+  }
+}
+async function pullSections(config, options) {
+  const client = clientFor(config);
+  const scope = options.shared ? "shared" : void 0;
+  let names = options.names;
+  if (options.all) {
+    const listing = await client.sections.list({ framework: config.framework });
+    names = listing.sections.filter((s) => options.shared ? s.shared : s.instance || s.shared).map((s) => s.name);
+  }
+  if (names.length === 0) return [];
+  const lock = await readLock(config.root);
+  const results = [];
+  for (const name of names) {
+    const entry = lock[name];
+    if (entry && !options.force) {
+      const current = await localHash(config.sectionsDir, name);
+      if (current !== null && current !== entry.contentHash) {
+        results.push({ name, scope: entry.scope, version: entry.version, files: [], skipped: "modified locally, use --force to overwrite" });
+        continue;
+      }
+    }
+    const response = await client.sections.pull(name, {
+      framework: config.framework,
+      version: options.version,
+      scope
+    });
+    const { source } = response;
+    const files = await writeSectionFiles(config.sectionsDir, source.files);
+    await writeManifest(config.sectionsDir, name, source.manifest);
+    const newEntry = {
+      scope: source.scope,
+      framework: source.framework,
+      version: source.version,
+      contentHash: source.contentHash,
+      pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    lock[name] = newEntry;
+    results.push({ name, scope: source.scope, version: source.version, files });
+  }
+  await writeLock(config.root, lock);
+  return results;
+}
+
+// src/commands/push.ts
+import {
+  BotlrConflictError,
+  contentHash as contentHash2
+} from "@botlr/sdk";
+var PushConflict = class extends Error {
+  constructor(message, latest) {
+    super(message);
+    this.latest = latest;
+    this.name = "PushConflict";
+  }
+  latest;
+};
+async function pushSection(config, options) {
+  const client = clientFor(config, { needPersonalToken: true });
+  const { name } = options;
+  const manifest = await readManifest(config.sectionsDir, name);
+  if (manifest.section !== name) {
+    throw new ManifestError(`${name}.botlr.json says section '${manifest.section}', expected '${name}'`);
+  }
+  if (manifest.framework && manifest.framework !== config.framework) {
+    throw new ManifestError(
+      `${name}.botlr.json is for framework '${manifest.framework}', the config says '${config.framework}'`
+    );
+  }
+  manifest.framework = config.framework;
+  const files = await readSectionFiles(config.sectionsDir, manifest);
+  const localHash2 = await contentHash2(files);
+  const targetScope = options.shared ? "shared" : "instance";
+  let baseVersion;
+  if (!options.force) {
+    const lock = (await readLock(config.root))[name];
+    if (lock && lock.scope === targetScope) {
+      baseVersion = lock.version;
+    } else {
+      const listing = await client.sections.list({ framework: config.framework });
+      const summary = listing.sections.find((s) => s.name === name);
+      const remote = summary ? targetScope === "shared" ? summary.shared : summary.instance : null;
+      baseVersion = remote?.version ?? 0;
+      if (remote && lock === void 0 && remote.contentHash === localHash2) {
+      }
+    }
+  }
+  let response;
+  try {
+    response = await client.sections.push(name, {
+      framework: config.framework,
+      manifest,
+      files,
+      shared: options.shared ?? false,
+      baseVersion,
+      message: options.message,
+      create: options.create ?? false
+    });
+  } catch (error) {
+    if (error instanceof BotlrConflictError) {
+      throw new PushConflict(error.message, error.latest);
+    }
+    throw error;
+  }
+  await updateLock(config.root, name, {
+    scope: response.scope,
+    framework: config.framework,
+    version: response.version,
+    contentHash: response.contentHash,
+    pulledAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    name,
+    created: response.created,
+    scope: response.scope,
+    version: response.version,
+    contentHash: response.contentHash
+  };
+}
+
+// src/commands/status.ts
+import { contentHash as contentHash3 } from "@botlr/sdk";
+
+// src/status.ts
+function computeStatus({ localHash: localHash2, lock, remote }) {
+  if (!lock) return "untracked";
+  const localChanged = localHash2 !== lock.contentHash;
+  const remoteChanged = remote != null && remote.contentHash !== lock.contentHash;
+  if (localChanged && remoteChanged) return "diverged";
+  if (localChanged) return "modified";
+  if (remoteChanged) return "behind";
+  return "clean";
+}
+function remoteForLock(summary, lock) {
+  if (!summary) return void 0;
+  if (!lock) return summary.effective === "shared" ? summary.shared : summary.instance;
+  return lock.scope === "shared" ? summary.shared : summary.instance;
+}
+
+// src/commands/status.ts
+async function sectionStatuses(config, options = {}) {
+  const names = options.names?.length ? options.names : await listManifests(config.sectionsDir);
+  const lock = await readLock(config.root);
+  let summaries = /* @__PURE__ */ new Map();
+  if (!options.offline) {
+    const listing = await clientFor(config).sections.list({ framework: config.framework });
+    summaries = new Map(listing.sections.map((s) => [s.name, s]));
+  }
+  const rows = [];
+  for (const name of names) {
+    const entry = lock[name];
+    const summary = summaries.get(name);
+    const remote = remoteForLock(summary, entry);
+    try {
+      const manifest = await readManifest(config.sectionsDir, name);
+      const localHash2 = await contentHash3(await readSectionFiles(config.sectionsDir, manifest));
+      rows.push({
+        name,
+        status: computeStatus({ localHash: localHash2, lock: entry, remote }),
+        local: entry?.version ?? null,
+        remote: remote?.version ?? null,
+        scope: entry?.scope ?? summary?.effective ?? "-"
+      });
+    } catch (error) {
+      rows.push({
+        name,
+        status: "error",
+        local: entry?.version ?? null,
+        remote: remote?.version ?? null,
+        scope: entry?.scope ?? "-",
+        detail: error.message
+      });
+    }
+  }
+  return rows;
+}
+
+// src/init.ts
+import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
+import path4 from "path";
+var REGISTRY_FILE = "publisher-section-registry.ts";
+function parseRegistry(source) {
+  const importedFrom = /* @__PURE__ */ new Map();
+  const importRe = /import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/g;
+  for (const match of source.matchAll(importRe)) {
+    const names = match[1];
+    const spec = match[2];
+    for (const raw of names.split(",")) {
+      const name = raw.trim().split(/\s+as\s+/).pop()?.trim();
+      if (name) importedFrom.set(name, spec);
+    }
+  }
+  const bodyMatch = source.match(/=\s*\{([\s\S]*?)\n\}\s*;?/);
+  if (!bodyMatch) return [];
+  const entries = [];
+  const entryRe = /^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_$-]+))\s*:\s*([A-Za-z0-9_$]+)\s*,?\s*(?:\/\/.*)?$/gm;
+  for (const match of bodyMatch[1].matchAll(entryRe)) {
+    const slug = match[1] ?? match[2] ?? match[3];
+    const exportName = match[4];
+    const importPath = importedFrom.get(exportName);
+    if (!importPath || !importPath.startsWith(".")) continue;
+    entries.push({ slug, exportName, importPath });
+  }
+  return entries;
+}
+function parseDefinition(source) {
+  const match = source.match(/export\s+const\s+\w+Definition\s*=\s*\{([\s\S]*?)\n\}/);
+  if (!match) return null;
+  const body = match[1];
+  const field = (key) => {
+    const m = body.match(new RegExp(`(?:^|\\n)\\s*${key}\\s*:\\s*(?:"([^"]*)"|'([^']*)'|\`([^\`]*)\`)`));
+    return m ? m[1] ?? m[2] ?? m[3] : void 0;
+  };
+  return {
+    name: field("name"),
+    heading: field("heading"),
+    category: field("category"),
+    description: field("description"),
+    icon: field("icon")
+  };
+}
+function parseImports(source) {
+  const internal = /* @__PURE__ */ new Set();
+  const npm = /* @__PURE__ */ new Set();
+  const re = /(?:import|export)\s+(?:[^"';]*?\s+from\s+)?["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)/g;
+  for (const match of source.matchAll(re)) {
+    const spec = match[1] ?? match[2];
+    if (!spec) continue;
+    if (spec.startsWith(".") || spec.startsWith("@/") || spec.startsWith("~/")) internal.add(spec);
+    else npm.add(spec.startsWith("@") ? spec.split("/").slice(0, 2).join("/") : spec.split("/")[0]);
+  }
+  return { internal: [...internal].sort(), npm: [...npm].sort() };
+}
+var SOURCE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+async function resolveImport(sectionsDir, spec) {
+  const base = path4.resolve(sectionsDir, spec);
+  for (const ext of SOURCE_EXTENSIONS) {
+    try {
+      await readFile4(base + ext);
+      return base + ext;
+    } catch {
+    }
+  }
+  return null;
+}
+async function deriveManifests(sectionsDir, options) {
+  const registrySource = await readFile4(path4.join(sectionsDir, REGISTRY_FILE), "utf8");
+  const entries = parseRegistry(registrySource);
+  const out = [];
+  for (const entry of entries) {
+    const entryFile = await resolveImport(sectionsDir, entry.importPath);
+    if (!entryFile) continue;
+    const source = await readFile4(entryFile, "utf8");
+    const meta = parseDefinition(source);
+    const imports = parseImports(source);
+    const relative = path4.relative(sectionsDir, entryFile).split(path4.sep).join("/");
+    const npm = {};
+    for (const pkg of imports.npm) {
+      if (pkg === "react" || pkg === "next") continue;
+      npm[pkg] = options.npmVersions?.[pkg] ?? "*";
+    }
+    const manifest = {
+      section: entry.slug,
+      framework: options.framework,
+      entry: relative,
+      exportName: entry.exportName,
+      files: [relative],
+      ...meta?.heading ? { title: meta.heading } : {},
+      ...meta?.description ? { description: meta.description } : {},
+      ...meta?.category ? { category: meta.category } : {},
+      ...meta?.icon ? { icon: meta.icon } : {},
+      dependencies: {
+        ...Object.keys(npm).length ? { npm } : {},
+        ...imports.internal.length ? { internal: imports.internal } : {}
+      }
+    };
+    out.push({ name: entry.slug, manifest, entryFile });
+  }
+  return out;
+}
+async function readNpmVersions(dir) {
+  let current = path4.resolve(dir);
+  for (; ; ) {
+    try {
+      const raw = await readFile4(path4.join(current, "package.json"), "utf8");
+      const pkg = JSON.parse(raw);
+      return { ...pkg.devDependencies, ...pkg.dependencies };
+    } catch {
+      const parent = path4.dirname(current);
+      if (parent === current) return {};
+      current = parent;
+    }
+  }
+}
+async function hasRegistry(sectionsDir) {
+  try {
+    return (await readdir2(sectionsDir)).includes(REGISTRY_FILE);
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/init.ts
+async function initSections(config, options = {}) {
+  if (!await hasRegistry(config.sectionsDir)) {
+    throw new Error(`No ${REGISTRY_FILE} in ${config.sectionsDir}; sections init reads the registry map to find components`);
+  }
+  const existing = new Set(await listManifests(config.sectionsDir));
+  const npmVersions = await readNpmVersions(config.sectionsDir);
+  const derived = await deriveManifests(config.sectionsDir, { framework: config.framework, npmVersions });
+  const results = [];
+  for (const { name, manifest, entryFile } of derived) {
+    const skip = existing.has(name) && !options.force;
+    let file = `${name}.botlr.json`;
+    if (!skip && !options.dryRun) {
+      file = await writeManifest(config.sectionsDir, name, manifest);
+    }
+    results.push({ name, file, entry: entryFile, written: !skip && !options.dryRun });
+  }
+  return results;
+}
+
+// src/output.ts
+function table(rows, header) {
+  const all = header ? [header, ...rows] : rows;
+  if (all.length === 0) return "";
+  const widths = all[0].map((_, col) => Math.max(...all.map((row) => (row[col] ?? "").length)));
+  const line = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd();
+  const out = all.map(line);
+  if (header) out.splice(1, 0, widths.map((w) => "-".repeat(w)).join("  "));
+  return out.join("\n");
+}
+function fail(message) {
+  process.stderr.write(`botlr: ${message}
+`);
+  process.exit(1);
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+function parseVersion(value) {
+  const n = Number.parseInt(value, 10);
+  if (!Number.isInteger(n) || n < 1) throw new InvalidArgumentError("version must be a positive integer");
+  return n;
+}
+function overrides(opts) {
+  return { framework: opts.framework, dir: opts.dir };
+}
+function withCommon(cmd) {
+  return cmd.option("--framework <name>", "source variant, for example react-next (default from config)").option("--dir <path>", "sections directory (default from config, components/sections)");
+}
+async function run(action) {
+  try {
+    await action();
+  } catch (error) {
+    if (error instanceof PushConflict) {
+      const latest = error.latest ? `v${error.latest.version} (${error.latest.contentHash.slice(0, 12)})` : "none";
+      fail(`${error.message}
+  latest on server: ${latest}
+  pull first, or push --force to overwrite`);
+    }
+    fail(error.message);
+  }
+}
+var program = new Command("botlr").description("Pull and push section source between a Botlr site and this app").version(version).configureHelp({ sortSubcommands: true });
+withCommon(
+  program.command("pull [names...]").description("pull sections into the sections directory; writes <name>.botlr.json and the lock file").option("--all", "every section the server lists for the framework").option("--version <n>", "a specific version instead of the latest", parseVersion).option("--shared", "the shared row (per section definition) even when the app has its own").option("--force", "overwrite files that changed locally since the last pull")
+).action(
+  (names, opts) => run(async () => {
+    if (names.length === 0 && !opts.all) fail("name a section or pass --all");
+    if (opts.all && opts.version !== void 0) fail("--version needs a single section name");
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const results = await pullSections(config, {
+      names,
+      all: opts.all,
+      version: opts.version,
+      shared: opts.shared,
+      force: opts.force
+    });
+    if (results.length === 0) {
+      console.log("nothing to pull");
+      return;
+    }
+    for (const r of results) {
+      if (r.skipped) console.log(`skip  ${r.name}: ${r.skipped}`);
+      else console.log(`pull  ${r.name} ${r.scope} v${r.version} (${r.files.length} file${r.files.length === 1 ? "" : "s"})`);
+    }
+  })
+);
+withCommon(
+  program.command("push <name>").description("push the section's files and manifest as a new version (needs BOTLR_PAT)").option("-m, --message <text>", "a note on the version, at most 500 characters").option("--shared", "write the shared row (per section definition) instead of this app's row").option("--create", "create the section definition when the dashboard does not have it").option("--force", "skip the conflict check (omits baseVersion)")
+).action(
+  (name, opts) => run(async () => {
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const result = await pushSection(config, {
+      name,
+      message: opts.message,
+      shared: opts.shared,
+      create: opts.create,
+      force: opts.force
+    });
+    if (result.created) console.log(`pushed ${result.name} ${result.scope} v${result.version}`);
+    else console.log(`${result.name} ${result.scope} v${result.version} already matches, nothing pushed`);
+  })
+);
+var sections = program.command("sections").description("list, inspect and bootstrap sections");
+withCommon(sections.command("list").description("every section the server has source for")).action(
+  (opts) => run(async () => {
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const rows = await listSections(config);
+    if (rows.length === 0) {
+      console.log(`no ${config.framework} sections for app ${config.appId}`);
+      return;
+    }
+    const v = (s) => s ? `v${s.version}` : "-";
+    console.log(
+      table(
+        rows.map((s) => [s.name, s.title, v(s.instance), v(s.shared), s.effective]),
+        ["name", "title", "instance", "shared", "effective"]
+      )
+    );
+  })
+);
+withCommon(
+  sections.command("status [names...]").description("clean | modified | behind | diverged per local manifest").option("--offline", "compare with the lock file only, without asking the server")
+).action(
+  (names, opts) => run(async () => {
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const rows = await sectionStatuses(config, { names, offline: opts.offline });
+    if (rows.length === 0) {
+      console.log(`no *.botlr.json manifests in ${config.sectionsDir}`);
+      return;
+    }
+    console.log(
+      table(
+        rows.map((r) => [
+          r.name,
+          r.status,
+          r.local === null ? "-" : `v${r.local}`,
+          r.remote === null ? "-" : `v${r.remote}`,
+          r.scope,
+          r.detail ?? ""
+        ]),
+        ["name", "status", "local", "remote", "scope", ""]
+      )
+    );
+    if (rows.some((r) => r.status === "diverged" || r.status === "error")) process.exitCode = 1;
+  })
+);
+withCommon(
+  sections.command("init").description("derive first <name>.botlr.json manifests from publisher-section-registry.ts and the XDefinition exports").option("--force", "overwrite manifests that already exist").option("--dry-run", "show what would be written")
+).action(
+  (opts) => run(async () => {
+    const config = await loadConfig(process.cwd(), overrides(opts));
+    const results = await initSections(config, { force: opts.force, dryRun: opts.dryRun });
+    for (const r of results) {
+      console.log(`${r.written ? "write" : opts.dryRun ? "would" : "keep "} ${r.name} -> ${r.file}`);
+    }
+    if (results.length === 0) console.log("the registry maps no components with a file next to it");
+    else console.log(`
+review the manifests, then push each section: botlr push <name> --create`);
+  })
+);
+program.parseAsync(process.argv).catch((error) => fail(error.message));
+//# sourceMappingURL=cli.js.map