@lunora/cli 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,19 @@
+export { COMMANDS, VERSION, runCli } from './packem_shared/COMMANDS-D3h9Iwvl.mjs';
+export { runCodegenCommand } from './packem_chunks/runCodegenCommand.mjs';
+export { DEFAULT_IMPORT_BATCH_SIZE, runExportCommand, runImportCommand } from './packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs';
+export { runDeployCommand } from './packem_chunks/runDeployCommand.mjs';
+export { planDevCommand, runDevCommand } from './packem_chunks/planDevCommand.mjs';
+export { runInitCommand } from './packem_chunks/runInitCommand.mjs';
+export { runMigrateGenerateCommand } from './packem_chunks/runMigrateGenerateCommand.mjs';
+export { runResetCommand } from './packem_chunks/runResetCommand.mjs';
+export { runRpcCommand } from './packem_chunks/runRpcCommand.mjs';
+export { default as parseArgs } from './packem_shared/parseArgs-YXFuKdEk.mjs';
+export { insertSchemaExtension } from './packem_shared/insertSchemaExtension-BuzF6-t2.mjs';
+export { createLogger, pail } from './packem_shared/createLogger-B40gPzQo.mjs';
+export { diffSnapshots, renderAddColumn, renderCreateIndex, renderCreateTable, renderDropIndex, renderDropTable, renderMigrationFile, validatorKindToSqlType } from './packem_shared/diffSnapshots-BeDvvNiF.mjs';
+export { default as schemaIrToSnapshot } from './packem_shared/schemaIrToSnapshot-DdsljJT-.mjs';
+export { createRecordingSpawner, defaultSpawner } from './packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+export { default as parseManifest } from './packem_shared/parseManifest--vZf2FY1.mjs';
+export { REQUIRED_COMPATIBILITY_DATE, REQUIRED_FLAG, validateWranglerProject as validateWrangler, validateWranglerConfig } from '@lunora/config';
+export { buildRegistryIndex } from './packem_shared/buildRegistryIndex-BcYe607_.mjs';
+export { r as runAddCommand, a as runBuildIndexCommand, b as runRegistryViewCommand } from './packem_shared/commands-DPKWlqqX.mjs';

package/dist/packem_chunks/handler.mjs

@@ -0,0 +1,150 @@
+import { existsSync } from 'node:fs';
+import { findWranglerFile } from '@lunora/config';
+import { join, basename } from '@visulima/path';
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { t as tuiText, a as tuiSelect } from '../packem_shared/tui-prompts-DEiPCKV-.mjs';
+import { n as normalizeFeature, E as EMAIL_ITEM, s as sanitizeBucketName, d as deriveBucketName, p as promptBucketName, r as resolveTypedDestination, M as MAIL_DESTINATION_PROMPT, a as sanitizeDatabaseName, b as deriveDatabaseName, c as promptDatabaseName, D as DEFAULT_AUTH_ITEM, e as promptAuthProvider, A as AUTH_PROVIDER_OPTIONS, w as withStorageBucketName, f as withMailDestination, g as withAuthDatabaseName } from '../packem_shared/storage-2RJBhUC4.mjs';
+import { r as runAddCommand } from '../packem_shared/commands-DPKWlqqX.mjs';
+
+const providerToItem = (provider) => {
+  const value = provider.trim().toLowerCase();
+  const match = AUTH_PROVIDER_OPTIONS.find(
+    (option) => option.value === value || option.label.toLowerCase() === value || value === "auth0" && option.value === "auth-auth0" || value === "clerk" && option.value === "auth-clerk"
+  );
+  return match?.value;
+};
+const resolveAuthItem = async (options) => {
+  if (options.provider !== void 0 && options.provider !== "") {
+    const item = providerToItem(options.provider);
+    if (item === void 0) {
+      options.logger.warn(`add: unknown --provider "${options.provider}" — using "${DEFAULT_AUTH_ITEM}" (email & password).`);
+      return DEFAULT_AUTH_ITEM;
+    }
+    return item;
+  }
+  if (options.yes === true) {
+    return DEFAULT_AUTH_ITEM;
+  }
+  const select = options.promptSelect ?? ((message, choices, settings) => tuiSelect(message, choices, settings));
+  return promptAuthProvider(select);
+};
+const textPrompt = (options) => options.promptText ?? ((message, settings) => tuiText(message, settings));
+const resolveStorageBucketName = async (options) => {
+  const projectName = basename(options.cwd ?? process.cwd());
+  if (options.bucket !== void 0 && options.bucket !== "") {
+    const sanitized = sanitizeBucketName(options.bucket);
+    if (sanitized !== void 0) {
+      return sanitized;
+    }
+    const fallback = deriveBucketName(projectName);
+    options.logger.warn(`add: "${options.bucket}" isn't a valid R2 bucket name (lowercase alphanumeric + hyphens, 3–63 chars) — using "${fallback}".`);
+    return fallback;
+  }
+  if (options.yes === true) {
+    return deriveBucketName(projectName);
+  }
+  return promptBucketName(textPrompt(options), projectName);
+};
+const resolveMailDestination = async (options) => {
+  const warn = (message) => {
+    options.logger.warn(`add: ${message}`);
+  };
+  if (options.mailTo !== void 0 && options.mailTo !== "") {
+    return resolveTypedDestination(options.mailTo, warn);
+  }
+  if (options.yes === true) {
+    return void 0;
+  }
+  return resolveTypedDestination(await textPrompt(options)(MAIL_DESTINATION_PROMPT, { placeholder: "you@yourdomain.com" }), warn);
+};
+const resolveAuthDatabaseName = async (options) => {
+  const projectName = basename(options.cwd ?? process.cwd());
+  if (options.db !== void 0 && options.db !== "") {
+    const sanitized = sanitizeDatabaseName(options.db);
+    if (sanitized !== void 0) {
+      return sanitized;
+    }
+    const fallback = deriveDatabaseName(projectName);
+    options.logger.warn(`add: "${options.db}" isn't a usable D1 database name — using "${fallback}".`);
+    return fallback;
+  }
+  if (options.yes === true) {
+    return deriveDatabaseName(projectName);
+  }
+  return promptDatabaseName(textPrompt(options), projectName);
+};
+const resolveFeatureItems = async (feature, options) => {
+  if (feature.kind === "auth") {
+    return [await resolveAuthItem(options)];
+  }
+  if (feature.kind === "email") {
+    return [EMAIL_ITEM];
+  }
+  return [feature.item];
+};
+const runAddFeature = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const feature = options.feature === void 0 ? void 0 : normalizeFeature(options.feature);
+  if (feature === void 0) {
+    options.logger.error("add requires a feature or registry item. Usage: lunora add <auth|email|storage|crons|presence|…>");
+    return { code: 1, items: [] };
+  }
+  if (!existsSync(join(cwd, "lunora")) || findWranglerFile(cwd) === void 0) {
+    options.logger.error("add: not a Lunora project here (need a lunora/ directory and a wrangler.jsonc). Run `lunora init` first.");
+    return { code: 1, items: [] };
+  }
+  const items = await resolveFeatureItems(feature, options);
+  const transforms = [];
+  if (items.includes("storage")) {
+    const bucketName = await resolveStorageBucketName(options);
+    transforms.push((manifest) => withStorageBucketName(manifest, bucketName));
+  }
+  if (items.includes("mail")) {
+    const destination = await resolveMailDestination(options);
+    if (destination !== void 0) {
+      transforms.push((manifest) => withMailDestination(manifest, destination));
+    }
+  }
+  if (items.some((name) => name === "auth" || name.startsWith("auth-"))) {
+    const databaseName = await resolveAuthDatabaseName(options);
+    transforms.push((manifest) => withAuthDatabaseName(manifest, databaseName));
+  }
+  const transformManifest = transforms.length > 0 ? (manifest) => {
+    let result2 = manifest;
+    for (const transform of transforms) {
+      result2 = transform(result2);
+    }
+    return result2;
+  } : void 0;
+  const result = await runAddCommand({
+    allowUnsafeSource: options.allowUnsafeSource,
+    cwd,
+    from: options.from,
+    logger: options.logger,
+    names: [...items],
+    ref: options.ref,
+    source: options.source,
+    transformManifest,
+    yes: true
+  });
+  return { code: result.code, items };
+};
+const execute = defineHandler(async ({ argument, cwd, logger, options }) => {
+  const result = await runAddFeature({
+    allowUnsafeSource: options.allowUnsafeSource === true,
+    bucket: options.bucket,
+    cwd,
+    db: options.db,
+    feature: argument[0],
+    from: options.from,
+    logger,
+    mailTo: options.mailTo,
+    provider: options.provider,
+    ref: options.ref,
+    source: options.source,
+    yes: options.yes === true
+  });
+  return { code: result.code };
+});
+
+export { execute, runAddFeature };

package/dist/packem_chunks/handler10.mjs

@@ -0,0 +1,22 @@
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
+import { runImportCommand } from '../packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs';
+
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const file = argument[0];
+  if (!file) {
+    logger.error("import requires a file. Usage: lunora import <path> [--table <name>]");
+    return { code: 1 };
+  }
+  return runImportCommand({
+    batchSize: options.batchSize,
+    file,
+    logger,
+    prod: options.prod === true,
+    table: options.table,
+    token: options.token,
+    url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url })
+  });
+});
+
+export { execute };

package/dist/packem_chunks/handler11.mjs

@@ -0,0 +1,192 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { discoverSchema } from '@lunora/codegen';
+import { readLinkedProject } from '@lunora/config';
+import { parse } from 'jsonc-parser';
+import { Project } from 'ts-morph';
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+
+const findWranglerFile = (projectRoot) => {
+  for (const candidate of ["wrangler.jsonc", "wrangler.json"]) {
+    const fullPath = join(projectRoot, candidate);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+};
+const stringField = (record, key) => {
+  if (record === null || typeof record !== "object") {
+    return void 0;
+  }
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+const arrayField = (record, key) => {
+  if (record === null || typeof record !== "object") {
+    return [];
+  }
+  const value = record[key];
+  return Array.isArray(value) ? value : [];
+};
+const summariseWrangler = (raw) => {
+  const durableObjectBindings = arrayField(raw.durable_objects ?? {}, "bindings");
+  const d1 = arrayField(raw, "d1_databases");
+  const vectorize = arrayField(raw, "vectorize");
+  return {
+    bindings: {
+      d1: d1.map((entry) => stringField(entry, "binding") ?? "<unnamed>"),
+      durableObjects: durableObjectBindings.map((entry) => stringField(entry, "name") ?? "<unnamed>"),
+      vectorize: vectorize.map((entry) => stringField(entry, "binding") ?? "<unnamed>")
+    },
+    compatibilityDate: stringField(raw, "compatibility_date"),
+    compatibilityFlags: arrayField(raw, "compatibility_flags").filter((entry) => typeof entry === "string"),
+    main: stringField(raw, "main"),
+    name: stringField(raw, "name")
+  };
+};
+const summariseSchema = (schema) => {
+  return {
+    tables: schema.tables.map((table) => {
+      let shard = "root";
+      if (table.shardMode === "global") {
+        shard = "global";
+      } else if (typeof table.shardMode === "object") {
+        shard = `shardBy(${table.shardMode.field})`;
+      }
+      return {
+        indexes: table.indexes.length,
+        name: table.name,
+        shard
+      };
+    }),
+    vectorIndexes: schema.vectorIndexes.length
+  };
+};
+const collectLunoraPackages = (projectRoot) => {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    return [];
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return [];
+  }
+  if (pkg === null || typeof pkg !== "object") {
+    return [];
+  }
+  const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+  const seen = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const block = pkg[section];
+    if (block === null || typeof block !== "object") {
+      continue;
+    }
+    for (const [name, version] of Object.entries(block)) {
+      if (!name.startsWith("@lunora/")) {
+        continue;
+      }
+      if (typeof version === "string" && !seen.has(name)) {
+        seen.set(name, version);
+      }
+    }
+  }
+  return [...seen.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([name, version]) => {
+    return { name, version };
+  });
+};
+const collectInfo = (projectRoot) => {
+  const lunoraPackages = collectLunoraPackages(projectRoot);
+  const wranglerPath = findWranglerFile(projectRoot);
+  let wrangler;
+  if (wranglerPath) {
+    try {
+      wrangler = summariseWrangler(parse(readFileSync(wranglerPath, "utf8")));
+    } catch {
+      wrangler = void 0;
+    }
+  }
+  const schemaPath = join(projectRoot, "lunora", "schema.ts");
+  let schema;
+  let schemaError;
+  if (existsSync(schemaPath)) {
+    try {
+      const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+      schema = summariseSchema(discoverSchema(project, schemaPath));
+    } catch (error) {
+      schemaError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return {
+    link: readLinkedProject(projectRoot),
+    lunoraPackages,
+    projectRoot,
+    schema,
+    schemaError,
+    wrangler,
+    wranglerPath
+  };
+};
+const renderText = (snapshot, logger) => {
+  logger.info(`project: ${snapshot.projectRoot}`);
+  logger.info("");
+  logger.info("@lunora/* packages:");
+  if (snapshot.lunoraPackages.length === 0) {
+    logger.info("  (none found in package.json)");
+  } else {
+    for (const pkg of snapshot.lunoraPackages) {
+      logger.info(`  ${pkg.name}@${pkg.version}`);
+    }
+  }
+  logger.info("");
+  if (snapshot.wrangler) {
+    logger.info(`wrangler: ${snapshot.wranglerPath ?? ""}`);
+    logger.info(`  name:               ${snapshot.wrangler.name ?? "<unset>"}`);
+    logger.info(`  main:               ${snapshot.wrangler.main ?? "<unset>"}`);
+    logger.info(`  compatibility_date: ${snapshot.wrangler.compatibilityDate ?? "<unset>"}`);
+    logger.info(`  compatibility_flags: ${snapshot.wrangler.compatibilityFlags.join(", ") || "<none>"}`);
+    logger.info(`  durable objects:    ${snapshot.wrangler.bindings.durableObjects.join(", ") || "<none>"}`);
+    logger.info(`  d1 databases:       ${snapshot.wrangler.bindings.d1.join(", ") || "<none>"}`);
+    logger.info(`  vectorize indexes:  ${snapshot.wrangler.bindings.vectorize.join(", ") || "<none>"}`);
+  } else {
+    logger.info("wrangler: (not found)");
+  }
+  logger.info("");
+  if (snapshot.link) {
+    logger.info(`link: ${snapshot.link.workerName ?? "(unnamed)"} -> ${snapshot.link.workerUrl ?? "<no url>"}`);
+    if (snapshot.link.env !== void 0) {
+      logger.info(`  env: ${snapshot.link.env}`);
+    }
+  } else {
+    logger.info("link: (not linked — run `lunora link --url <https://your-worker>`)");
+  }
+  logger.info("");
+  if (snapshot.schemaError !== void 0) {
+    logger.warn(`schema: parse error — ${snapshot.schemaError}`);
+  } else if (snapshot.schema) {
+    logger.info(`schema: ${String(snapshot.schema.tables.length)} table(s), ${String(snapshot.schema.vectorIndexes)} vector index(es)`);
+    for (const table of snapshot.schema.tables) {
+      logger.info(`  ${table.name}  [${table.shard}, ${String(table.indexes)} index(es)]`);
+    }
+  } else {
+    logger.info("schema: (no lunora/schema.ts)");
+  }
+};
+const runInfoCommand = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const snapshot = collectInfo(cwd);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(snapshot, void 0, 2)}
+`);
+  } else {
+    renderText(snapshot, options.logger);
+  }
+  return { code: 0, snapshot };
+};
+const execute = defineHandler(
+  ({ cwd, logger, options }) => runInfoCommand({ cwd, json: options.json === true, logger })
+);
+
+export { collectInfo, execute, runInfoCommand };

package/dist/packem_chunks/handler12.mjs

@@ -0,0 +1,131 @@
+import { r as resolveAdminBaseUrl } from '../packem_shared/admin-url-4UzT-CI4.mjs';
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
+
+const GET_FUNCTION_STATS_OP = "__lunora_admin__:getFunctionStats";
+const DEFAULT_LIMIT = 10;
+const TRAILING_SLASH = /\/$/u;
+const toInsightRow = (stat, rate) => {
+  return {
+    calls: stat.calls,
+    conflicts: stat.conflicts ?? 0,
+    errors: stat.errors,
+    lastErrorMessage: stat.lastErrorMessage,
+    maxDurationMs: stat.maxDurationMs,
+    meanDurationMs: stat.calls === 0 ? 0 : stat.totalDurationMs / stat.calls,
+    path: stat.path,
+    rate
+  };
+};
+const buildInsightsReport = (functions, limit) => {
+  const writeContention = functions.filter((stat) => (stat.conflicts ?? 0) > 0).map((stat) => toInsightRow(stat, stat.calls === 0 ? 0 : (stat.conflicts ?? 0) / stat.calls)).toSorted((a, b) => b.rate - a.rate || b.conflicts - a.conflicts).slice(0, limit);
+  const errorHotspots = functions.filter((stat) => stat.errors > 0).map((stat) => toInsightRow(stat, stat.calls === 0 ? 0 : stat.errors / stat.calls)).toSorted((a, b) => b.rate - a.rate || b.errors - a.errors).slice(0, limit);
+  const latencyOutliers = functions.map((stat) => toInsightRow(stat, 0)).toSorted((a, b) => b.maxDurationMs - a.maxDurationMs).slice(0, limit);
+  return { errorHotspots, latencyOutliers, totalFunctions: functions.length, writeContention };
+};
+const percent = (rate) => `${(rate * 100).toFixed(1)}%`;
+const formatMs = (ms) => ms < 1e3 ? `${Math.round(ms).toString()}ms` : `${(ms / 1e3).toFixed(2)}s`;
+const formatSection = (heading, rows, emptyNote, renderRow) => [
+  heading,
+  ...rows.length === 0 ? [`  ${emptyNote}`] : rows.map((row) => `  ${renderRow(row)}`)
+];
+const formatInsightsReport = (report) => {
+  const errorTail = (row) => row.lastErrorMessage ? ` — ${row.lastErrorMessage}` : "";
+  return [
+    `Insights over ${report.totalFunctions.toString()} function${report.totalFunctions === 1 ? "" : "s"}`,
+    "",
+    ...formatSection(
+      "Write-conflict hot-spots (OCC contention — candidates for sharding):",
+      report.writeContention,
+      "none — no write conflicts observed",
+      (row) => `${row.path}  ${row.conflicts.toString()}/${row.calls.toString()} calls (${percent(row.rate)})`
+    ),
+    "",
+    ...formatSection(
+      "Error hot-spots:",
+      report.errorHotspots,
+      "none — no errors observed",
+      (row) => `${row.path}  ${row.errors.toString()}/${row.calls.toString()} calls (${percent(row.rate)})${errorTail(row)}`
+    ),
+    "",
+    ...formatSection(
+      "Latency outliers (slowest single call):",
+      report.latencyOutliers,
+      "none — no functions have run",
+      (row) => `${row.path}  max ${formatMs(row.maxDurationMs)}, mean ${formatMs(row.meanDurationMs)} over ${row.calls.toString()} calls`
+    )
+  ].join("\n");
+};
+const resolveLimit = (raw) => {
+  if (raw === void 0 || !Number.isFinite(raw) || raw <= 0) {
+    return DEFAULT_LIMIT;
+  }
+  return Math.floor(raw);
+};
+const runInsightsCommand = async (options) => {
+  if (options.prod && options.url === void 0) {
+    options.logger.error("--prod requires an explicit --url (refusing to report from the implicit localhost worker)");
+    return { code: 1 };
+  }
+  const token = options.token ?? process.env.LUNORA_ADMIN_TOKEN;
+  if (!token) {
+    options.logger.error("admin token required — pass --token or set LUNORA_ADMIN_TOKEN");
+    return { code: 1 };
+  }
+  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
+  if (baseUrl === void 0) {
+    return { code: 1 };
+  }
+  const requestUrl = `${baseUrl.replace(TRAILING_SLASH, "")}/_lunora/rpc`;
+  const fetchImpl = globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("no fetch implementation available — pass fetchImpl or run on Node >= 18");
+  }
+  const payload = { args: {}, functionPath: GET_FUNCTION_STATS_OP };
+  if (options.shard !== void 0) {
+    payload.shardKey = options.shard;
+  }
+  options.logger.info(`POST ${requestUrl} -> insights`);
+  const response = await fetchImpl(requestUrl, {
+    body: JSON.stringify(payload),
+    headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+    method: "POST"
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    options.logger.error(`insights failed: HTTP ${String(response.status)}: ${text}`);
+    return { code: 1 };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    options.logger.error(`insights failed: worker returned non-JSON: ${text}`);
+    return { code: 1 };
+  }
+  const result = parsed.result ?? parsed;
+  const { functions } = result;
+  if (!Array.isArray(functions)) {
+    options.logger.error("insights failed: response carried no `functions` array");
+    return { code: 1 };
+  }
+  const report = buildInsightsReport(functions, resolveLimit(options.limit));
+  options.logger.info(options.json ? JSON.stringify(report, void 0, 2) : formatInsightsReport(report));
+  return { code: 0, report };
+};
+const execute = defineHandler(({ cwd, logger, options }) => {
+  const limit = options.limit === void 0 ? void 0 : Number.parseInt(options.limit, 10);
+  return runInsightsCommand({
+    json: options.json,
+    limit,
+    logger,
+    prod: options.prod,
+    shard: options.shard,
+    token: options.token,
+    // Fall back to the `.lunora/project.json` link when `--prod` is set, so a
+    // linked checkout doesn't need --url repeated for prod insights.
+    url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url })
+  });
+});
+
+export { buildInsightsReport, execute, formatInsightsReport, runInsightsCommand };

package/dist/packem_chunks/handler13.mjs

@@ -0,0 +1,65 @@
+import { existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeLinkedProject, LINKED_PROJECT_FILE } from '@lunora/config';
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { r as readWranglerName } from '../packem_shared/wrangler-name-cy4yhm9j.mjs';
+
+const isValidWorkerUrl = (value) => {
+  try {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+const runLinkRemove = (cwd, logger) => {
+  const path = join(cwd, LINKED_PROJECT_FILE);
+  if (!existsSync(path)) {
+    logger.warn(`link: no ${LINKED_PROJECT_FILE} to remove`);
+    return { code: 0 };
+  }
+  rmSync(path);
+  logger.success(`link: removed ${LINKED_PROJECT_FILE}`);
+  return { code: 0 };
+};
+const runLinkCommand = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const { logger } = options;
+  if (options.remove) {
+    return runLinkRemove(cwd, logger);
+  }
+  if (options.url === void 0 || options.url === "") {
+    logger.error("link requires a deployed Worker URL. Usage: lunora link --url <https://your-worker>");
+    return { code: 1 };
+  }
+  if (!isValidWorkerUrl(options.url)) {
+    logger.error(`link: invalid --url "${options.url}" — expected an http(s) URL`);
+    return { code: 1 };
+  }
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const link = {
+    env: options.env,
+    linkedAt: now(),
+    workerName: options.name ?? readWranglerName(cwd),
+    workerUrl: options.url
+  };
+  const path = writeLinkedProject(cwd, link);
+  logger.success(`link: ${link.workerName ?? "(unnamed worker)"} -> ${options.url}`);
+  logger.info(`link: wrote ${path}`);
+  if (link.env !== void 0) {
+    logger.info(`link: environment "${link.env}"`);
+  }
+  return { code: 0, link };
+};
+const execute = defineHandler(
+  ({ cwd, logger, options }) => runLinkCommand({
+    cwd,
+    env: options.env,
+    logger,
+    name: options.name,
+    remove: options.remove === true,
+    url: options.url
+  })
+);
+
+export { execute, runLinkCommand };

package/dist/packem_chunks/handler14.mjs

@@ -0,0 +1,58 @@
+import { readLinkedProject } from '@lunora/config';
+import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
+import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+
+const LOG_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
+const runLogsCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.format !== void 0 && !LOG_FORMATS.has(options.format)) {
+    options.logger.error(`logs: unknown --format "${options.format}" — expected pretty | json`);
+    return { code: 1, descriptor: void 0, error: "invalid format" };
+  }
+  const args = ["exec", "wrangler", "tail"];
+  if (options.worker !== void 0) {
+    args.push(options.worker);
+  }
+  const env = options.env ?? readLinkedProject(cwd)?.env;
+  if (env !== void 0) {
+    args.push("--env", env);
+  }
+  if (options.format !== void 0) {
+    args.push("--format", options.format);
+  }
+  if (options.status !== void 0) {
+    args.push("--status", options.status);
+  }
+  if (options.search !== void 0) {
+    args.push("--search", options.search);
+  }
+  if (options.temporary) {
+    args.push("--temporary");
+  }
+  const descriptor = {
+    args,
+    command: "pnpm",
+    cwd
+  };
+  options.logger.info(`tailing logs via ${descriptor.command} ${descriptor.args.join(" ")}`);
+  const spawner = options.spawner ?? defaultSpawner;
+  const result = await spawner(descriptor);
+  return {
+    code: result.code,
+    descriptor
+  };
+};
+const execute = defineHandler(
+  ({ argument, cwd, logger, options }) => runLogsCommand({
+    cwd,
+    env: options.env,
+    format: options.format,
+    logger,
+    search: options.search,
+    status: options.status,
+    temporary: options.temporary === true,
+    worker: argument[0]
+  })
+);
+
+export { execute, runLogsCommand };