@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_chunks/runInitCommand.mjs

@@ -0,0 +1,652 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync, mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { detectFramework as detectFramework$1, isInteractive, promptSelect, promptMultiSelect } from '@lunora/config';
+import { walkSync } from '@visulima/fs';
+import { resolve, join as join$1, relative, dirname as dirname$1 } from '@visulima/path';
+import { downloadTemplate } from 'giget';
+import { join, dirname } from 'node:path';
+import { d as defineHandler } from '../packem_shared/command-BDXcJCCJ.mjs';
+import MagicString from 'magic-string';
+import { Project, SyntaxKind } from 'ts-morph';
+import { p as promptAuthProvider, E as EMAIL_ITEM } from '../packem_shared/features-ocSSpZtS.mjs';
+import { runAddCommand } from '../packem_shared/runAddCommand-BZGkRnBs.mjs';
+
+const GITHUB_CONTENT = `name: Deploy
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+# Set these repository secrets (Settings → Secrets and variables → Actions):
+#   CLOUDFLARE_API_TOKEN   — a Workers-scoped API token
+#   CLOUDFLARE_ACCOUNT_ID  — your Cloudflare account id
+env:
+  CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+  CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+jobs:
+  # Production deploy on push to the default branch.
+  deploy:
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      # Codegen + wrangler validation gate (no deploy) — fails fast on drift.
+      - run: pnpm exec lunora prepare
+      - run: pnpm exec lunora deploy
+
+  # Preview version on every pull request — uploads a versioned preview URL;
+  # production traffic is untouched.
+  preview:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm exec lunora deploy --preview
+`;
+const GITLAB_CONTENT = `stages:
+  - deploy
+
+# Set these as masked CI/CD variables (Settings → CI/CD → Variables):
+#   CLOUDFLARE_API_TOKEN   — a Workers-scoped API token
+#   CLOUDFLARE_ACCOUNT_ID  — your Cloudflare account id
+.lunora_base:
+  image: node:22
+  stage: deploy
+  before_script:
+    - corepack enable
+    - pnpm install --frozen-lockfile
+
+# Production deploy on the default branch.
+deploy:
+  extends: .lunora_base
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+  script:
+    # Codegen + wrangler validation gate (no deploy) — fails fast on drift.
+    - pnpm exec lunora prepare
+    - pnpm exec lunora deploy
+
+# Preview version on every merge request (versioned preview URL; production
+# traffic is untouched).
+preview:
+  extends: .lunora_base
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+  script:
+    - pnpm exec lunora deploy --preview
+`;
+const WORKFLOWS = {
+  github: {
+    content: GITHUB_CONTENT,
+    file: join(".github", "workflows", "deploy.yml"),
+    secretsHint: "repository secrets (Settings → Secrets and variables → Actions)"
+  },
+  gitlab: {
+    content: GITLAB_CONTENT,
+    file: ".gitlab-ci.yml",
+    secretsHint: "masked CI/CD variables (Settings → CI/CD → Variables)"
+  }
+};
+const isCiProvider = (value) => value === "github" || value === "gitlab";
+const writeCiWorkflow = (projectRoot, provider, options = {}) => {
+  const spec = WORKFLOWS[provider];
+  const path = join(projectRoot, spec.file);
+  if (existsSync(path) && options.overwrite !== true) {
+    return { path, skipped: true, written: false };
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, spec.content, "utf8");
+  return { path, skipped: false, written: true };
+};
+const scaffoldCiWorkflow = (projectRoot, provider, logger, options = {}) => {
+  const spec = WORKFLOWS[provider];
+  try {
+    const result = writeCiWorkflow(projectRoot, provider, options);
+    if (result.skipped) {
+      logger.info(`--ci ${provider}: ${spec.file} already exists — left unchanged (re-run with overwrite to replace).`);
+    } else {
+      logger.success(`--ci ${provider}: wrote ${spec.file}`);
+      logger.info(`--ci ${provider}: set CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID as ${spec.secretsHint} to enable deploys.`);
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`--ci ${provider}: could not write ${spec.file} (${message})`);
+    return { path: join(projectRoot, spec.file), skipped: false, written: false };
+  }
+};
+
+const ADAPTER_BY_FRAMEWORK = {
+  astro: "@lunora/react",
+  none: "@lunora/react",
+  nuxt: "@lunora/vue",
+  "react-router": "@lunora/react",
+  "solid-start": "@lunora/solid",
+  sveltekit: "@lunora/svelte",
+  "tanstack-start": "@lunora/react",
+  "tanstack-start-solid": "@lunora/solid"
+};
+const detectFramework = (root) => {
+  const base = detectFramework$1(root);
+  return { ...base, adapter: ADAPTER_BY_FRAMEWORK[base.framework] };
+};
+
+const LUNORA_CALL = "lunora()";
+const LUNORA_IMPORT = 'import { lunora } from "@lunora/vite";';
+const LUNORA_CALL_RE = /\blunora\s*\(/u;
+const LUNORA_VITE_DOUBLE = '"@lunora/vite"';
+const LUNORA_VITE_SINGLE = "'@lunora/vite'";
+const findDefineConfigObject = (sf) => {
+  for (const statement of sf.getStatements()) {
+    if (statement.getKind() !== SyntaxKind.ExportAssignment) {
+      continue;
+    }
+    const expr = statement.asKindOrThrow(SyntaxKind.ExportAssignment).getExpression();
+    if (expr.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = expr.asKindOrThrow(SyntaxKind.CallExpression);
+    if (call.getExpression().getText() !== "defineConfig") {
+      continue;
+    }
+    const argument = call.getArguments()[0];
+    if (argument?.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      return argument.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+  }
+  return void 0;
+};
+const findPlainExportObject = (sf) => {
+  for (const statement of sf.getStatements()) {
+    if (statement.getKind() !== SyntaxKind.ExportAssignment) {
+      continue;
+    }
+    const expr = statement.asKindOrThrow(SyntaxKind.ExportAssignment).getExpression();
+    if (expr.getKind() === SyntaxKind.ObjectLiteralExpression) {
+      return expr.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    }
+  }
+  return void 0;
+};
+const findConfigObject = (sourceText) => {
+  const project = new Project({
+    compilerOptions: { allowJs: true },
+    useInMemoryFileSystem: true
+  });
+  const sf = project.createSourceFile("vite.config.ts", sourceText, { overwrite: true });
+  return findDefineConfigObject(sf) ?? findPlainExportObject(sf);
+};
+const importInsertPosition = (sourceText) => {
+  const project = new Project({
+    compilerOptions: { allowJs: true },
+    useInMemoryFileSystem: true
+  });
+  const sf = project.createSourceFile("vite.config.ts", sourceText, { overwrite: true });
+  const imports = sf.getImportDeclarations();
+  if (imports.length === 0) {
+    return 0;
+  }
+  const last = imports[imports.length - 1];
+  if (last === void 0) {
+    return 0;
+  }
+  return last.getEnd();
+};
+const addImport = (ms, source) => {
+  const insertAt = importInsertPosition(source);
+  if (insertAt === 0) {
+    ms.prepend(`${LUNORA_IMPORT}
+`);
+  } else {
+    ms.appendLeft(insertAt, `
+${LUNORA_IMPORT}`);
+  }
+};
+const patchPluginsArray = (ms, configObject) => {
+  const pluginsProp = configObject.getProperty("plugins");
+  if (pluginsProp === void 0) {
+    const properties = configObject.getProperties();
+    const openBrace = configObject.getStart() + 1;
+    if (properties.length === 0) {
+      ms.appendLeft(openBrace, ` plugins: [${LUNORA_CALL}] `);
+    } else {
+      const firstProp = properties[0];
+      if (firstProp !== void 0) {
+        ms.appendLeft(firstProp.getStart(), `plugins: [${LUNORA_CALL}],
+    `);
+      }
+    }
+    return;
+  }
+  const arrayLit = pluginsProp.getDescendantsOfKind(SyntaxKind.ArrayLiteralExpression)[0];
+  if (arrayLit === void 0) {
+    return;
+  }
+  const elements = arrayLit.getElements();
+  if (elements.length === 0) {
+    ms.appendLeft(arrayLit.getStart() + 1, LUNORA_CALL);
+  } else {
+    const firstElement = elements[0];
+    if (firstElement !== void 0) {
+      ms.appendLeft(firstElement.getStart(), `${LUNORA_CALL}, `);
+    }
+  }
+};
+const patchViteConfig = (source) => {
+  if (LUNORA_CALL_RE.test(source)) {
+    return { changed: false, code: source, reason: "lunora plugin already present" };
+  }
+  const configObject = findConfigObject(source);
+  if (configObject === void 0) {
+    return { changed: false, code: source, reason: "could not locate a Vite config plugins array to patch" };
+  }
+  const ms = new MagicString(source);
+  const alreadyImported = source.includes(LUNORA_VITE_DOUBLE) || source.includes(LUNORA_VITE_SINGLE);
+  if (alreadyImported) {
+    patchPluginsArray(ms, configObject);
+  } else {
+    addImport(ms, source);
+    patchPluginsArray(ms, configObject);
+  }
+  return { changed: true, code: ms.toString() };
+};
+
+const STACK_FEATURE_OPTIONS = [
+  { description: "Sign-up / sign-in (asks which provider)", label: "Authentication", value: "auth" },
+  { description: "Cloudflare Email Workers + a dev mail catcher", label: "Transactional email", value: "email" }
+];
+const offerRegistryExtras = async (deps) => {
+  if (!deps.interactive) {
+    deps.logger.info("tip: add authentication or email later with `lunora add auth` / `lunora add email`.");
+    return;
+  }
+  const picked = await deps.multiSelect("Which features do you want to add?", STACK_FEATURE_OPTIONS, { defaults: [] });
+  for (const feature of picked) {
+    if (feature === "auth") {
+      const provider = await promptAuthProvider(deps.select);
+      await deps.apply([provider]);
+    } else {
+      await deps.apply([EMAIL_ITEM]);
+    }
+  }
+};
+
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".gitignore", ".html", ".js", ".json", ".jsonc", ".md", ".mjs", ".ts", ".tsx"]);
+const VITE_CONFIG_CANDIDATES = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+const MINIMAL_VITE_CONFIG = `import { defineConfig } from "vite";
+import { lunora } from "@lunora/vite";
+
+export default defineConfig({ plugins: [lunora()] });
+`;
+const SAMPLE_SCHEMA = `import { defineSchema, defineTable, v } from "@lunora/server";
+
+export default defineSchema({
+    messages: defineTable({
+        channelId: v.id("channels"),
+        text: v.string(),
+    })
+        .shardBy("channelId")
+        .index("by_channel", ["channelId"]),
+});
+`;
+const SAMPLE_FUNCTION = `import { mutation, query, v } from "./_generated/server";
+
+export const list = query
+    .input({ channelId: v.id("channels"), limit: v.optional(v.number()) })
+    .query(async ({ args }) => {
+        return { channelId: args.channelId, limit: args.limit ?? 50, messages: [] };
+    });
+
+export const send = mutation
+    .input({ channelId: v.id("channels"), text: v.string() })
+    .mutation(async ({ args }) => {
+        return { channelId: args.channelId, text: args.text };
+    });
+`;
+const DEFAULT_SOURCE_BASE = "gh:anolilab/lunora/templates";
+const DEFAULT_SOURCE_REF_FALLBACK = "alpha";
+const resolveCliVersion = () => {
+  try {
+    let directory = dirname$1(fileURLToPath(import.meta.url));
+    for (let index = 0; index < 5; index += 1) {
+      const candidate = join$1(directory, "package.json");
+      if (existsSync(candidate)) {
+        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+        if (parsed.name === "@lunora/cli" && typeof parsed.version === "string") {
+          return parsed.version;
+        }
+      }
+      const parent = dirname$1(directory);
+      if (parent === directory) {
+        break;
+      }
+      directory = parent;
+    }
+  } catch {
+  }
+  return "0.0.0";
+};
+const resolveDefaultSourceRef = () => {
+  const version = resolveCliVersion();
+  return version === "0.0.0" ? DEFAULT_SOURCE_REF_FALLBACK : `v${version}`;
+};
+const isTextFile = (filePath) => {
+  const lastDot = filePath.lastIndexOf(".");
+  if (lastDot === -1) {
+    return false;
+  }
+  return TEXT_EXTENSIONS.has(filePath.slice(lastDot));
+};
+const substitute = (content, name) => content.replaceAll("{{name}}", name);
+const collectFiles = (directory) => {
+  const out = [];
+  for (const entry of walkSync(directory, { includeDirs: false, includeFiles: true })) {
+    out.push(entry.path);
+  }
+  return out;
+};
+const copyTemplate = (sourceDirectory, target, name) => {
+  const files = collectFiles(sourceDirectory);
+  const written = [];
+  for (const source of files) {
+    const relativePath = relative(sourceDirectory, source);
+    const destination = join$1(target, relativePath);
+    mkdirSync(dirname$1(destination), { recursive: true });
+    const raw = readFileSync(source);
+    const text = isTextFile(source) ? substitute(raw.toString("utf8"), name) : void 0;
+    if (text === void 0) {
+      writeFileSync(destination, raw);
+    } else {
+      writeFileSync(destination, text, "utf8");
+    }
+    written.push(destination);
+  }
+  return written;
+};
+const resolveTemplateSource = (templateType, source) => {
+  if (source !== void 0 && source.length > 0) {
+    return source;
+  }
+  return `${DEFAULT_SOURCE_BASE}/${templateType}#${resolveDefaultSourceRef()}`;
+};
+const isSafeSource = (source) => {
+  if (source.includes("..")) {
+    return false;
+  }
+  return source.startsWith("gh:") || source.startsWith("github:") || source.startsWith("https://");
+};
+const logScaffoldSuccess = (logger, written, target, name) => {
+  logger.success(`scaffolded ${String(written.length)} files into ${target}`);
+  logger.info("next steps:");
+  logger.info(`  cd ${name}`);
+  logger.info("  pnpm install");
+  logger.info("  pnpm dev");
+};
+const scaffoldFromLocal = (fromRoot, templateType, target, name, logger) => {
+  const templateDirectory = join$1(fromRoot, templateType);
+  if (!existsSync(templateDirectory)) {
+    logger.error(`template not found in local source: ${templateDirectory}`);
+    return { code: 1, files: [], target };
+  }
+  const written = copyTemplate(templateDirectory, target, name);
+  logScaffoldSuccess(logger, written, target, name);
+  return { code: 0, files: written, target };
+};
+const scaffoldFromRemote = async (source, templateType, target, name, logger) => {
+  const stagingRoot = mkdtempSync(join$1(tmpdir(), "lunora-init-fetch-"));
+  const stagingDirectory = join$1(stagingRoot, "template");
+  try {
+    const remote = resolveTemplateSource(templateType, source);
+    logger.info(`fetching template from ${remote}`);
+    const downloaded = await downloadTemplate(remote, {
+      cwd: stagingRoot,
+      dir: stagingDirectory,
+      force: true,
+      install: false,
+      silent: true
+    });
+    const staged = collectFiles(stagingDirectory);
+    if (downloaded.commit) {
+      logger.info(`resolved ${downloaded.source} @ ${downloaded.commit} (${String(staged.length)} file(s))`);
+    } else {
+      logger.info(`resolved ${downloaded.source} (${String(staged.length)} file(s))`);
+    }
+    const written = copyTemplate(stagingDirectory, target, name);
+    logScaffoldSuccess(logger, written, target, name);
+    return { code: 0, files: written, target };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`failed to download template: ${message}`);
+    return { code: 1, files: [], target };
+  } finally {
+    rmSync(stagingRoot, { force: true, recursive: true });
+  }
+};
+const createMinimalViteConfig = (cwd, logger) => {
+  const target = join$1(cwd, "vite.config.ts");
+  try {
+    writeFileSync(target, MINIMAL_VITE_CONFIG, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not write ${target}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  logger.success(`created ${target} with lunora() plugin`);
+  return { code: 0, files: [target], target: cwd };
+};
+const patchExistingViteConfig = (viteConfigPath, cwd, logger) => {
+  let source;
+  try {
+    source = readFileSync(viteConfigPath, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not read ${viteConfigPath}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  const result = patchViteConfig(source);
+  if (!result.changed) {
+    logger.info(`${viteConfigPath}: ${result.reason ?? "no changes needed"}`);
+    return { code: 0, files: [], target: cwd };
+  }
+  try {
+    writeFileSync(viteConfigPath, result.code, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --in-place: could not write ${viteConfigPath}: ${message}`);
+    return { code: 1, files: [], target: cwd };
+  }
+  logger.success(`patched ${viteConfigPath} — added lunora() plugin`);
+  return { code: 0, files: [viteConfigPath], target: cwd };
+};
+const scaffoldLunoraDirectory = (cwd, logger) => {
+  const lunoraDirectory = join$1(cwd, "lunora");
+  const schemaPath = join$1(lunoraDirectory, "schema.ts");
+  if (existsSync(schemaPath)) {
+    logger.info(`lunora/ already present — left ${schemaPath} untouched`);
+    return [];
+  }
+  const written = [];
+  try {
+    mkdirSync(lunoraDirectory, { recursive: true });
+    writeFileSync(schemaPath, SAMPLE_SCHEMA, "utf8");
+    written.push(schemaPath);
+    const functionPath = join$1(lunoraDirectory, "messages.ts");
+    if (!existsSync(functionPath)) {
+      writeFileSync(functionPath, SAMPLE_FUNCTION, "utf8");
+      written.push(functionPath);
+    }
+    logger.success(`scaffolded lunora/ (${String(written.length)} file(s))`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`init --here: could not scaffold lunora/: ${message}`);
+  }
+  return written;
+};
+const printFrameworkNextSteps = (detection, logger) => {
+  const { adapter, class: frameworkClass, framework } = detection;
+  logger.info("");
+  logger.info(`detected framework: ${framework} (class ${frameworkClass})`);
+  logger.info("next steps:");
+  logger.info(`  1. install the adapter:  pnpm add ${adapter} @lunora/client @lunora/runtime @lunora/server`);
+  logger.info("  2. run codegen:          lunora codegen");
+  if (frameworkClass === "A") {
+    logger.info("  3. compose one worker:   wrap your worker entry with");
+    logger.info("       createWorker({ httpRouter: <your framework SSR handler>, shardDO: ShardDO, ... })");
+    logger.info(`  4. add the provider:     mount the ${adapter} provider in your root layout/route`);
+    logger.info("  5. make a loader live:   preloadQuery() in a loader, usePreloadedQuery() in the component");
+    logger.info("     see https://lunora.sh/docs/frameworks/reactive-loaders");
+  } else if (frameworkClass === "B") {
+    logger.info("  3. inject Lunora:        mount Lunora realtime under /_lunora/* in your server hook");
+    logger.info(`       (${framework} owns its Cloudflare adapter — Lunora composes into its server entry)`);
+    logger.info(`  4. add the provider:     mount the ${adapter} provider in your root layout`);
+    logger.info("  5. read the guide:       https://lunora.sh/docs/frameworks/deploy");
+  } else {
+    logger.info("  3. add the provider:     wrap your app with the LunoraProvider from @lunora/react");
+    logger.info("  4. read the guide:       https://lunora.sh/docs/frameworks/bring-your-framework");
+  }
+  logger.info("");
+};
+const findExistingViteConfig = (cwd) => {
+  for (const candidate of VITE_CONFIG_CANDIDATES) {
+    const full = join$1(cwd, candidate);
+    if (existsSync(full)) {
+      return full;
+    }
+  }
+  return void 0;
+};
+const patchOrCreateViteConfig = (cwd, framework, logger) => {
+  const viteConfigPath = findExistingViteConfig(cwd);
+  if (viteConfigPath === void 0) {
+    if (framework === "sveltekit" || framework === "nuxt" || framework === "astro") {
+      logger.info(`no Vite config found — ${framework} wires Lunora through its server entry (see next steps)`);
+      return { code: 0, files: [], target: cwd };
+    }
+    return createMinimalViteConfig(cwd, logger);
+  }
+  return patchExistingViteConfig(viteConfigPath, cwd, logger);
+};
+const runInPlaceInit = (cwd, logger) => {
+  const detection = detectFramework(cwd);
+  const viteResult = patchOrCreateViteConfig(cwd, detection.framework, logger);
+  if (viteResult.code !== 0) {
+    return viteResult;
+  }
+  const scaffolded = scaffoldLunoraDirectory(cwd, logger);
+  printFrameworkNextSteps(detection, logger);
+  return { code: 0, files: [...viteResult.files, ...scaffolded], target: cwd };
+};
+const offerIsInteractive = (options) => options.yes !== true && (options.prompt !== void 0 || (options.interactive ?? isInteractive()));
+const maybeOfferExtras = async (options, projectDirectory) => {
+  const interactive = offerIsInteractive(options);
+  const apply = async (names) => {
+    const result = await runAddCommand({
+      allowUnsafeSource: options.allowUnsafeSource,
+      cwd: projectDirectory,
+      from: options.registryFrom,
+      logger: options.logger,
+      names: [...names],
+      source: options.registrySource,
+      yes: true
+    });
+    return result.code === 0;
+  };
+  await offerRegistryExtras({
+    apply,
+    interactive,
+    logger: options.logger,
+    multiSelect: options.prompt?.multiSelect ?? ((message, choices, settings) => promptMultiSelect(message, choices, settings)),
+    select: options.prompt?.select ?? ((message, choices, settings) => promptSelect(message, choices, settings))
+  });
+};
+const scaffoldNewProject = async (options, cwd) => {
+  const name = options.name ?? "lunora-app";
+  const templateType = options.templateType ?? "vite";
+  if (templateType === "next") {
+    options.logger.warn('template "next" is not yet available — re-run with `-t vite` or `-t standalone`.');
+    return { code: 1, files: [], target: "" };
+  }
+  if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
+    options.logger.error(`init: refusing project name "${name}" — must not contain path separators or be "." / "..".`);
+    return { code: 1, files: [], target: "" };
+  }
+  const target = resolve(cwd, name);
+  if (existsSync(target)) {
+    const entries = readdirSync(target);
+    if (entries.length > 0) {
+      options.logger.error(`target directory not empty: ${target}`);
+      return { code: 1, files: [], target };
+    }
+  }
+  if (options.from !== void 0) {
+    return scaffoldFromLocal(options.from, templateType, target, name, options.logger);
+  }
+  if (options.source !== void 0 && options.source.length > 0 && !options.allowUnsafeSource && !isSafeSource(options.source)) {
+    options.logger.error(
+      `init: refusing --source ${options.source} — only gh:, github:, or https:// sources are allowed (and may not contain ".."). Re-run with --allow-unsafe-source if you really want this.`
+    );
+    return { code: 1, files: [], target };
+  }
+  return scaffoldFromRemote(options.source, templateType, target, name, options.logger);
+};
+const runInitCommand = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const result = options.inPlace === true ? runInPlaceInit(cwd, options.logger) : await scaffoldNewProject(options, cwd);
+  if (result.code === 0 && result.target !== "") {
+    await maybeOfferExtras(options, result.target);
+  }
+  if (result.code === 0 && options.ci !== void 0) {
+    scaffoldCiWorkflow(options.inPlace === true ? cwd : result.target, options.ci, options.logger);
+  }
+  return result;
+};
+const isTemplate = (value) => value === "astro" || value === "next" || value === "nuxt" || value === "standalone" || value === "sveltekit" || value === "tanstack-start-react" || value === "tanstack-start-solid" || value === "vite";
+const resolveCiProvider = (raw, logger) => {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (isCiProvider(raw)) {
+    return raw;
+  }
+  logger.warn(`init: unknown --ci "${raw}" — expected github | gitlab; skipping CI scaffold.`);
+  return void 0;
+};
+const execute = defineHandler(({ argument, cwd, logger, options }) => {
+  const templateRaw = options.template ?? "vite";
+  const template = isTemplate(templateRaw) ? templateRaw : "vite";
+  return runInitCommand({
+    allowUnsafeSource: options.allowUnsafeSource === true,
+    cwd,
+    ci: resolveCiProvider(options.ci, logger),
+    from: options.from,
+    inPlace: options.here === true,
+    interactive: options.interactive === true ? true : void 0,
+    logger,
+    name: argument[0],
+    source: options.source,
+    templateType: template,
+    yes: options.yes === true
+  });
+});
+
+export { execute, isTemplate, runInitCommand };