@lunora/config 1.0.0-alpha.7 → 1.0.0-alpha.71

package/dist/packem_shared/WORKERS_CACHE_MIN_DATE-CaXbS7CX.mjs

@@ -0,0 +1,11 @@
+const WORKERS_CACHE_MIN_DATE = "2026-05-01";
+const isCacheEnabled = (parsed) => {
+  if (!parsed) {
+    return false;
+  }
+  const topLevel = typeof parsed.cache === "object" && parsed.cache !== null && parsed.cache.enabled === true;
+  const inExports = typeof parsed.exports === "object" && parsed.exports !== null && Object.values(parsed.exports).some((entry) => typeof entry === "object" && entry !== null && entry.cache?.enabled === true);
+  return topLevel || inExports;
+};
+
+export { WORKERS_CACHE_MIN_DATE, isCacheEnabled };

package/dist/packem_shared/assetContentType-ByZjeV3D.mjs

@@ -0,0 +1,72 @@
+import { readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { normalize, join, relative, isAbsolute, dirname } from 'node:path';
+
+const loadStudioAssets = (logger, resolveFrom = import.meta.url) => {
+  try {
+    const require = createRequire(resolveFrom);
+    return {
+      script: readFileSync(require.resolve("@lunora/studio/standalone/studio.js")),
+      styles: readFileSync(require.resolve("@lunora/studio/styles.css"))
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warnOnce?.(`[lunora] studio assets unavailable (build @lunora/studio?): ${message}`);
+    return void 0;
+  }
+};
+const studioAssetsStamp = (resolveFrom = import.meta.url) => {
+  try {
+    const require = createRequire(resolveFrom);
+    const scriptMtime = statSync(require.resolve("@lunora/studio/standalone/studio.js")).mtimeMs;
+    const stylesMtime = statSync(require.resolve("@lunora/studio/styles.css")).mtimeMs;
+    return Math.max(scriptMtime, stylesMtime);
+  } catch {
+    return void 0;
+  }
+};
+const resolveStandaloneDirectory = (resolveFrom = import.meta.url) => {
+  try {
+    return dirname(createRequire(resolveFrom).resolve("@lunora/studio/standalone/studio.js"));
+  } catch {
+    return void 0;
+  }
+};
+const resolveContainedFile = (directory, fileName) => {
+  if (fileName === "" || fileName === "." || fileName === ".." || fileName.includes("/") || fileName.includes("\\") || fileName.includes("\0")) {
+    return void 0;
+  }
+  const resolved = normalize(join(directory, fileName));
+  const relativePath = relative(directory, resolved);
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath) || relativePath.includes("/") || relativePath.includes("\\")) {
+    return void 0;
+  }
+  return resolved;
+};
+const readStandaloneAsset = (fileName, resolveFrom = import.meta.url) => {
+  const directory = resolveStandaloneDirectory(resolveFrom);
+  if (directory === void 0) {
+    return void 0;
+  }
+  const resolved = resolveContainedFile(directory, fileName);
+  if (resolved === void 0) {
+    return void 0;
+  }
+  try {
+    return readFileSync(resolved);
+  } catch {
+    return void 0;
+  }
+};
+const isStandaloneModulePath = (pathname) => pathname.endsWith(".js") || pathname.endsWith(".js.map");
+const assetContentType = (fileName) => {
+  if (fileName.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (fileName.endsWith(".map")) {
+    return "application/json; charset=utf-8";
+  }
+  return "text/javascript; charset=utf-8";
+};
+
+export { assetContentType, isStandaloneModulePath, loadStudioAssets, readStandaloneAsset, resolveContainedFile, resolveStandaloneDirectory, studioAssetsStamp };

package/dist/packem_shared/{buildPackageSecretsBlock-S74dgmwy.mjs → buildPackageSecretsBlock-B-dWb-Sa.mjs}

@@ -1,9 +1,11 @@
 import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, parseDevVariableEntries, DEV_VARS_NEWLINE, splitDevVariableLine, unquoteDevVariable } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
-import { secretsForPackages } from './PACKAGE_SECRETS_REGISTRY-CySy5vR_.mjs';
+import { LunoraError } from '@lunora/errors';
+import { DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, splitDevVariableLine, parseDevVariableEntries, DEV_VARS_NEWLINE, unquoteDevVariable } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
+import { CORE_SECRETS, PACKAGE_SECRETS_REGISTRY, secretsForPackages } from './PACKAGE_SECRETS_REGISTRY-BeRSvrl5.mjs';
 
+const requiredSecrets = (packageNames) => [...CORE_SECRETS, ...secretsForPackages(packageNames)];
 const SECRET_BYTES = 32;
 const SECRET_KEY = /(?:KEY|PASSWORD|SECRET|TOKEN)$/u;
 const PLACEHOLDER_MARKERS = [
@@ -44,7 +46,12 @@ const isPlaceholderValue = (value) => {
 };
 const isPlaceholder = (rawValue) => isPlaceholderValue(unquoteDevVariable(rawValue.trim()));
 const defaultRandomHex = (bytes) => randomBytes(bytes).toString("hex");
-const generatedSecretFor = (key, rawValue, randomHex) => SECRET_KEY.test(key) && isPlaceholder(rawValue) ? randomHex(SECRET_BYTES) : void 0;
+const PROVIDER_SECRET_KEYS = new Set(
+  [...CORE_SECRETS, ...Object.values(PACKAGE_SECRETS_REGISTRY).flat()].filter((entry) => SECRET_KEY.test(entry.key) && entry.placeholderValue.startsWith("<")).map((entry) => entry.key)
+);
+const isMintableSecretKey = (key) => SECRET_KEY.test(key) && !PROVIDER_SECRET_KEYS.has(key);
+const generatedSecretFor = (key, rawValue, randomHex) => isMintableSecretKey(key) && isPlaceholder(rawValue) ? randomHex(SECRET_BYTES) : void 0;
+const generateSecretValue = (randomHex = defaultRandomHex) => randomHex(SECRET_BYTES);
 const planDevVariablesScaffold = (input) => {
   if (input.devVarsExists) {
     return { status: "exists" };
@@ -98,19 +105,48 @@ const atomicCreateDevVariables = (path, content) => {
     throw error;
   }
 };
-const appendDevVariables = (path, additions) => {
-  const existing = readFileSync(path, "utf8");
-  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  const content = `${existing}${separator}${additions.join("\n")}
-`;
-  const temporaryPath = `${path}.tmp-${String(process.pid)}`;
+const APPEND_MAX_ATTEMPTS = 5;
+const fingerprintOf = (path) => {
   try {
-    writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
-    renameSync(temporaryPath, path);
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    throw error;
+    const stats = statSync(path);
+    return { mtimeMs: stats.mtimeMs, size: stats.size };
+  } catch {
+    return void 0;
+  }
+};
+const sameFingerprint = (a, b) => {
+  if (a === void 0 || b === void 0) {
+    return false;
+  }
+  return a.mtimeMs === b.mtimeMs && a.size === b.size;
+};
+const appendDevVariables = (path, buildAdditions) => {
+  for (let attempt = 0; attempt < APPEND_MAX_ATTEMPTS; attempt += 1) {
+    const beforeFingerprint = fingerprintOf(path);
+    const existing = readFileSync(path, "utf8");
+    const additions = buildAdditions(existing);
+    if (additions.length === 0) {
+      return [];
+    }
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    const content = `${existing}${separator}${additions.join("\n")}
+`;
+    const temporaryPath = `${path}.tmp-${String(process.pid)}-${randomBytes(6).toString("hex")}`;
+    try {
+      writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
+      const beforeRenameFingerprint = fingerprintOf(path);
+      if (!sameFingerprint(beforeFingerprint, beforeRenameFingerprint)) {
+        rmSync(temporaryPath, { force: true });
+        continue;
+      }
+      renameSync(temporaryPath, path);
+      return additions;
+    } catch (error) {
+      rmSync(temporaryPath, { force: true });
+      throw error;
+    }
   }
+  throw new LunoraError("INTERNAL", `Failed to append to ${path} after ${String(APPEND_MAX_ATTEMPTS)} attempts — a concurrent writer kept winning the race.`);
 };
 const ensureDevVariables = async (deps) => {
   const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
@@ -146,16 +182,24 @@ const ensureDevVariables = async (deps) => {
     deps.info(`Skipped — add ${list} to ${DEV_VARS_FILE} when you're ready.`);
     return { addedKeys: [], generatedKeys: [], status: "declined" };
   }
-  appendDevVariables(devVariablesPath, augment.additions);
-  deps.info(`Updated ${DEV_VARS_FILE} — added ${list}${generatedSuffix(augment.generatedKeys)}.`);
-  return { addedKeys: augment.missingKeys, generatedKeys: augment.generatedKeys, status: "augmented" };
+  const written = appendDevVariables(
+    devVariablesPath,
+    (currentContent) => planDevVariablesAugment({ existingContent: currentContent, exampleContent, randomHex: deps.randomHex }).additions
+  );
+  const writtenKeys = written.map((line) => splitDevVariableLine(line)?.key).filter((key) => key !== void 0);
+  if (writtenKeys.length === 0) {
+    return { addedKeys: [], generatedKeys: [], status: "exists" };
+  }
+  const writtenGeneratedKeys = augment.generatedKeys.filter((key) => writtenKeys.includes(key));
+  deps.info(`Updated ${DEV_VARS_FILE} — added ${writtenKeys.join(", ")}${generatedSuffix(writtenGeneratedKeys)}.`);
+  return { addedKeys: writtenKeys, generatedKeys: writtenGeneratedKeys, status: "augmented" };
 };
 const secretEntryBlock = (entry) => {
   const lines = [`# ${entry.description}`, `# Docs: ${entry.docsUrl}`, `${entry.key}="${entry.placeholderValue}"`];
   return lines.join("\n");
 };
 const buildPackageSecretsBlock = (packageNames, existingKeys) => {
-  const entries = secretsForPackages(packageNames).filter((entry) => !existingKeys.has(entry.key));
+  const entries = requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key));
   if (entries.length === 0) {
     return "";
   }
@@ -181,7 +225,57 @@ ${block}
     rmSync(temporaryPath, { force: true });
     throw error;
   }
-  return secretsForPackages(packageNames).filter((entry) => !existingKeys.has(entry.key)).map((entry) => entry.key);
+  return requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key)).map((entry) => entry.key);
+};
+const planDevSecretsFill = (input) => {
+  const randomHex = input.randomHex ?? defaultRandomHex;
+  const filledKeys = [];
+  const lines = input.existingContent.split(DEV_VARS_NEWLINE).map((line) => {
+    const parsed = splitDevVariableLine(line);
+    const secret = parsed ? generatedSecretFor(parsed.key, parsed.value, randomHex) : void 0;
+    if (!parsed || secret === void 0) {
+      return line;
+    }
+    filledKeys.push(parsed.key);
+    return `${parsed.key}="${secret}"`;
+  });
+  const present = new Set(parseDevVariableEntries(input.existingContent).map((entry) => entry.key));
+  const addedKeys = [];
+  const additions = [];
+  for (const entry of CORE_SECRETS) {
+    if (present.has(entry.key)) {
+      continue;
+    }
+    addedKeys.push(entry.key);
+    additions.push(`# ${entry.description}`, `${entry.key}="${randomHex(SECRET_BYTES)}"`);
+  }
+  const body = lines.join("\n");
+  if (additions.length === 0) {
+    return { addedKeys, content: body, filledKeys };
+  }
+  const separator = body === "" || body.endsWith("\n") ? "" : "\n";
+  return { addedKeys, content: `${body}${separator}${additions.join("\n")}
+`, filledKeys };
+};
+const fillDevSecrets = (deps) => {
+  const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
+  const exists = existsSync(devVariablesPath);
+  const existingContent = exists ? readFileSync(devVariablesPath, "utf8") : "";
+  const plan = planDevSecretsFill({ existingContent, randomHex: deps.randomHex });
+  if (plan.filledKeys.length === 0 && plan.addedKeys.length === 0) {
+    return { addedKeys: [], filledKeys: [], status: "unchanged" };
+  }
+  const temporaryPath = `${devVariablesPath}.tmp-${String(process.pid)}`;
+  try {
+    writeFileSync(temporaryPath, plan.content, { encoding: "utf8", mode: 384 });
+    renameSync(temporaryPath, devVariablesPath);
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+  const generated = [...plan.filledKeys, ...plan.addedKeys];
+  deps.info?.(`Generated ${String(generated.length)} dev secret(s) in ${DEV_VARS_FILE}: ${generated.join(", ")}`);
+  return { addedKeys: plan.addedKeys, filledKeys: plan.filledKeys, status: exists ? "filled" : "created" };
 };
 
-export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, isPlaceholderValue, planDevVariablesAugment, planDevVariablesScaffold };
+export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, fillDevSecrets, generateSecretValue, isMintableSecretKey, isPlaceholderValue, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, requiredSecrets };

package/dist/packem_shared/collectWranglerSecretVariables-p4ezBYQ4.mjs

@@ -0,0 +1,56 @@
+import { relative } from 'node:path';
+import { secretKindOf, redact } from '@lunora/codegen';
+import { isPlaceholderValue } from './buildPackageSecretsBlock-B-dWb-Sa.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const MIN_SECRET_NAMED_VALUE_LENGTH = 8;
+const SECRET_WORD_TOKENS = /* @__PURE__ */ new Set(["CREDENTIAL", "CREDENTIALS", "DSN", "PASSPHRASE", "PASSWD", "PASSWORD", "SECRET", "TOKEN"]);
+const SECRET_KEY_SUFFIXES = ["ACCESS_KEY", "API_KEY", "ENCRYPTION_KEY", "PRIVATE_KEY", "SIGNING_KEY"];
+const PUBLIC_KEY_TOKENS = /* @__PURE__ */ new Set(["PUBLIC", "PUBLISHABLE"]);
+const KEY_SEPARATOR_RE = /[_-]/u;
+const keyTokens = (key) => key.toUpperCase().split(KEY_SEPARATOR_RE);
+const isSecretKeyName = (key) => {
+  const normalized = key.toUpperCase().replaceAll("-", "_");
+  if (keyTokens(key).some((token) => SECRET_WORD_TOKENS.has(token))) {
+    return true;
+  }
+  return SECRET_KEY_SUFFIXES.some((suffix) => normalized === suffix || normalized.endsWith(`_${suffix}`));
+};
+const isPublicKeyName = (key) => keyTokens(key).some((token) => PUBLIC_KEY_TOKENS.has(token));
+const scanWranglerVariablesForSecrets = (variables, file) => {
+  if (variables === void 0) {
+    return [];
+  }
+  const findings = [];
+  for (const [key, rawValue] of Object.entries(variables)) {
+    if (typeof rawValue !== "string") {
+      continue;
+    }
+    if (isPlaceholderValue(rawValue)) {
+      continue;
+    }
+    if (isPublicKeyName(key)) {
+      continue;
+    }
+    const shapeKind = secretKindOf(rawValue);
+    const kind = shapeKind ?? (isSecretKeyName(key) && rawValue.length >= MIN_SECRET_NAMED_VALUE_LENGTH ? "secret_named_var" : void 0);
+    if (kind === void 0) {
+      continue;
+    }
+    findings.push({ file, key, kind, preview: redact(rawValue) });
+  }
+  return findings;
+};
+const collectWranglerSecretVariables = (projectRoot) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (wranglerPath === void 0) {
+    return [];
+  }
+  const { parsed } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return [];
+  }
+  return scanWranglerVariablesForSecrets(parsed.vars, relative(projectRoot, wranglerPath));
+};
+
+export { collectWranglerSecretVariables, scanWranglerVariablesForSecrets };

package/dist/packem_shared/{createConfirm-fvpdgJ9s.mjs → createConfirm-BMikeJC9.mjs}

@@ -28,13 +28,13 @@ const promptSelect = async (message, options, settings) => {
   const lines = options.map(
     (option, index) => `  ${String(index + 1)}) ${option.label}${option.description === void 0 ? "" : ` — ${option.description}`}`
   );
-  const promptText = `${message}
+  const promptMessage = `${message}
 ${lines.join("\n")}
 > ${defaultIndex >= 0 ? `[${String(defaultIndex + 1)}] ` : ""}`;
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
     const answer = await new Promise((resolve) => {
-      rl.question(promptText, (input) => {
+      rl.question(promptMessage, (input) => {
         resolve(input);
       });
     });
@@ -52,6 +52,23 @@ ${lines.join("\n")}
     rl.close();
   }
 };
+const promptText = async (message, settings) => {
+  if (!isInteractive()) {
+    return settings?.default;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(message, (input) => {
+        resolve(input);
+      });
+    });
+    const trimmed = answer.trim();
+    return trimmed === "" ? settings?.default : trimmed;
+  } finally {
+    rl.close();
+  }
+};
 const promptMultiSelect = async (message, options, settings) => {
   const defaults = settings?.defaults ?? [];
   if (!isInteractive() || options.length === 0) {
@@ -61,13 +78,13 @@ const promptMultiSelect = async (message, options, settings) => {
     (option, index) => `  ${String(index + 1)}) ${option.label}${option.description === void 0 ? "" : ` — ${option.description}`}`
   );
   const defaultHint = defaults.length === 0 ? "" : `[${defaults.join(", ")}] `;
-  const promptText = `${message} (comma-separated; Enter for default)
+  const promptMessage = `${message} (comma-separated; Enter for default)
 ${lines.join("\n")}
 > ${defaultHint}`;
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
     const answer = await new Promise((resolve) => {
-      rl.question(promptText, (input) => {
+      rl.question(promptMessage, (input) => {
         resolve(input);
       });
     });
@@ -97,4 +114,4 @@ ${lines.join("\n")}
   }
 };
 
-export { createConfirm, isInteractive, promptMultiSelect, promptSelect, promptYesNo };
+export { createConfirm, isInteractive, promptMultiSelect, promptSelect, promptText, promptYesNo };

package/dist/packem_shared/{detectFramework-Br-BcPBq.mjs → detectFramework-U08038Yp.mjs}

@@ -12,7 +12,7 @@ const FRAMEWORK_SIGNATURES = [
   { class: "B", dependency: "astro", framework: "astro" }
 ];
 const STANDALONE = { class: "C", framework: "none" };
-const readDependencyNames = (root) => {
+const readProjectDependencyNames = (root) => {
   const packageJsonPath = join(root, "package.json");
   if (!existsSync(packageJsonPath)) {
     return /* @__PURE__ */ new Set();
@@ -26,7 +26,7 @@ const readDependencyNames = (root) => {
   }
 };
 const detectFramework = (root) => {
-  const dependencies = readDependencyNames(root);
+  const dependencies = readProjectDependencyNames(root);
   if (dependencies.size === 0) {
     return STANDALONE;
   }
@@ -38,4 +38,4 @@ const detectFramework = (root) => {
   return STANDALONE;
 };
 
-export { detectFramework };
+export { detectFramework, readProjectDependencyNames };

package/dist/packem_shared/discoverAgentInfo-eXA3hF4v.mjs

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { AGENTS_FILENAME, discoverAgents } from '@lunora/codegen';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+
+const discoverAgentInfo = (projectRoot, schemaDirectory) => {
+  const agentsPath = join(projectRoot, schemaDirectory, AGENTS_FILENAME);
+  if (!existsSync(agentsPath)) {
+    return { agents: [] };
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { agents: discoverAgents(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { agents: [], error: error instanceof Error ? error.message : String(error) };
+  }
+};
+
+export { discoverAgentInfo };

package/dist/packem_shared/{discoverSchemaInfo-DWtypqpP.mjs → discoverSchemaInfo-BB-CKlTK.mjs}

@@ -10,7 +10,7 @@ const discoverSchemaInfo = (projectRoot, schemaDirectory) => {
   }
   try {
     const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-    const schema = discoverSchema(project, schemaPath);
+    const schema = discoverSchema(project, schemaPath, projectRoot);
     return {
       info: {
         hasGlobalTable: schema.tables.some((table) => table.shardMode === "global"),