@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_chunks/handler16.mjs

@@ -0,0 +1,41 @@
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { runAddCommand, runRegistryViewCommand, runBuildIndexCommand } from '../packem_shared/runAddCommand-BZGkRnBs.mjs';
+
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const subcommand = argument[0];
+  const names = argument.slice(1);
+  if (subcommand === "add") {
+    return runAddCommand({
+      allowUnsafeSource: options.allowUnsafeSource === true,
+      cwd,
+      diff: options.diff === true,
+      dryRun: options.dryRun === true,
+      from: options.from,
+      json: options.json === true,
+      logger,
+      names,
+      overwrite: options.overwrite === true,
+      source: options.source,
+      yes: options.yes === true
+    });
+  }
+  if (subcommand === "list") {
+    return runAddCommand({ cwd, from: options.from, json: options.json === true, list: true, logger, names: [], source: options.source });
+  }
+  if (subcommand === "view") {
+    return runRegistryViewCommand({
+      allowUnsafeSource: options.allowUnsafeSource === true,
+      from: options.from,
+      logger,
+      names,
+      source: options.source
+    });
+  }
+  if (subcommand === "build") {
+    return runBuildIndexCommand({ check: options.check === true, from: options.from, logger, out: options.out });
+  }
+  logger.error("registry: unknown subcommand. Usage: lunora registry <add|list|view|build> [names…]");
+  return { code: 1 };
+});
+
+export { execute };

package/dist/packem_chunks/handler17.mjs

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { AGENT_RULES_DIR, detectAgentRules, LUNORA_SKILL_NAMES } from '@lunora/config';
+import { join, relative, dirname } from '@visulima/path';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+
+const resolveBundledSkillsDirectory = (startDirectory = dirname(fileURLToPath(import.meta.url))) => {
+  let directory = startDirectory;
+  for (let index = 0; index < 6; index += 1) {
+    const packageJson = join(directory, "package.json");
+    if (existsSync(packageJson)) {
+      try {
+        const parsed = JSON.parse(readFileSync(packageJson, "utf8"));
+        if (parsed.name === "@lunora/cli") {
+          const skills = join(directory, "skills");
+          return existsSync(skills) ? skills : void 0;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) {
+      break;
+    }
+    directory = parent;
+  }
+  return void 0;
+};
+const listBundledSkills = (skillsDirectory) => readdirSync(skillsDirectory).filter((name) => {
+  const directory = join(skillsDirectory, name);
+  return statSync(directory).isDirectory() && existsSync(join(directory, "SKILL.md"));
+});
+const copySkill = (source, destination, overwrite) => {
+  mkdirSync(destination, { recursive: true });
+  let wrote = false;
+  for (const entry of readdirSync(source)) {
+    const from = join(source, entry);
+    const to = join(destination, entry);
+    if (statSync(from).isDirectory()) {
+      wrote = copySkill(from, to, overwrite) || wrote;
+      continue;
+    }
+    if (existsSync(to) && !overwrite) {
+      continue;
+    }
+    writeFileSync(to, readFileSync(from));
+    wrote = true;
+  }
+  return wrote;
+};
+const runRulesInstall = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const overwrite = options.overwrite === true;
+  const skillsDirectory = resolveBundledSkillsDirectory();
+  if (skillsDirectory === void 0) {
+    options.logger.error("rules: could not locate the bundled skills (is @lunora/cli installed correctly?).");
+    return { code: 1, installed: [], skipped: [] };
+  }
+  const installed = [];
+  const skipped = [];
+  for (const name of listBundledSkills(skillsDirectory)) {
+    const destination = join(cwd, AGENT_RULES_DIR, name);
+    const wrote = copySkill(join(skillsDirectory, name), destination, overwrite);
+    if (wrote) {
+      installed.push(name);
+    } else {
+      skipped.push(name);
+    }
+  }
+  const target = relative(cwd, join(cwd, AGENT_RULES_DIR)) || AGENT_RULES_DIR;
+  if (installed.length > 0) {
+    options.logger.success(`Installed ${String(installed.length)} Lunora skill(s) into ${target}/: ${installed.join(", ")}.`);
+  }
+  if (skipped.length > 0) {
+    options.logger.info(`Skipped ${String(skipped.length)} existing skill(s) (re-run with --overwrite to replace): ${skipped.join(", ")}.`);
+  }
+  options.logger.info("Your AI coding agent will pick these up automatically. Start with the `lunora` skill.");
+  return { code: 0, installed, skipped };
+};
+const runRulesCheck = (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const status = detectAgentRules(cwd);
+  if (status.installed) {
+    options.logger.success(`Lunora agent rules are installed (${String(status.present.length)}/${String(LUNORA_SKILL_NAMES.length)} skills).`);
+    if (status.missing.length > 0) {
+      options.logger.info(`Missing: ${status.missing.join(", ")}. Run \`lunora rules install\` to add them.`);
+    }
+    return { code: 0, installed: status.present, skipped: [] };
+  }
+  options.logger.warn("Lunora agent rules are not installed. Run `lunora rules install` so your AI agent knows how to use Lunora.");
+  return { code: options.strict === true ? 1 : 0, installed: status.present, skipped: [] };
+};
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const subcommand = argument[0] ?? "check";
+  if (subcommand === "install") {
+    return runRulesInstall({ cwd, logger, overwrite: options.overwrite === true });
+  }
+  if (subcommand === "check") {
+    return runRulesCheck({ cwd, logger, strict: options.strict === true });
+  }
+  logger.error("rules: unknown subcommand. Usage: lunora rules <install|check>");
+  return { code: 1 };
+});
+
+export { execute, resolveBundledSkillsDirectory, runRulesCheck, runRulesInstall };

package/dist/packem_chunks/handler18.mjs

@@ -0,0 +1,172 @@
+import { existsSync } from 'node:fs';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { discoverSchema, schemaFromIr } from '@lunora/codegen';
+import { promptYesNo } from '@lunora/config';
+import { seedPlan } from '@lunora/seed';
+import { join } from '@visulima/path';
+import { Project } from 'ts-morph';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.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';
+import { runResetCommand } from './runResetCommand.mjs';
+
+const isLocalUrl = (url) => {
+  if (url === void 0) {
+    return true;
+  }
+  try {
+    const { hostname } = new URL(url);
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+const ndjsonReplacer = (_key, value) => {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return [...new Uint8Array(value)];
+  }
+  return value;
+};
+const seedFailure = (code) => {
+  return { code, conflicts: 0, generated: 0, inserted: 0, ndjson: "" };
+};
+const guardSeedTargets = (options, schemaPath) => {
+  if (!existsSync(schemaPath)) {
+    options.logger.error(`schema not found: ${schemaPath} — run \`vis generate lunora-table --name=<name>\` to create one`);
+    return seedFailure(1);
+  }
+  if (options.reset === true && (options.prod === true || !isLocalUrl(options.url))) {
+    options.logger.error("--reset only clears local .wrangler/state and cannot be combined with --prod or a remote --url");
+    return seedFailure(1);
+  }
+  return void 0;
+};
+const insertSeedRows = async (ndjson, generated, cwd, options) => {
+  const scratchDirectory = await mkdtemp(join(tmpdir(), "lunora-seed-"));
+  const temporaryFile = join(scratchDirectory, "rows.ndjson");
+  await writeFile(temporaryFile, ndjson, "utf8");
+  try {
+    const result = await runImportCommand({
+      batchSize: options.batchSize,
+      fetchImpl: options.fetchImpl,
+      file: temporaryFile,
+      logger: options.logger,
+      prod: options.prod,
+      token: options.token,
+      url: options.url
+    });
+    const conflicts = result.body?.conflicts ?? 0;
+    if (conflicts > 0) {
+      options.logger.warn(
+        `${String(conflicts)} row(s) skipped — their _id already exists. Seeding is deterministic; re-run with --reset to wipe local state first, or a different --seed for fresh ids.`
+      );
+    }
+    return { code: result.code, conflicts, generated, inserted: result.inserted, ndjson };
+  } finally {
+    await rm(scratchDirectory, { force: true, recursive: true }).catch(() => {
+    });
+  }
+};
+const validateSeedTable = (options, ir) => {
+  if (options.table === void 0 || ir.tables.some((table) => table.name === options.table)) {
+    return void 0;
+  }
+  const available = ir.tables.map((table) => table.name).join(", ");
+  options.logger.error(`unknown table "${options.table}" — schema defines: ${available || "(no tables)"}`);
+  return seedFailure(1);
+};
+const confirmRemoteSeedTarget = async (options, generated) => {
+  const targetsRemote = options.prod === true || !isLocalUrl(options.url);
+  if (!targetsRemote || options.yes === true) {
+    return void 0;
+  }
+  if (!process.stdin.isTTY && options.confirm === void 0) {
+    options.logger.error("seed: refusing to insert into a non-local target without confirmation — re-run with --yes");
+    return seedFailure(1);
+  }
+  const confirmer = options.confirm ?? promptYesNo;
+  const confirmed = await confirmer(
+    `This will insert ${String(generated)} generated row(s) into ${options.url ?? "the production worker"}. Continue? [y/N] `
+  );
+  if (!confirmed) {
+    options.logger.info("seed: aborted");
+    return seedFailure(1);
+  }
+  return void 0;
+};
+const runSeedCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const schemaPath = join(cwd, "lunora", "schema.ts");
+  const guard = guardSeedTargets(options, schemaPath);
+  if (guard !== void 0) {
+    return guard;
+  }
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const ir = discoverSchema(project, schemaPath);
+  const unknownTable = validateSeedTable(options, ir);
+  if (unknownTable !== void 0) {
+    return unknownTable;
+  }
+  const schema = schemaFromIr(ir);
+  const plan = seedPlan(schema, {
+    defaultCount: options.count ?? 10,
+    only: options.table === void 0 ? void 0 : [options.table],
+    seed: options.seed ?? 0
+  });
+  const lines = [];
+  for (const { rows, table } of plan) {
+    for (const row of rows) {
+      lines.push(JSON.stringify({ doc: row, table }, ndjsonReplacer));
+    }
+  }
+  const ndjson = lines.length > 0 ? `${lines.join("\n")}
+` : "";
+  const generated = lines.length;
+  if (options.dryRun === true) {
+    if (ndjson.length > 0) {
+      process.stdout.write(ndjson);
+    }
+    options.logger.info(`generated ${String(generated)} row(s) across ${String(plan.length)} table(s) — dry run, nothing inserted`);
+    return { code: 0, conflicts: 0, generated, inserted: 0, ndjson };
+  }
+  if (options.reset === true) {
+    const reset = await runResetCommand({ cwd, logger: options.logger, yes: true });
+    if (reset.code !== 0) {
+      return { code: reset.code, conflicts: 0, generated, inserted: 0, ndjson };
+    }
+  }
+  if (generated === 0) {
+    options.logger.warn("no rows generated — nothing to insert");
+    return { code: 0, conflicts: 0, generated: 0, inserted: 0, ndjson };
+  }
+  const aborted = await confirmRemoteSeedTarget(options, generated);
+  if (aborted !== void 0) {
+    return aborted;
+  }
+  return insertSeedRows(ndjson, generated, cwd, options);
+};
+const execute = defineHandler(async ({ cwd, logger, options }) => {
+  const result = await runSeedCommand({
+    batchSize: options.batchSize,
+    count: options.count,
+    cwd,
+    dryRun: options.dryRun === true,
+    logger,
+    prod: options.prod === true,
+    reset: options.reset === true,
+    seed: options.seed,
+    table: options.table,
+    token: options.token,
+    // Resolve the link here (only under --prod) so seed's own remote/confirm
+    // logic and the downstream import both see the same effective target.
+    url: resolveProductionWorkerUrl({ cwd, prod: options.prod === true, url: options.url }),
+    yes: options.yes === true
+  });
+  return { code: result.code };
+});
+
+export { execute, runSeedCommand };

package/dist/packem_chunks/handler19.mjs

@@ -0,0 +1,89 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runCodegen } from '@lunora/codegen';
+import { p as parseApiSpec } from '../packem_shared/api-spec-CtA6ilu4.mjs';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { v as validateOutputFormat, i as isJsonFormat, p as printJson, l as loggerForFormat } from '../packem_shared/output-format-7gyGR3h8.mjs';
+import { r as runSchemaDriftGate } from '../packem_shared/schema-drift-gate-BtBt0as0.mjs';
+import { defaultSpawner } from '../packem_shared/defaultSpawner-DxI3mebw.mjs';
+import { validateWranglerProject } from '@lunora/config';
+
+const runTypecheckStep = async (cwd, spawner) => {
+  if (!existsSync(join(cwd, "tsconfig.json"))) {
+    return { warning: "no tsconfig.json found — skipping TypeScript type-check" };
+  }
+  const result = await spawner({ args: ["exec", "tsc", "--noEmit", "-p", "tsconfig.json"], command: "pnpm", cwd });
+  return result.code === 0 ? {} : { error: `type errors: tsc --noEmit exited ${String(result.code)}` };
+};
+const reportVerifyResult = (logger, errors, warnings, wranglerPath) => {
+  if (errors.length === 0 && warnings.length === 0) {
+    logger.success("verify: project is valid");
+    return { code: 0, errors: [], warnings: [], wranglerPath };
+  }
+  if (warnings.length > 0) {
+    logger.warn("verify: warnings:");
+    for (const warning of warnings) {
+      logger.warn(`  - ${warning}`);
+    }
+  }
+  if (errors.length > 0) {
+    logger.error("verify: errors:");
+    for (const error of errors) {
+      logger.error(`  - ${error}`);
+    }
+    return { code: 1, errors, warnings, wranglerPath };
+  }
+  logger.success("verify: project is valid (with warnings)");
+  return { code: 0, errors: [], warnings, wranglerPath };
+};
+const runVerifyCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const logger = loggerForFormat(options.format, options.logger);
+  const formatError = validateOutputFormat("verify", options.format);
+  if (formatError !== void 0) {
+    options.logger.error(formatError);
+    return { code: 1, error: formatError, errors: [], warnings: [], wranglerPath: void 0 };
+  }
+  const validation = validateWranglerProject({ projectRoot: cwd });
+  const errors = [...validation.report.errors];
+  const warnings = [...validation.report.warnings];
+  try {
+    const codegen = runCodegen({ apiSpec: options.apiSpec, dryRun: true, projectRoot: cwd });
+    const gate = runSchemaDriftGate({ allowDrift: options.allowSchemaDrift === true, codegen, logger, readOnly: true });
+    if (gate.blocked) {
+      errors.push(gate.reason);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    errors.push(`codegen failed: ${message}`);
+  }
+  if (options.typecheck !== false) {
+    const typecheck = await runTypecheckStep(cwd, options.spawner ?? defaultSpawner);
+    if (typecheck.error !== void 0) {
+      errors.push(typecheck.error);
+    }
+    if (typecheck.warning !== void 0) {
+      warnings.push(typecheck.warning);
+    }
+  }
+  const result = reportVerifyResult(logger, errors, warnings, validation.wranglerPath);
+  if (isJsonFormat(options.format)) {
+    printJson(result);
+  }
+  return result;
+};
+const execute = defineHandler(async ({ cwd, logger, options }) => {
+  const result = await runVerifyCommand({
+    allowSchemaDrift: options.allowSchemaDrift === true,
+    apiSpec: parseApiSpec(options.apiSpec),
+    cwd,
+    format: options.format,
+    logger,
+    // `--no-typecheck` is declared as a `no-*` option but cerebro exposes it
+    // under the negated `typecheck` key (false when passed, true when absent).
+    typecheck: options.typecheck === false ? false : void 0
+  });
+  return { code: result.code };
+});
+
+export { execute, runVerifyCommand };

package/dist/packem_chunks/handler2.mjs

@@ -0,0 +1,114 @@
+import { mkdtempSync, rmSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative } from 'node:path';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { defaultSpawner } from '../packem_shared/defaultSpawner-DxI3mebw.mjs';
+
+const walk = (root) => {
+  const entries = [];
+  const recurse = (directory) => {
+    for (const name of readdirSync(directory)) {
+      const full = join(directory, name);
+      const info = statSync(full);
+      if (info.isDirectory()) {
+        recurse(full);
+      } else if (info.isFile()) {
+        entries.push({ path: relative(root, full), sizeBytes: info.size });
+      }
+    }
+  };
+  recurse(root);
+  return entries;
+};
+const formatBytes = (bytes) => {
+  if (bytes < 1024) {
+    return `${String(bytes)} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KiB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
+};
+const buildReport = (outdir) => {
+  const all = walk(outdir);
+  const sorted = all.toSorted((a, b) => b.sizeBytes - a.sizeBytes);
+  const totalBytes = all.reduce((sum, entry) => sum + entry.sizeBytes, 0);
+  const generatedFiles = all.filter((entry) => entry.path.includes("_generated"));
+  return {
+    generatedFiles,
+    outdir,
+    topModules: sorted.slice(0, 10),
+    totalBytes,
+    totalFiles: all.length
+  };
+};
+const renderText = (report, logger) => {
+  logger.info(`outdir: ${report.outdir}`);
+  logger.info(`total:  ${String(report.totalFiles)} files, ${formatBytes(report.totalBytes)}`);
+  if (report.topModules.length > 0) {
+    logger.info("");
+    logger.info("top modules by size:");
+    for (const entry of report.topModules) {
+      logger.info(`  ${formatBytes(entry.sizeBytes).padStart(10, " ")}  ${entry.path}`);
+    }
+  }
+  if (report.generatedFiles.length > 0) {
+    logger.info("");
+    logger.info(`_generated/ files: ${String(report.generatedFiles.length)}`);
+    for (const entry of report.generatedFiles) {
+      logger.info(`  ${formatBytes(entry.sizeBytes).padStart(10, " ")}  ${entry.path}`);
+    }
+  }
+};
+const runAnalyzeCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const { logger } = options;
+  let outdir;
+  let descriptor;
+  let temporary = false;
+  if (options.inspectOnly) {
+    outdir = options.inspectOnly;
+  } else {
+    outdir = mkdtempSync(join(tmpdir(), "lunora-analyze-"));
+    temporary = true;
+    descriptor = {
+      args: ["exec", "wrangler", "deploy", "--dry-run", "--outdir", outdir],
+      command: "pnpm",
+      cwd
+    };
+    logger.info(`analyze: building via ${descriptor.command} ${descriptor.args.join(" ")}`);
+    const spawner = options.spawner ?? defaultSpawner;
+    const spawned = await spawner(descriptor);
+    if (spawned.code !== 0) {
+      logger.error(`analyze: wrangler dry-run failed (exit ${String(spawned.code)})`);
+      rmSync(outdir, { force: true, recursive: true });
+      return { code: spawned.code, descriptor, report: void 0 };
+    }
+  }
+  try {
+    if (!existsSync(outdir)) {
+      logger.error(`analyze: outdir not found at ${outdir}`);
+      return { code: 1, descriptor, report: void 0 };
+    }
+    const report = buildReport(outdir);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(report, void 0, 2)}
+`);
+    } else {
+      renderText(report, logger);
+    }
+    return { code: 0, descriptor, report };
+  } finally {
+    if (temporary && existsSync(outdir)) {
+      try {
+        rmSync(outdir, { force: true, recursive: true });
+      } catch {
+      }
+    }
+  }
+};
+const execute = defineHandler(
+  ({ cwd, logger, options }) => runAnalyzeCommand({ cwd, json: options.json === true, logger })
+);
+
+export { execute, runAnalyzeCommand };

package/dist/packem_chunks/handler20.mjs

@@ -0,0 +1,94 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'jsonc-parser';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import { o as openUrl } from '../packem_shared/open-url-Dfq6fAyT.mjs';
+
+const DEFAULT_DEV_PORT = 8787;
+const STUDIO_PATH = "/_lunora/studio";
+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 readWrangler = (projectRoot) => {
+  const file = findWranglerFile(projectRoot);
+  if (!file) {
+    return void 0;
+  }
+  try {
+    const parsed = parse(readFileSync(file, "utf8"));
+    return parsed !== null && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const resolveDevPort = (wrangler) => {
+  if (!wrangler) {
+    return DEFAULT_DEV_PORT;
+  }
+  const { dev } = wrangler;
+  if (dev !== null && typeof dev === "object") {
+    const { port } = dev;
+    if (typeof port === "number" && Number.isFinite(port)) {
+      return port;
+    }
+  }
+  return DEFAULT_DEV_PORT;
+};
+const resolveRemoteUrl = (wrangler) => {
+  if (!wrangler) {
+    return void 0;
+  }
+  const { routes } = wrangler;
+  if (Array.isArray(routes) && routes.length > 0) {
+    const first = routes[0];
+    if (typeof first === "string") {
+      return `https://${first.split("/")[0] ?? first}${STUDIO_PATH}`;
+    }
+    if (first !== null && typeof first === "object") {
+      const { pattern } = first;
+      if (typeof pattern === "string" && pattern.length > 0) {
+        return `https://${pattern.split("/")[0] ?? pattern}${STUDIO_PATH}`;
+      }
+    }
+  }
+  const { name } = wrangler;
+  if (typeof name === "string" && name.length > 0) {
+    return `https://${name}.workers.dev${STUDIO_PATH}`;
+  }
+  return void 0;
+};
+const runViewCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const wrangler = readWrangler(cwd);
+  const { logger } = options;
+  let url;
+  if (options.remote) {
+    url = resolveRemoteUrl(wrangler);
+    if (!url) {
+      logger.error("view --remote: could not determine the remote URL from wrangler config (set `routes` or `name`).");
+      return { code: 1, url: void 0 };
+    }
+  } else {
+    url = `http://localhost:${String(resolveDevPort(wrangler))}${STUDIO_PATH}`;
+  }
+  logger.info(`opening ${url}`);
+  try {
+    await openUrl(url, { opener: options.opener });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`view: failed to open URL: ${message}`);
+    return { code: 1, url };
+  }
+  return { code: 0, url };
+};
+const execute = defineHandler(
+  ({ cwd, logger, options }) => runViewCommand({ cwd, logger, remote: options.remote === true })
+);
+
+export { execute, runViewCommand };