@lunora/cli 1.0.0-alpha.22 → 1.0.0-alpha.24

package/dist/packem_chunks/handler12.mjs

@@ -1,131 +1,192 @@
-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';
+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-D3lB_4Az.mjs';
 
-const GET_FUNCTION_STATS_OP = "__lunora_admin__:getFunctionStats";
-const DEFAULT_LIMIT = 10;
-const TRAILING_SLASH = /\/$/u;
-const toInsightRow = (stat, rate) => {
+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 {
-    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
+    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 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 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 resolveLimit = (raw) => {
-  if (raw === void 0 || !Number.isFinite(raw) || raw <= 0) {
-    return DEFAULT_LIMIT;
+const collectLunoraPackages = (projectRoot) => {
+  const pkgPath = join(projectRoot, "package.json");
+  if (!existsSync(pkgPath)) {
+    return [];
   }
-  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 };
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  } catch {
+    return [];
   }
-  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 };
+  if (pkg === null || typeof pkg !== "object") {
+    return [];
   }
-  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
-  if (baseUrl === void 0) {
-    return { code: 1 };
+  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);
+      }
+    }
   }
-  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");
+  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 payload = { args: {}, functionPath: GET_FUNCTION_STATS_OP };
-  if (options.shard !== void 0) {
-    payload.shardKey = options.shard;
+  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);
+    }
   }
-  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 };
+  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}`);
+    }
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    options.logger.error(`insights failed: worker returned non-JSON: ${text}`);
-    return { code: 1 };
+  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>`)");
   }
-  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 };
+  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 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 })
-  });
-});
+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 { buildInsightsReport, execute, formatInsightsReport, runInsightsCommand };
+export { collectInfo, execute, runInfoCommand };

package/dist/packem_chunks/handler13.mjs

@@ -1,65 +1,131 @@
-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';
+import { r as resolveAdminBaseUrl } from '../packem_shared/admin-url-4UzT-CI4.mjs';
+import { d as defineHandler } from '../packem_shared/command-D3lB_4Az.mjs';
+import { a as resolveProductionWorkerUrl } from '../packem_shared/resolve-target-qbsJ_5sF.mjs';
 
-const isValidWorkerUrl = (value) => {
-  try {
-    const { protocol } = new URL(value);
-    return protocol === "http:" || protocol === "https:";
-  } catch {
-    return false;
-  }
+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 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 };
+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;
   }
-  rmSync(path);
-  logger.success(`link: removed ${LINKED_PROJECT_FILE}`);
-  return { code: 0 };
+  return Math.floor(raw);
 };
-const runLinkCommand = (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  const { logger } = options;
-  if (options.remove) {
-    return runLinkRemove(cwd, logger);
+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 };
   }
-  if (options.url === void 0 || options.url === "") {
-    logger.error("link requires a deployed Worker URL. Usage: lunora link --url <https://your-worker>");
+  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 };
   }
-  if (!isValidWorkerUrl(options.url)) {
-    logger.error(`link: invalid --url "${options.url}" — expected an http(s) URL`);
+  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
+  if (baseUrl === void 0) {
     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}"`);
+  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 };
   }
-  return { code: 0, link };
+  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 }) => runLinkCommand({
-    cwd,
-    env: options.env,
+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,
-    name: options.name,
-    remove: options.remove === true,
-    url: options.url
-  })
-);
+    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 { execute, runLinkCommand };
+export { buildInsightsReport, execute, formatInsightsReport, runInsightsCommand };

package/dist/packem_chunks/handler14.mjs

@@ -1,58 +1,65 @@
-import { readLinkedProject } from '@lunora/config';
-import { d as defineHandler } from '../packem_shared/command-BC30oSBW.mjs';
-import { defaultSpawner } from '../packem_shared/createRecordingSpawner-DxI3mebw.mjs';
+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-D3lB_4Az.mjs';
+import { r as readWranglerName } from '../packem_shared/wrangler-name-cy4yhm9j.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);
+const isValidWorkerUrl = (value) => {
+  try {
+    const { protocol } = new URL(value);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
   }
-  if (options.format !== void 0) {
-    args.push("--format", options.format);
+};
+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 };
   }
-  if (options.status !== void 0) {
-    args.push("--status", options.status);
+  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.search !== void 0) {
-    args.push("--search", options.search);
+  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 (options.temporary) {
-    args.push("--temporary");
+  if (!isValidWorkerUrl(options.url)) {
+    logger.error(`link: invalid --url "${options.url}" — expected an http(s) URL`);
+    return { code: 1 };
   }
-  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 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(
-  ({ argument, cwd, logger, options }) => runLogsCommand({
+  ({ cwd, logger, options }) => runLinkCommand({
     cwd,
     env: options.env,
-    format: options.format,
     logger,
-    search: options.search,
-    status: options.status,
-    temporary: options.temporary === true,
-    worker: argument[0]
+    name: options.name,
+    remove: options.remove === true,
+    url: options.url
   })
 );
 
-export { execute, runLogsCommand };
+export { execute, runLinkCommand };