@botlr/cli 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,601 @@
+// 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, overrides = {}, 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 = overrides.baseUrl ?? env.BOTLR_BASE_URL ?? file.baseUrl;
+  const appId = overrides.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 = overrides.dir ? path.resolve(cwd, overrides.dir) : path.resolve(root, env.BOTLR_SECTIONS_DIR ?? file.sectionsDir ?? DEFAULT_SECTIONS_DIR);
+  return {
+    root,
+    configPath,
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    appId,
+    framework: overrides.framework ?? env.BOTLR_FRAMEWORK ?? file.framework ?? DEFAULT_FRAMEWORK,
+    sectionsDir,
+    apiKey: env.BOTLR_API_KEY || void 0,
+    personalToken: env.BOTLR_PAT || void 0
+  };
+}
+
+// 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/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/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/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/pull.ts
+import { contentHash } from "@botlr/sdk";
+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/list.ts
+async function listSections(config) {
+  const client = clientFor(config);
+  const listing = await client.sections.list({ framework: config.framework });
+  return listing.sections;
+}
+
+// src/commands/status.ts
+import { contentHash as contentHash3 } from "@botlr/sdk";
+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/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;
+}
+export {
+  CONFIG_FILE,
+  ConfigError,
+  DEFAULT_FRAMEWORK,
+  DEFAULT_SECTIONS_DIR,
+  LOCK_DIR,
+  LOCK_FILE,
+  MANIFEST_SUFFIX,
+  ManifestError,
+  REGISTRY_FILE,
+  clientFor,
+  computeStatus,
+  deriveManifests,
+  findConfigFile,
+  hasRegistry,
+  initSections,
+  listManifests,
+  listSections,
+  loadConfig,
+  lockPath,
+  manifestPath,
+  parseDefinition,
+  parseImports,
+  parseRegistry,
+  pullSections,
+  pushSection,
+  readConfigFile,
+  readLock,
+  readManifest,
+  readNpmVersions,
+  readSectionFiles,
+  remoteForLock,
+  safeJoin,
+  sectionStatuses,
+  updateLock,
+  validateManifest,
+  writeLock,
+  writeManifest,
+  writeSectionFiles
+};
+//# sourceMappingURL=index.js.map