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

package/dist/packem_shared/{reconcileWranglerBindings-DTHmqTbL.mjs → reconcileWranglerBindings-2Cww5VLa.mjs}

@@ -1,9 +1,8 @@
 import { writeFileSync } from 'node:fs';
 import { containerBuildTag } from '@lunora/container';
-import { modify, applyEdits } from 'jsonc-parser';
+import { a as applyModify } from './jsonc-edit-SbcD7MAe.mjs';
 import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
 
-const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
 const D1_PLACEHOLDER_ID = "<replace-with-d1-create-id>";
 const collectExportGaps = (inferred) => {
   const gaps = [];
@@ -17,13 +16,19 @@ const collectExportGaps = (inferred) => {
       gaps.push({ className: workflow.className, exportName: workflow.exportName, kind: "workflow", module: "workflows" });
     }
   }
+  for (const agent of inferred.agents) {
+    if (!agent.exported) {
+      gaps.push({ className: agent.className, exportName: agent.exportName, kind: "agent", module: "agents" });
+    }
+  }
   return gaps;
 };
 const collectHintBindingWarnings = (inferred, parsed) => {
+  const flagshipBindingMissing = inferred.flagshipBinding !== void 0 && !(parsed?.flagship ?? []).some((entry) => entry.binding === inferred.flagshipBinding);
   const rules = [
     [
       inferred.usesKv && (parsed?.kv_namespaces?.length ?? 0) === 0,
-      "@lunora/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
+      "@lunora/bindings/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
     ],
     [
       inferred.usesHyperdrive && (parsed?.hyperdrive?.length ?? 0) === 0,
@@ -31,11 +36,31 @@ const collectHintBindingWarnings = (inferred, parsed) => {
     ],
     [
       inferred.usesPipelines && (parsed?.pipelines?.length ?? 0) === 0,
-      "@lunora/pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+      "ctx.pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+    ],
+    [
+      flagshipBindingMissing,
+      `lunora/flags.ts uses Flagship in binding mode but no flagship binding "${inferred.flagshipBinding ?? ""}" exists; add a flagship entry ({ binding: "${inferred.flagshipBinding ?? ""}", app_id }) — the app_id can't be auto-provisioned.`
     ]
   ];
   return rules.filter(([active]) => active).map(([, warning]) => warning);
 };
+const collectX402Warnings = (inferred) => {
+  const rules = [
+    [
+      inferred.usesX402Charge,
+      "@lunora/x402/charge is used; set the recipient wallet address as a [vars] entry (the var name is your choice) and pass it to the charge config — the x402 facilitator settles USDC to that address."
+    ],
+    [
+      inferred.usesX402Pay,
+      "@lunora/x402/pay is used (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding holding the agent wallet key (binding name == signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars."
+    ]
+  ];
+  return rules.filter(([active]) => active).map(([, warning]) => warning);
+};
+const unexportedDeclarationWarnings = (kind, module, declarations) => declarations.filter((declaration) => !declaration.exported).map(
+  (declaration) => `${kind} "${declaration.exportName}" is declared but ${declaration.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/${module}"\` so its binding can be provisioned.`
+);
 const collectWarnings = (inferred, parsed) => {
   const exported = new Set(inferred.durableObjects.map((object) => object.className));
   const warnings = [];
@@ -54,20 +79,11 @@ const collectWarnings = (inferred, parsed) => {
   if (inferred.usesScheduler && !exported.has("SchedulerDO")) {
     warnings.push("@lunora/scheduler is used but the worker entry exports no SchedulerDO; export it so the SCHEDULER binding can be provisioned.");
   }
-  for (const container of inferred.containers) {
-    if (!container.exported) {
-      warnings.push(
-        `container "${container.exportName}" is declared but ${container.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/containers"\` so its binding can be provisioned.`
-      );
-    }
-  }
-  for (const workflow of inferred.workflows) {
-    if (!workflow.exported) {
-      warnings.push(
-        `workflow "${workflow.exportName}" is declared but ${workflow.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/workflows"\` so its binding can be provisioned.`
-      );
-    }
-  }
+  warnings.push(
+    ...unexportedDeclarationWarnings("container", "containers", inferred.containers),
+    ...unexportedDeclarationWarnings("workflow", "workflows", inferred.workflows),
+    ...unexportedDeclarationWarnings("agent", "agents", inferred.agents)
+  );
   if (inferred.containers.length > 0 && parsed?.observability?.enabled === false) {
     warnings.push("containers are declared but observability is explicitly disabled in wrangler.jsonc — container logs will not be captured.");
   }
@@ -76,13 +92,9 @@ const collectWarnings = (inferred, parsed) => {
       "@lunora/payment is used; set the provider secrets in .dev.vars — STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)."
     );
   }
-  warnings.push(...collectHintBindingWarnings(inferred, parsed));
+  warnings.push(...collectX402Warnings(inferred), ...collectHintBindingWarnings(inferred, parsed));
   return warnings;
 };
-const applyModify = (text, path, value) => {
-  const edits = modify(text, [...path], value, FORMATTING);
-  return edits.length > 0 ? applyEdits(text, edits) : text;
-};
 const nextMigrationTag = (migrations) => {
   const used = new Set(migrations.map((migration) => migration.tag));
   let index = 1;
@@ -212,15 +224,77 @@ const reconcileObservability = (text, parsed) => {
 const workflowEntryFor = (workflow) => {
   return { binding: workflow.bindingName, class_name: workflow.className, name: workflow.name };
 };
-const reconcileWorkflows = (text, parsed, workflows) => {
+const agentEntryFor = (agent) => {
+  return { binding: agent.bindingName, class_name: agent.className, name: agent.name };
+};
+const reconcileWorkflows = (text, parsed, workflows, agents = []) => {
   const existing = parsed.workflows ?? [];
   const existingClasses = new Set(existing.map((entry) => entry.class_name));
-  const missing = workflows.filter((workflow) => !existingClasses.has(workflow.className));
-  if (missing.length === 0) {
+  const missingWorkflows = workflows.filter((workflow) => !existingClasses.has(workflow.className));
+  const missingAgents = agents.filter((agent) => !existingClasses.has(agent.className));
+  if (missingWorkflows.length === 0 && missingAgents.length === 0) {
+    return { added: [], text };
+  }
+  const nextText = applyModify(
+    text,
+    ["workflows"],
+    [...existing, ...missingWorkflows.map((workflow) => workflowEntryFor(workflow)), ...missingAgents.map((agent) => agentEntryFor(agent))]
+  );
+  return {
+    added: [...missingWorkflows.map((workflow) => `workflows/${workflow.className}`), ...missingAgents.map((agent) => `workflows/${agent.className}`)],
+    text: nextText
+  };
+};
+const reconcileQueues = (text, parsed, queues) => {
+  const existing = parsed.queues ?? {};
+  const existingProducers = existing.producers ?? [];
+  const existingConsumers = existing.consumers ?? [];
+  const haveProducer = new Set(existingProducers.map((entry) => entry.binding));
+  const haveConsumer = new Set(existingConsumers.map((entry) => entry.queue));
+  const missingProducers = queues.filter((queue) => !haveProducer.has(queue.bindingName));
+  const missingConsumers = queues.filter((queue) => !haveConsumer.has(queue.name));
+  if (missingProducers.length === 0 && missingConsumers.length === 0) {
     return { added: [], text };
   }
-  const nextText = applyModify(text, ["workflows"], [...existing, ...missing.map((workflow) => workflowEntryFor(workflow))]);
-  return { added: missing.map((workflow) => `workflows/${workflow.className}`), text: nextText };
+  const nextProducers = [
+    ...existingProducers,
+    ...missingProducers.map((queue) => {
+      return { binding: queue.bindingName, queue: queue.name };
+    })
+  ];
+  const nextConsumers = [
+    ...existingConsumers,
+    ...missingConsumers.map((queue) => {
+      const consumer = { queue: queue.name };
+      if (queue.mode === "pull") {
+        consumer.type = "http_pull";
+      }
+      if (queue.tuning.maxBatchSize !== void 0) {
+        consumer.max_batch_size = queue.tuning.maxBatchSize;
+      }
+      if (queue.tuning.maxBatchTimeout !== void 0) {
+        consumer.max_batch_timeout = queue.tuning.maxBatchTimeout;
+      }
+      if (queue.tuning.maxRetries !== void 0) {
+        consumer.max_retries = queue.tuning.maxRetries;
+      }
+      if (queue.tuning.deadLetterQueue !== void 0) {
+        consumer.dead_letter_queue = queue.tuning.deadLetterQueue;
+      }
+      if (queue.tuning.retryDelay !== void 0) {
+        consumer.retry_delay = queue.tuning.retryDelay;
+      }
+      return consumer;
+    })
+  ];
+  const nextText = applyModify(text, ["queues"], { consumers: nextConsumers, producers: nextProducers });
+  return {
+    added: [
+      ...missingProducers.map((queue) => `queues.producers/${queue.bindingName}`),
+      ...missingConsumers.map((queue) => `queues.consumers/${queue.name}`)
+    ],
+    text: nextText
+  };
 };
 const reconcileWranglerBindings = (projectRoot, inferred) => {
   const wranglerPath = findWranglerFile(projectRoot);
@@ -234,13 +308,20 @@ const reconcileWranglerBindings = (projectRoot, inferred) => {
   }
   const warnings = collectWarnings(inferred, parsed);
   const exportedContainers = inferred.containers.filter((container) => container.exported);
+  const voiceAgents = inferred.agents.filter(
+    (agent) => agent.exported && agent.voice === true && agent.voiceBindingName !== void 0 && agent.voiceClassName !== void 0
+  );
   const requiredDurableObjects = [
     ...inferred.durableObjects,
     ...exportedContainers.map((container) => {
       return { binding: container.bindingName, className: container.className };
+    }),
+    ...voiceAgents.map((agent) => {
+      return { binding: agent.voiceBindingName, className: agent.voiceClassName };
     })
   ];
   const exportedWorkflows = inferred.workflows.filter((workflow) => workflow.exported);
+  const exportedAgents = inferred.agents.filter((agent) => agent.exported);
   const pipeline = [
     { enabled: true, run: (text2) => reconcileDurableObjects(text2, parsed, requiredDurableObjects) },
     { enabled: inferred.needsD1, run: (text2) => reconcileD1(text2, parsed) },
@@ -250,7 +331,11 @@ const reconcileWranglerBindings = (projectRoot, inferred) => {
     { enabled: inferred.usesAnalytics, run: (text2) => reconcileAnalytics(text2, parsed) },
     { enabled: true, run: (text2) => reconcileObservability(text2, parsed) },
     { enabled: exportedContainers.length > 0, run: (text2) => reconcileContainers(text2, parsed, exportedContainers) },
-    { enabled: exportedWorkflows.length > 0, run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows) }
+    {
+      enabled: exportedWorkflows.length > 0 || exportedAgents.length > 0,
+      run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows, exportedAgents)
+    },
+    { enabled: inferred.queues.length > 0, run: (text2) => reconcileQueues(text2, parsed, inferred.queues) }
   ];
   let text = original;
   const added = [];

package/dist/packem_shared/reconcileWranglerCompatibilityDate-C8c497ag.mjs

@@ -0,0 +1,31 @@
+import { writeFileSync } from 'node:fs';
+import { modify, applyEdits } from 'jsonc-parser';
+import { F as FORMATTING } from './jsonc-edit-SbcD7MAe.mjs';
+import { isCacheEnabled, WORKERS_CACHE_MIN_DATE } from './WORKERS_CACHE_MIN_DATE-CaXbS7CX.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const reconcileWranglerCompatibilityDate = (projectRoot) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (!wranglerPath) {
+    return { changed: false, date: void 0, reason: "wrangler.jsonc not found" };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { changed: false, date: void 0, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
+  }
+  const currentDate = parsed.compatibility_date ?? "";
+  if (!isCacheEnabled(parsed)) {
+    return { changed: false, date: currentDate || void 0, reason: "cache not enabled", wranglerPath };
+  }
+  if (currentDate >= WORKERS_CACHE_MIN_DATE) {
+    return { changed: false, date: currentDate, reason: `compatibility_date already >= ${WORKERS_CACHE_MIN_DATE}`, wranglerPath };
+  }
+  const edits = modify(text, ["compatibility_date"], WORKERS_CACHE_MIN_DATE, FORMATTING);
+  if (edits.length === 0) {
+    return { changed: false, date: currentDate || void 0, reason: "no structural edit produced", wranglerPath };
+  }
+  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
+  return { changed: true, date: WORKERS_CACHE_MIN_DATE, wranglerPath };
+};
+
+export { reconcileWranglerCompatibilityDate };

package/dist/packem_shared/reconcileWranglerCrons-DvsceVFz.mjs

@@ -0,0 +1,29 @@
+import { writeFileSync } from 'node:fs';
+import { modify, applyEdits } from 'jsonc-parser';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const sameTriggers = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+const reconcileWranglerCrons = (projectRoot, cronTriggers) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (!wranglerPath) {
+    return { changed: false, reason: "wrangler.jsonc not found" };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { changed: false, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
+  }
+  const existing = Array.isArray(parsed.triggers?.crons) ? parsed.triggers.crons.filter((value) => typeof value === "string") : [];
+  if (sameTriggers(existing, cronTriggers)) {
+    return { changed: false, reason: "triggers.crons already in sync", wranglerPath };
+  }
+  const edits = modify(text, ["triggers", "crons"], [...cronTriggers], {
+    formattingOptions: { insertSpaces: true, tabSize: 4 }
+  });
+  if (edits.length === 0) {
+    return { changed: false, reason: "no structural edit produced", wranglerPath };
+  }
+  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
+  return { changed: true, wranglerPath };
+};
+
+export { reconcileWranglerCrons };

package/dist/packem_shared/{serveJsonHandler-B4OLTGLS.mjs → serveJsonHandler-Cl2Wqkv8.mjs}

@@ -57,7 +57,7 @@ const csrfRejectionReason = (request) => {
   }
   return void 0;
 };
-const serveJsonHandler = (request, response, handle, projectRoot) => {
+const serveJsonHandler = (request, response, handle, projectRoot, schemaDirectory) => {
   const run = async () => {
     try {
       const rejection = csrfRejectionReason(request);
@@ -73,7 +73,7 @@ const serveJsonHandler = (request, response, handle, projectRoot) => {
         respondJson(response, 400, { error: "invalid-json", ok: false });
         return;
       }
-      const result = handle({ body: parsed, method: request.method ?? "POST", projectRoot });
+      const result = handle({ body: parsed, method: request.method ?? "POST", projectRoot, schemaDirectory });
       respondJson(response, result.status, result.body);
     } catch (error) {
       respondJson(response, 500, { error: error instanceof Error ? error.message : String(error), ok: false });

package/dist/packem_shared/streamContainerLogs-BZ4cOZwH.mjs

@@ -0,0 +1,157 @@
+import { Writable } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+
+const DEV_CONTAINER_IMAGE_PREFIX = "cloudflare-dev/";
+const DEFAULT_POLL_INTERVAL_MS = 1500;
+const createDefaultDocker = async () => {
+  const { default: Dockerode } = await import('dockerode');
+  return new Dockerode();
+};
+const classFromImage = (image) => {
+  if (!image.startsWith(DEV_CONTAINER_IMAGE_PREFIX)) {
+    return void 0;
+  }
+  const [segment] = image.slice(DEV_CONTAINER_IMAGE_PREFIX.length).split(":");
+  return segment !== void 0 && segment.length > 0 ? segment : void 0;
+};
+const lineBufferWritable = (emit) => {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  const flushLine = (line) => {
+    emit(line.endsWith("\r") ? line.slice(0, -1) : line);
+  };
+  return new Writable({
+    final(callback) {
+      buffer += decoder.end();
+      if (buffer.length > 0) {
+        flushLine(buffer);
+        buffer = "";
+      }
+      callback();
+    },
+    write(chunk, _encoding, callback) {
+      buffer += decoder.write(chunk);
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        flushLine(line);
+      }
+      callback();
+    }
+  });
+};
+const streamContainerLogs = (options) => {
+  const classToExport = new Map(options.containers.map((source) => [source.className.toLowerCase(), source.exportName]));
+  if (classToExport.size === 0) {
+    return { close: () => {
+    } };
+  }
+  const interval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const attached = /* @__PURE__ */ new Map();
+  let closed = false;
+  let unavailableNotified = false;
+  let timer;
+  let dockerPromise;
+  const getDocker = async () => {
+    dockerPromise ??= options.docker ? Promise.resolve(options.docker) : createDefaultDocker();
+    return dockerPromise;
+  };
+  const attach = async (docker, id, exportName) => {
+    try {
+      const stream = await docker.getContainer(id).logs({ follow: true, stderr: true, stdout: true, tail: "all", timestamps: false });
+      if (closed) {
+        stream.destroy();
+        return;
+      }
+      const stdout = lineBufferWritable((text) => {
+        options.onLine({ level: "info", name: exportName, text });
+      });
+      const stderr = lineBufferWritable((text) => {
+        options.onLine({ level: "error", name: exportName, text });
+      });
+      docker.modem.demuxStream(stream, stdout, stderr);
+      stream.on("end", () => {
+        stdout.end();
+        stderr.end();
+        attached.delete(id);
+      });
+      stream.on("error", () => {
+        attached.delete(id);
+      });
+      attached.set(id, stream);
+    } catch {
+    }
+  };
+  const listRunning = async () => {
+    try {
+      const docker = await getDocker();
+      const running = await docker.listContainers({ filters: { status: ["running"] } });
+      unavailableNotified = false;
+      return running;
+    } catch (error) {
+      if (!unavailableNotified) {
+        unavailableNotified = true;
+        options.onUnavailable?.(error instanceof Error ? error.message : String(error));
+      }
+      return void 0;
+    }
+  };
+  const reconcile = async (docker, running) => {
+    const live = /* @__PURE__ */ new Set();
+    for (const summary of running) {
+      const className = classFromImage(summary.Image);
+      const exportName = className === void 0 ? void 0 : classToExport.get(className);
+      if (exportName === void 0) {
+        continue;
+      }
+      live.add(summary.Id);
+      if (!attached.has(summary.Id)) {
+        await attach(docker, summary.Id, exportName);
+      }
+    }
+    for (const [id, stream] of attached) {
+      if (!live.has(id)) {
+        stream.destroy();
+        attached.delete(id);
+      }
+    }
+  };
+  const poll = async () => {
+    if (closed) {
+      return;
+    }
+    const running = await listRunning();
+    if (running === void 0) {
+      return;
+    }
+    await reconcile(await getDocker(), running);
+  };
+  let polling = false;
+  const onTick = () => {
+    if (polling || closed) {
+      return;
+    }
+    polling = true;
+    poll().finally(() => {
+      polling = false;
+    }).catch(() => void 0);
+  };
+  timer = setInterval(onTick, interval);
+  timer.unref();
+  onTick();
+  return {
+    close: () => {
+      closed = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      for (const [id, stream] of attached) {
+        stream.destroy();
+        attached.delete(id);
+      }
+    }
+  };
+};
+
+export { streamContainerLogs };

package/dist/packem_shared/write-atomic-B2REqapi.mjs

@@ -0,0 +1,14 @@
+import { writeFileSync, renameSync, rmSync } from 'node:fs';
+
+const writeFileAtomic = (path, text) => {
+  const temporaryPath = `${path}.lunora-tmp`;
+  try {
+    writeFileSync(temporaryPath, text, "utf8");
+    renameSync(temporaryPath, path);
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+};
+
+export { writeFileAtomic as w };