@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/insertSchemaExtension-BuzF6-t2.mjs

@@ -0,0 +1,59 @@
+import { Project, SyntaxKind } from 'ts-morph';
+
+const VALID_JS_IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
+const startMarker = (key) => `// lunora:add:${key}:start`;
+const endMarker = (key) => `// lunora:add:${key}:end`;
+const extensionImportSpecifier = (key) => `./${key}/schema`;
+const findDefineSchemaCall = (callExpressions) => {
+  for (const call of callExpressions) {
+    if (call.getExpression().getText() === "defineSchema") {
+      return call;
+    }
+  }
+  return void 0;
+};
+const insertSchemaExtension = (source, key) => {
+  if (!VALID_JS_IDENTIFIER.test(key)) {
+    return { ok: false, reason: "invalid-identifier" };
+  }
+  if (source.includes(startMarker(key))) {
+    return { ok: false, reason: "already-applied" };
+  }
+  const project = new Project({
+    compilerOptions: { allowJs: true },
+    useInMemoryFileSystem: true
+  });
+  const sourceFile = project.createSourceFile("schema.ts", source, { overwrite: true });
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+  const defineSchemaCall = findDefineSchemaCall(callExpressions);
+  if (!defineSchemaCall) {
+    return { ok: false, reason: "no-define-schema" };
+  }
+  const tablesArgument = defineSchemaCall.getArguments()[0];
+  if (tablesArgument?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
+    return { ok: false, reason: "non-object-argument" };
+  }
+  const variableDeclaration = defineSchemaCall.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+  if (!variableDeclaration) {
+    return { ok: false, reason: "no-define-schema" };
+  }
+  const initializer = variableDeclaration.getInitializer();
+  if (!initializer) {
+    return { ok: false, reason: "no-define-schema" };
+  }
+  const insertAt = initializer.getEnd();
+  const chainText = `
+    ${startMarker(key)}
+    .extend(${key}.extension)
+    ${endMarker(key)}
+`;
+  sourceFile.insertText(insertAt, chainText);
+  const importText = `${startMarker(key)}
+import { ${key} } from "${extensionImportSpecifier(key)}";
+${endMarker(key)}
+`;
+  sourceFile.insertText(0, importText);
+  return { ok: true, text: sourceFile.getFullText() };
+};
+
+export { insertSchemaExtension };

package/dist/packem_shared/open-url-Dfq6fAyT.mjs

@@ -0,0 +1,41 @@
+import { spawn } from 'node:child_process';
+import { platform } from 'node:os';
+
+const platformCommand = () => {
+  const os = platform();
+  if (os === "darwin") {
+    return { args: [], command: "open" };
+  }
+  if (os === "win32") {
+    return { args: ["/c", "start", ""], command: "cmd" };
+  }
+  return { args: [], command: "xdg-open" };
+};
+const escapeForCmd = (url) => url.replaceAll("%", "%25").replaceAll("&", "%26").replaceAll("|", "%7C").replaceAll("^", "%5E").replaceAll("<", "%3C").replaceAll(">", "%3E").replaceAll("(", "%28").replaceAll(")", "%29").replaceAll('"', "%22").replaceAll("!", "%21");
+const platformOpener = (url) => new Promise((resolve, reject) => {
+  const { args, command } = platformCommand();
+  const safeUrl = platform() === "win32" ? escapeForCmd(url) : url;
+  const child = spawn(command, [...args, safeUrl], { detached: true, stdio: "ignore" });
+  child.once("error", (error) => {
+    reject(error);
+  });
+  child.once("spawn", () => {
+    child.unref();
+    resolve();
+  });
+});
+const openUrl = async (url, options = {}) => {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Refusing to open non-http(s) URL: ${url}`);
+  }
+  const opener = options.opener ?? platformOpener;
+  await opener(url);
+};
+
+export { openUrl as o };

package/dist/packem_shared/output-format-7gyGR3h8.mjs

@@ -0,0 +1,17 @@
+import { createStderrLogger } from './createLogger-CHPNjFw2.mjs';
+
+const OUTPUT_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
+const validateOutputFormat = (command, format) => {
+  if (format !== void 0 && !OUTPUT_FORMATS.has(format)) {
+    return `${command}: unknown --format "${format}" — expected pretty | json`;
+  }
+  return void 0;
+};
+const isJsonFormat = (format) => format === "json";
+const loggerForFormat = (format, prettyLogger) => isJsonFormat(format) ? createStderrLogger() : prettyLogger;
+const printJson = (result) => {
+  process.stdout.write(`${JSON.stringify(result, void 0, 2)}
+`);
+};
+
+export { isJsonFormat as i, loggerForFormat as l, printJson as p, validateOutputFormat as v };

package/dist/packem_shared/parseArgs-YXFuKdEk.mjs

@@ -0,0 +1,56 @@
+const consumeLongOption = (body, next, booleanFlags, accumulator) => {
+  const eqIndex = body.indexOf("=");
+  if (eqIndex !== -1) {
+    accumulator.options[body.slice(0, eqIndex)] = body.slice(eqIndex + 1);
+    return 1;
+  }
+  if (booleanFlags.has(body)) {
+    accumulator.flags[body] = true;
+    return 1;
+  }
+  if (next !== void 0 && !next.startsWith("-")) {
+    accumulator.options[body] = next;
+    return 2;
+  }
+  accumulator.flags[body] = true;
+  return 1;
+};
+const consumeShortOption = (body, next, accumulator) => {
+  if (body.length > 1) {
+    accumulator.options[body[0]] = body.slice(1);
+    return 1;
+  }
+  if (next !== void 0 && !next.startsWith("-")) {
+    accumulator.options[body] = next;
+    return 2;
+  }
+  accumulator.flags[body] = true;
+  return 1;
+};
+const parseArgs = (argv, booleanFlags = /* @__PURE__ */ new Set()) => {
+  const accumulator = { flags: {}, options: {}, positional: [] };
+  let index = 0;
+  let terminated = false;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === void 0) {
+      index += 1;
+      continue;
+    }
+    if (terminated || !token.startsWith("-") || token.length === 1) {
+      accumulator.positional.push(token);
+      index += 1;
+      continue;
+    }
+    if (token === "--") {
+      terminated = true;
+      index += 1;
+      continue;
+    }
+    const next = argv[index + 1];
+    index += token.startsWith("--") ? consumeLongOption(token.slice(2), next, booleanFlags, accumulator) : consumeShortOption(token.slice(1), next, accumulator);
+  }
+  return { flags: accumulator.flags, options: accumulator.options, positional: accumulator.positional };
+};
+
+export { parseArgs as default };

package/dist/packem_shared/parseManifest--vZf2FY1.mjs

@@ -0,0 +1,94 @@
+const NEWLINE_PRESENT = /[\r\n]/u;
+const VALID_ENV_NAME = /^[A-Za-z_]\w*$/u;
+const VALID_ITEM_NAME = /^[A-Za-z0-9][\w-]*$/u;
+const parseManifest = (raw, itemName) => {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`registry.json for "${itemName}" is not an object`);
+  }
+  const record = raw;
+  const { name } = record;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`registry.json for "${itemName}" is missing a string "name"`);
+  }
+  if (!VALID_ITEM_NAME.test(name)) {
+    throw new Error(
+      `registry.json for "${itemName}": name "${name}" must match ${VALID_ITEM_NAME.source} (letters, digits, "-", "_"; no path separators, "..", or code)`
+    );
+  }
+  const filesRaw = record.files;
+  if (!Array.isArray(filesRaw)) {
+    throw new TypeError(`registry.json for "${itemName}" is missing a "files" array`);
+  }
+  const files = filesRaw.map((entry, index) => {
+    if (typeof entry !== "object" || entry === null) {
+      throw new Error(`registry.json "${itemName}": files[${String(index)}] is not an object`);
+    }
+    const fileRecord = entry;
+    const { from } = fileRecord;
+    const { to } = fileRecord;
+    const { merge } = fileRecord;
+    if (typeof from !== "string" || typeof to !== "string") {
+      throw new TypeError(`registry.json "${itemName}": files[${String(index)}] needs string "from" and "to"`);
+    }
+    if (merge !== "create-or-skip" && merge !== "schema-extension") {
+      throw new Error(`registry.json "${itemName}": files[${String(index)}].merge must be "create-or-skip" or "schema-extension"`);
+    }
+    for (const [field, value] of [
+      ["from", from],
+      ["to", to]
+    ]) {
+      if (value.includes("..") || value.startsWith("/")) {
+        throw new Error(`registry.json "${itemName}": files[${String(index)}].${field} "${value}" must be a relative path without ".."`);
+      }
+    }
+    return { from, merge, to };
+  });
+  const asStringMap = (value) => typeof value === "object" && value !== null ? value : void 0;
+  const deps = asStringMap(record.deps);
+  const devDependencies = asStringMap(record.devDependencies);
+  const requires = Array.isArray(record.requires) ? record.requires.filter((value) => typeof value === "string") : void 0;
+  const bindings = Array.isArray(record.bindings) ? record.bindings.filter((value) => {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const bindingRecord = value;
+    return Array.isArray(bindingRecord.path) && bindingRecord.path.every((segment) => typeof segment === "string");
+  }) : void 0;
+  const envVariables = Array.isArray(record.envVars) ? record.envVars.filter(
+    (value) => typeof value === "object" && value !== null && typeof value.name === "string"
+  ).map((entry) => {
+    const hasValue = typeof entry.value === "string";
+    if (!VALID_ENV_NAME.test(entry.name)) {
+      throw new Error(
+        `registry.json "${itemName}": envVars["${entry.name}"].name must match ${VALID_ENV_NAME.source} (letters, digits, underscore; no "=" or newline)`
+      );
+    }
+    if (hasValue && NEWLINE_PRESENT.test(entry.value)) {
+      throw new Error(`registry.json "${itemName}": envVars["${entry.name}"].value must not contain a newline`);
+    }
+    if (typeof entry.description === "string" && NEWLINE_PRESENT.test(entry.description)) {
+      throw new Error(`registry.json "${itemName}": envVars["${entry.name}"].description must not contain a newline`);
+    }
+    return {
+      ...typeof entry.description === "string" ? { description: entry.description } : {},
+      name: entry.name,
+      // Default to secret unless a concrete value is provided.
+      secret: typeof entry.secret === "boolean" ? entry.secret : !hasValue,
+      ...hasValue ? { value: entry.value } : {}
+    };
+  }) : void 0;
+  return {
+    bindings,
+    deps,
+    description: typeof record.description === "string" ? record.description : void 0,
+    devDependencies,
+    docs: typeof record.docs === "string" ? record.docs : void 0,
+    envVars: envVariables,
+    files,
+    name,
+    requires,
+    title: typeof record.title === "string" ? record.title : void 0
+  };
+};
+
+export { parseManifest as default };

package/dist/packem_shared/resolve-target-qbsJ_5sF.mjs

@@ -0,0 +1,16 @@
+import { readLinkedProject } from '@lunora/config';
+
+const resolveWorkerUrl = ({ cwd, url }) => {
+  if (url !== void 0 && url !== "") {
+    return url;
+  }
+  return readLinkedProject(cwd)?.workerUrl;
+};
+const resolveProductionWorkerUrl = ({ cwd, prod, url }) => {
+  if (url !== void 0 && url !== "") {
+    return url;
+  }
+  return prod ? readLinkedProject(cwd)?.workerUrl : void 0;
+};
+
+export { resolveProductionWorkerUrl as a, resolveWorkerUrl as r };