@hs-x/cli 0.1.2 → 0.2.0

package/dist/commands/init.js

@@ -1,176 +1,15 @@
 import { spawn } from 'node:child_process';
-import { mkdir, stat, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
 import * as Args from '@effect/cli/Args';
 import * as Command from '@effect/cli/Command';
 import * as Options from '@effect/cli/Options';
+import { FileSystem, Path } from '@effect/platform';
 import { Effect, Option } from 'effect';
-import { exitWith } from '../cli-error.js';
-import { cwdOption, jsonOption, runHandler, runQuarantined } from '../cli/kit.js';
-import { isInteractive, promptConfirm, promptSelect, promptText } from '../prompt.js';
-import { createReporter } from '../reporter/index.js';
+import { cliError, exitWith } from '../cli-error.js';
+import { cwdOption, jsonOption, runHandler } from '../cli/kit.js';
+import { getTemplate, resolveTemplateType, TEMPLATES, } from '../init/templates.js';
+import { BACK, isInteractive, promptConfirm, promptSelect, promptText } from '../prompt.js';
 import { Cwd } from '../services/cwd.js';
-export async function initProject({ argv, cwd, json, }) {
-    const { getTemplate, resolveTemplateType, TEMPLATES } = await import('../init/templates.js');
-    const positional = argv[1] && !argv[1].startsWith('-') ? argv[1] : undefined;
-    const flagName = resolveFlag(argv, '--name');
-    const flagTemplateRaw = resolveFlag(argv, '--template') ?? resolveFlag(argv, '--type');
-    const flagTemplate = resolveTemplateType(flagTemplateRaw);
-    if (flagTemplateRaw && !flagTemplate) {
-        throw new Error(`Unknown app type: ${flagTemplateRaw}. Use workflow-action, sync-source, or empty.`);
-    }
-    const flagAppName = resolveFlag(argv, '--app-name') ?? resolveFlag(argv, '--display-name');
-    const flagYes = argv.includes('--yes') || argv.includes('-y');
-    const flagSkipInstall = argv.includes('--no-install');
-    const force = argv.includes('--force');
-    const interactive = !json && isInteractive();
-    let workingCwd = cwd;
-    if (positional &&
-        (positional.includes('/') || positional.startsWith('.') || positional.startsWith('~'))) {
-        const expanded = positional.startsWith('~')
-            ? join(process.env.HOME ?? '', positional.slice(1))
-            : positional;
-        const abs = resolve(cwd, expanded);
-        workingCwd = dirname(abs);
-    }
-    const reporter = createReporter({ command: 'init', argv, entry: true });
-    let bannerShown = false;
-    if (interactive) {
-        reporter.banner();
-        bannerShown = true;
-    }
-    const rawName = positional ?? flagName;
-    let name;
-    if (rawName) {
-        name = basename(rawName.startsWith('~')
-            ? join(process.env.HOME ?? '', rawName.slice(1))
-            : resolve(workingCwd, rawName));
-        const validationError = validateProjectName(name);
-        if (validationError) {
-            const code = 'HSX_E_INPUT_BAD_NAME';
-            reporter.error(code, `Invalid project name: ${name}`, {
-                hint: validationError,
-                docs_url: `https://hs-x.dev/errors/${code}`,
-            });
-            reporter.done(undefined, 10);
-            return { exitCode: 10 };
-        }
-    }
-    if (!name) {
-        if (interactive) {
-            const answer = await promptText({
-                message: 'Project name',
-                default: 'hsx-app',
-                validate: validateProjectName,
-            });
-            if (answer === undefined)
-                return cancelledResult(argv, 'init');
-            name = answer;
-        }
-        else {
-            name = 'hsx-app';
-        }
-    }
-    let templateId = flagTemplate ?? 'deals-tagger';
-    if (!flagTemplate && interactive) {
-        const picked = await promptSelect({
-            message: 'What are you building?',
-            default: 'deals-tagger',
-            options: TEMPLATES.map((t) => ({
-                value: t.id,
-                label: t.label,
-                description: t.description,
-            })),
-        });
-        if (picked === undefined)
-            return cancelledResult(argv, 'init');
-        templateId = picked;
-    }
-    let appName = flagAppName;
-    if (appName === undefined && interactive) {
-        const answer = await promptText({
-            message: 'HubSpot app name',
-            default: toDisplayName(name),
-            validate(value) {
-                return value.trim().length === 0 ? 'Enter an app name.' : undefined;
-            },
-        });
-        if (answer === undefined)
-            return cancelledResult(argv, 'init');
-        appName = answer.trim();
-    }
-    appName = appName?.trim() || toDisplayName(name);
-    let shouldInstall = false;
-    if (!flagSkipInstall && interactive && !flagYes) {
-        const confirmed = await promptConfirm({
-            message: 'Install dependencies now?',
-            default: true,
-        });
-        if (confirmed === undefined)
-            return cancelledResult(argv, 'init');
-        shouldInstall = confirmed;
-    }
-    else if (flagYes && !flagSkipInstall) {
-        shouldInstall = true;
-    }
-    const root = resolve(workingCwd, name);
-    const configPath = join(root, 'hsx.config.ts');
-    const configExists = await stat(configPath).then(() => true, () => false);
-    if (configExists && !force) {
-        const code = 'HSX_E_INIT_DIR_NOT_EMPTY';
-        reporter.error(code, `Project already exists at ${root}.`, {
-            hint: `Pick a new directory, delete the existing one (rm -rf ${root}), or pass --force to overwrite.`,
-            docs_url: `https://hs-x.dev/errors/${code}`,
-        });
-        reporter.done(undefined, 10);
-        return { exitCode: 10 };
-    }
-    if (interactive)
-        reporter.header(name);
-    else if (!json && !bannerShown) {
-        reporter.banner();
-        reporter.header(name);
-    }
-    const template = getTemplate(templateId);
-    const files = template.files(name, { appName });
-    await mkdir(join(root, 'src', 'workers'), { recursive: true });
-    const scaffoldStep = reporter.step('Scaffolding project');
-    for (const file of files) {
-        const filePath = join(root, file.path);
-        await mkdir(dirname(filePath), { recursive: true });
-        await writeFile(filePath, file.contents, { flag: force ? 'w' : 'wx' });
-    }
-    scaffoldStep.ok(`${files.length} file${files.length === 1 ? '' : 's'}  ${root}`);
-    if (shouldInstall) {
-        const installStep = reporter.step('Installing dependencies');
-        try {
-            await runInstall(root);
-            installStep.ok();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            installStep.fail(message);
-            reporter.warn('HSX_W_INIT_INSTALL_FAILED', `Dependency install failed; you can retry with: cd ${name} && bun install`);
-        }
-    }
-    const result = {
-        ok: true,
-        command: 'init',
-        project: { name, appName, root, template: templateId, installed: shouldInstall },
-    };
-    if (json) {
-        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        return { exitCode: 0 };
-    }
-    reporter.info('');
-    reporter.info('Next steps:');
-    reporter.info(`  cd ${name}`);
-    if (!shouldInstall)
-        reporter.info('  bun install');
-    reporter.info('  hs-x dev');
-    reporter.done('Created');
-    return { exitCode: 0 };
-}
+import { Reporter } from '../services/reporter.js';
 function validateProjectName(input) {
     if (!input)
         return 'Name is required.';
@@ -185,53 +24,66 @@ function toDisplayName(name) {
         .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
         .join(' ');
 }
+/** Resolve an optional enum flag against its allowed values (trimmed, lowercased). */
+function resolveEnumFlag(value, allowed) {
+    const raw = Option.getOrUndefined(value)?.trim().toLowerCase();
+    return raw && allowed.includes(raw) ? raw : undefined;
+}
+// LEAF QUARANTINE: genuine subprocess I/O. Spawns `bun install` in the new
+// project root; wrapped in `Effect.tryPromise` by the handler.
+//
+// A timeout is mandatory: `bun install` retries network fetches with backoff
+// when the registry is unreachable, so an offline scaffold would otherwise sit
+// on a silent (stdio: 'ignore') `… Installing dependencies` line forever. On
+// timeout we kill the child and reject; the handler then surfaces the graceful
+// "retry with bun install" hint instead of hanging.
+const INSTALL_TIMEOUT_MS = 180_000;
 async function runInstall(root) {
+    try {
+        await runInstallWith('bun', root);
+    }
+    catch (error) {
+        // The CLI runs fine under plain node; a node-only machine has no `bun` on
+        // PATH (spawn ENOENT). Fall back to npm so `npm i -g @hs-x/cli && hs-x init`
+        // works without installing Bun first.
+        if (error.code === 'ENOENT') {
+            await runInstallWith('npm', root);
+            return;
+        }
+        throw error;
+    }
+}
+async function runInstallWith(tool, root) {
     await new Promise((resolvePromise, rejectPromise) => {
-        const child = spawn('bun', ['install'], { cwd: root, stdio: 'ignore' });
-        child.on('error', rejectPromise);
+        const child = spawn(tool, ['install'], { cwd: root, stdio: 'ignore' });
+        const timer = setTimeout(() => {
+            child.kill('SIGKILL');
+            rejectPromise(new Error(`${tool} install timed out after ${INSTALL_TIMEOUT_MS / 1000}s (registry unreachable?)`));
+        }, INSTALL_TIMEOUT_MS);
+        timer.unref?.();
+        child.on('error', (error) => {
+            clearTimeout(timer);
+            rejectPromise(error);
+        });
         child.on('exit', (code) => {
+            clearTimeout(timer);
             if (code === 0)
                 resolvePromise();
             else
-                rejectPromise(new Error(`bun install exited with code ${code}`));
+                rejectPromise(new Error(`${tool} install exited with code ${code}`));
         });
     });
 }
-function cancelledResult(argv, command) {
-    const reporter = createReporter({ command, argv });
-    reporter.info('Cancelled.');
-    return { exitCode: 130 };
-}
-function isFlagValue(value) {
-    return value !== undefined && value.length > 0 && !value.startsWith('-');
-}
-function resolveFlag(argv, flag) {
-    const index = argv.indexOf(flag);
-    if (index !== -1) {
-        const next = argv[index + 1];
-        if (isFlagValue(next))
-            return next;
-    }
-    const prefix = `${flag}=`;
-    const found = argv.find((arg) => arg.startsWith(prefix));
-    if (!found)
-        return undefined;
-    const value = found.slice(prefix.length);
-    return value.length > 0 ? value : undefined;
-}
-// ─── Native @effect/cli command (Phase 4) ──────────────────────────────────
-// `init` is QUARANTINED: scaffolding binds to an imperative, prompt-driven body
-// (`promptText`/`promptSelect`/`promptConfirm`, `mkdir`/`writeFile`, and a
-// `bun install` child process) whose internal purity is out of scope for this
-// pass. The native command reconstructs the legacy argv from its typed options /
-// positional and delegates to the existing `initProject` Promise via
-// `Effect.tryPromise`; only the command boundary is Effect. A non-zero
-// `CliResult.exitCode` is surfaced as a silent `exitWith(code)` (output already
-// rendered by the legacy body) so `runHandler` does not re-render.
+// ─── Native @effect/cli command ────────────────────────────────────────────
+// `init` is de-quarantined: the scaffolding logic runs directly on Effect
+// services (`FileSystem`/`Path` for all fs, `Reporter` for all output, `Cwd`
+// for the working dir). Only two genuine leaf I/O seams remain wrapped in
+// `Effect.tryPromise`/`Effect.promise`: the interactive TTY prompts
+// (`promptText`/`promptSelect`/`promptConfirm`, non-json TTY only) and the
+// `bun install` subprocess (`runInstall`, only when the user opts in).
 //
 // `init` and its `create` alias are built from one factory; only the command
-// name differs (both reconstruct the same `init`-prefixed argv the legacy body
-// parses).
+// name differs.
 const nameArg = Args.text({ name: 'name' }).pipe(Args.optional);
 // Legacy init accepts the project name as EITHER a positional or `--name`.
 const nameOption = Options.text('name').pipe(Options.optional);
@@ -239,9 +91,376 @@ const templateOption = Options.text('template').pipe(Options.optional);
 const typeOption = Options.text('type').pipe(Options.optional);
 const appNameOption = Options.text('app-name').pipe(Options.optional);
 const displayNameOption = Options.text('display-name').pipe(Options.optional);
+const distributionOption = Options.text('distribution').pipe(Options.optional);
+const authOption = Options.text('auth').pipe(Options.optional);
+// Two explicit flags give the tri-state (@effect/cli doesn't auto-negate):
+// `--ui-extension` forces on, `--no-ui-extension` forces off, neither prompts.
+const uiExtensionOption = Options.boolean('ui-extension').pipe(Options.withDefault(false));
+const noUiExtensionOption = Options.boolean('no-ui-extension').pipe(Options.withDefault(false));
 const yesOption = Options.boolean('yes').pipe(Options.withAlias('y'), Options.withDefault(false));
 const noInstallOption = Options.boolean('no-install').pipe(Options.withDefault(false));
 const forceOption = Options.boolean('force').pipe(Options.withDefault(false));
+/** Emit a cancelled result (interactive prompt aborted). */
+function cancelled() {
+    return Effect.gen(function* () {
+        const reporter = yield* Reporter;
+        yield* reporter.info('Cancelled.');
+        return yield* Effect.fail(exitWith(130));
+    });
+}
+function initBody(opts) {
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        const pathSvc = yield* Path.Path;
+        const reporter = yield* Reporter;
+        // `@effect/cli` greedily consumes the NEXT token as a text option's value,
+        // so `--name --json` yields nameFlag="--json". Treat a flag-like value as a
+        // missing name and restore the swallowed `--json` so json mode isn't lost.
+        let json = opts.json;
+        let flagName;
+        if (Option.isSome(opts.nameFlag)) {
+            const value = opts.nameFlag.value;
+            if (value.startsWith('-')) {
+                if (value === '--json')
+                    json = true;
+            }
+            else {
+                flagName = value;
+            }
+        }
+        const positional = Option.getOrUndefined(opts.name);
+        const flagTemplateRaw = Option.getOrUndefined(opts.template) ?? Option.getOrUndefined(opts.type);
+        const flagTemplate = resolveTemplateType(flagTemplateRaw);
+        if (flagTemplateRaw && !flagTemplate) {
+            // Surface the same flat `{ok:false,error}` / `Error: …` shape the legacy
+            // direct dispatcher produced for a thrown error — rendered here (not via
+            // the registry error block) so the exit code path stays byte-identical.
+            const message = `Unknown app type: ${flagTemplateRaw}. Use workflow-action, sync-source, or empty.`;
+            if (json) {
+                yield* reporter.raw(`${JSON.stringify({ ok: false, error: message }, null, 2)}\n`);
+            }
+            else {
+                yield* reporter.rawErr(`Error: ${message}\n`);
+            }
+            return yield* Effect.fail(exitWith(1));
+        }
+        const flagAppName = Option.getOrUndefined(opts.appName) ?? Option.getOrUndefined(opts.displayName);
+        const flagYes = opts.yes;
+        const flagSkipInstall = opts.noInstall;
+        const force = opts.force;
+        const interactive = !json && isInteractive();
+        // `--cwd` overrides the injected process working dir.
+        let workingCwd = yield* Option.match(opts.cwd, {
+            onNone: () => Cwd,
+            onSome: (dir) => Effect.succeed(dir),
+        });
+        if (positional &&
+            (positional.includes('/') || positional.startsWith('.') || positional.startsWith('~'))) {
+            const expanded = positional.startsWith('~')
+                ? pathSvc.join(process.env.HOME ?? '', positional.slice(1))
+                : positional;
+            const abs = pathSvc.resolve(workingCwd, expanded);
+            workingCwd = pathSvc.dirname(abs);
+        }
+        let bannerShown = false;
+        if (interactive) {
+            yield* reporter.banner;
+            bannerShown = true;
+        }
+        const rawName = positional ?? flagName;
+        let name;
+        if (rawName) {
+            name = pathSvc.basename(rawName.startsWith('~')
+                ? pathSvc.join(process.env.HOME ?? '', rawName.slice(1))
+                : pathSvc.resolve(workingCwd, rawName));
+            const validationError = validateProjectName(name);
+            if (validationError) {
+                const code = 'HSX_E_INPUT_BAD_NAME';
+                yield* reporter.error(code, `Invalid project name: ${name}`, {
+                    hint: validationError,
+                    docs_url: `https://hs-x.dev/errors/${code}`,
+                });
+                yield* reporter.done(undefined, 10);
+                return yield* Effect.fail(exitWith(10));
+            }
+        }
+        // Enum flags are validated up front (the wizard never sees a bad value).
+        if (Option.isSome(opts.distribution) && !resolveEnumFlag(opts.distribution, ['private', 'marketplace'])) {
+            const message = `Unknown distribution: ${opts.distribution.value}. Use private or marketplace.`;
+            if (json)
+                yield* reporter.raw(`${JSON.stringify({ ok: false, error: message }, null, 2)}\n`);
+            else
+                yield* reporter.rawErr(`Error: ${message}\n`);
+            return yield* Effect.fail(exitWith(1));
+        }
+        if (Option.isSome(opts.auth) && !resolveEnumFlag(opts.auth, ['oauth', 'static'])) {
+            const message = `Unknown auth: ${opts.auth.value}. Use oauth or static.`;
+            if (json)
+                yield* reporter.raw(`${JSON.stringify({ ok: false, error: message }, null, 2)}\n`);
+            else
+                yield* reporter.rawErr(`Error: ${message}\n`);
+            return yield* Effect.fail(exitWith(1));
+        }
+        const flagDistribution = resolveEnumFlag(opts.distribution, ['private', 'marketplace']);
+        const flagAuth = resolveEnumFlag(opts.auth, ['oauth', 'static']);
+        // Wizard state. Flags pre-seed answers (those steps are skipped); --yes or
+        // a non-interactive run accepts the defaults below as-is.
+        const draft = {
+            name: name ?? 'hsx-app',
+            templateId: flagTemplate ?? 'deals-tagger',
+            uiExtension: opts.uiExtension && !opts.noUiExtension,
+            distribution: flagDistribution ?? 'private',
+            auth: flagAuth ?? 'oauth',
+            appName: flagAppName,
+            shouldInstall: !flagSkipInstall,
+        };
+        if (interactive && !flagYes) {
+            const steps = [
+                {
+                    skip: () => name !== undefined,
+                    run: async () => {
+                        const answer = await promptText({
+                            message: 'Project name',
+                            default: draft.name,
+                            validate: validateProjectName,
+                            allowBack: true,
+                        });
+                        if (answer === undefined)
+                            return 'cancel';
+                        if (answer === BACK)
+                            return 'back';
+                        draft.name = answer;
+                        return 'next';
+                    },
+                },
+                {
+                    skip: () => flagTemplate !== undefined,
+                    run: async () => {
+                        const picked = await promptSelect({
+                            message: 'What are you building?',
+                            default: draft.templateId,
+                            options: TEMPLATES.map((t) => ({
+                                value: t.id,
+                                label: t.label,
+                                description: t.description,
+                            })),
+                            allowBack: true,
+                        });
+                        if (picked === undefined)
+                            return 'cancel';
+                        if (picked === BACK)
+                            return 'back';
+                        draft.templateId = picked;
+                        return 'next';
+                    },
+                },
+                {
+                    // UI extension (app card): --ui-extension → on; --no-ui-extension → off.
+                    skip: () => opts.uiExtension || opts.noUiExtension,
+                    run: async () => {
+                        const confirmed = await promptConfirm({
+                            message: 'Add a UI extension (app card)?',
+                            default: draft.uiExtension,
+                            allowBack: true,
+                        });
+                        if (confirmed === undefined)
+                            return 'cancel';
+                        if (confirmed === BACK)
+                            return 'back';
+                        draft.uiExtension = confirmed;
+                        return 'next';
+                    },
+                },
+                {
+                    skip: () => flagDistribution !== undefined,
+                    run: async () => {
+                        const picked = await promptSelect({
+                            message: 'How will this app be distributed?',
+                            default: draft.distribution,
+                            options: [
+                                { value: 'private', label: 'Private', description: 'One account; not listed publicly' },
+                                {
+                                    value: 'marketplace',
+                                    label: 'Marketplace',
+                                    description: 'Listed on the HubSpot App Marketplace',
+                                },
+                            ],
+                            allowBack: true,
+                        });
+                        if (picked === undefined)
+                            return 'cancel';
+                        if (picked === BACK)
+                            return 'back';
+                        draft.distribution = picked;
+                        return 'next';
+                    },
+                },
+                {
+                    skip: () => flagAuth !== undefined,
+                    run: async () => {
+                        const picked = await promptSelect({
+                            message: 'How does the app authenticate?',
+                            default: draft.auth,
+                            options: [
+                                { value: 'oauth', label: 'OAuth', description: 'Install-time OAuth; per-portal tokens' },
+                                { value: 'static', label: 'Static', description: 'A single static access token' },
+                            ],
+                            allowBack: true,
+                        });
+                        if (picked === undefined)
+                            return 'cancel';
+                        if (picked === BACK)
+                            return 'back';
+                        draft.auth = picked;
+                        return 'next';
+                    },
+                },
+                {
+                    skip: () => flagAppName !== undefined,
+                    run: async () => {
+                        const answer = await promptText({
+                            message: 'HubSpot app name',
+                            default: draft.appName ?? toDisplayName(draft.name),
+                            validate(value) {
+                                return value.trim().length === 0 ? 'Enter an app name.' : undefined;
+                            },
+                            allowBack: true,
+                        });
+                        if (answer === undefined)
+                            return 'cancel';
+                        if (answer === BACK)
+                            return 'back';
+                        draft.appName = answer.trim();
+                        return 'next';
+                    },
+                },
+                {
+                    skip: () => flagSkipInstall,
+                    run: async () => {
+                        const confirmed = await promptConfirm({
+                            message: 'Install dependencies now?',
+                            default: draft.shouldInstall,
+                            allowBack: true,
+                        });
+                        if (confirmed === undefined)
+                            return 'cancel';
+                        if (confirmed === BACK)
+                            return 'back';
+                        draft.shouldInstall = confirmed;
+                        return 'next';
+                    },
+                },
+            ];
+            const outcome = yield* Effect.promise(async () => {
+                let index = 0;
+                while (index < steps.length) {
+                    const step = steps[index];
+                    if (step === undefined || step.skip()) {
+                        index += 1;
+                        continue;
+                    }
+                    const result = await step.run();
+                    if (result === 'cancel')
+                        return 'cancelled';
+                    if (result === 'back') {
+                        // Walk back to the previous non-skipped step; Esc on the first
+                        // step just re-asks it.
+                        let previous = index - 1;
+                        while (previous >= 0 && (steps[previous]?.skip() ?? true))
+                            previous -= 1;
+                        index = Math.max(0, previous);
+                        continue;
+                    }
+                    index += 1;
+                }
+                return 'done';
+            });
+            if (outcome === 'cancelled')
+                return yield* cancelled();
+        }
+        name = draft.name;
+        const templateId = draft.templateId;
+        const uiExtension = draft.uiExtension;
+        const distribution = draft.distribution;
+        const auth = draft.auth;
+        const appName = draft.appName?.trim() || toDisplayName(name);
+        const shouldInstall = interactive && !flagYes
+            ? !flagSkipInstall && draft.shouldInstall
+            : flagYes && !flagSkipInstall;
+        const root = pathSvc.resolve(workingCwd, name);
+        const configPath = pathSvc.join(root, 'hsx.config.ts');
+        const configExists = yield* fs.exists(configPath).pipe(Effect.orElseSucceed(() => false));
+        if (configExists && !force) {
+            const code = 'HSX_E_INIT_DIR_NOT_EMPTY';
+            yield* reporter.error(code, `Project already exists at ${root}.`, {
+                hint: `Pick a new directory, delete the existing one (rm -rf ${root}), or pass --force to overwrite.`,
+                docs_url: `https://hs-x.dev/errors/${code}`,
+            });
+            yield* reporter.done(undefined, 10);
+            return yield* Effect.fail(exitWith(10));
+        }
+        if (interactive)
+            yield* reporter.header(name);
+        else if (!json && !bannerShown) {
+            yield* reporter.banner;
+            yield* reporter.header(name);
+        }
+        const template = getTemplate(templateId);
+        const files = template.files(name, { appName, distribution, auth, uiExtension });
+        yield* fs
+            .makeDirectory(pathSvc.join(root, 'src', 'workers'), { recursive: true })
+            .pipe(Effect.mapError((cause) => cliError('HSX_E_INTERNAL', `Could not create ${root}: ${String(cause)}`)));
+        const scaffoldStep = yield* reporter.step('Scaffolding project');
+        for (const file of files) {
+            const filePath = pathSvc.join(root, file.path);
+            yield* fs
+                .makeDirectory(pathSvc.dirname(filePath), { recursive: true })
+                .pipe(Effect.mapError((cause) => cliError('HSX_E_INTERNAL', `Could not create directory for ${filePath}: ${String(cause)}`)));
+            yield* fs
+                .writeFileString(filePath, file.contents, { flag: force ? 'w' : 'wx' })
+                .pipe(Effect.mapError((cause) => cliError('HSX_E_INTERNAL', `Could not write ${filePath}: ${String(cause)}`)));
+        }
+        yield* scaffoldStep.ok(`${files.length} file${files.length === 1 ? '' : 's'}  ${root}`);
+        if (shouldInstall) {
+            const installStep = yield* reporter.step('Installing dependencies');
+            const installed = yield* Effect.tryPromise({
+                try: () => runInstall(root),
+                catch: (error) => (error instanceof Error ? error.message : String(error)),
+            }).pipe(Effect.as(true), Effect.catchAll((message) => Effect.gen(function* () {
+                yield* installStep.fail(message);
+                yield* reporter.warn('HSX_W_INIT_INSTALL_FAILED', `Dependency install failed; you can retry with: cd ${name} && bun install`);
+                return false;
+            })));
+            if (installed)
+                yield* installStep.ok();
+        }
+        const result = {
+            ok: true,
+            command: 'init',
+            project: {
+                name,
+                appName,
+                root,
+                template: templateId,
+                distribution,
+                auth,
+                uiExtension,
+                installed: shouldInstall,
+            },
+        };
+        if (json) {
+            yield* reporter.raw(`${JSON.stringify(result, null, 2)}\n`);
+            return;
+        }
+        yield* reporter.info('');
+        yield* reporter.info('Next steps:');
+        yield* reporter.info(`  cd ${name}`);
+        if (!shouldInstall)
+            yield* reporter.info('  bun install');
+        yield* reporter.info('  hs-x dev');
+        yield* reporter.done('Created');
+    });
+}
 function makeInitCmd(commandName) {
     return Command.make(commandName, {
         name: nameArg,
@@ -250,54 +469,21 @@ function makeInitCmd(commandName) {
         type: typeOption,
         appName: appNameOption,
         displayName: displayNameOption,
+        distribution: distributionOption,
+        auth: authOption,
+        uiExtension: uiExtensionOption,
+        noUiExtension: noUiExtensionOption,
         yes: yesOption,
         noInstall: noInstallOption,
         force: forceOption,
         json: jsonOption,
         cwd: cwdOption,
-    }, (opts) => runHandler(commandName, { json: opts.json }, Effect.gen(function* () {
-        // Reconstruct the legacy argv the quarantined body parses (it reads
-        // the positional name + --name/--template/etc off argv).
-        //
-        // @effect/cli greedily consumes the NEXT token as a text option's
-        // value, so `--name --json` yields nameFlag="--json". Treat a
-        // flag-like value as a missing name and restore the swallowed flag so
-        // it isn't lost (matches the legacy hardened parser).
-        let jsonOn = opts.json;
-        const argv = ['init'];
-        if (Option.isSome(opts.name))
-            argv.push(opts.name.value);
-        if (Option.isSome(opts.nameFlag)) {
-            const value = opts.nameFlag.value;
-            if (value.startsWith('-')) {
-                if (value === '--json')
-                    jsonOn = true;
-            }
-            else {
-                argv.push('--name', value);
-            }
-        }
-        if (Option.isSome(opts.template))
-            argv.push('--template', opts.template.value);
-        if (Option.isSome(opts.type))
-            argv.push('--type', opts.type.value);
-        if (Option.isSome(opts.appName))
-            argv.push('--app-name', opts.appName.value);
-        if (Option.isSome(opts.displayName)) {
-            argv.push('--display-name', opts.displayName.value);
-        }
-        if (opts.yes)
-            argv.push('--yes');
-        if (opts.noInstall)
-            argv.push('--no-install');
-        if (opts.force)
-            argv.push('--force');
-        if (jsonOn)
-            argv.push('--json');
-        const cwdOverride = Option.getOrUndefined(opts.cwd);
-        const cwd = cwdOverride ?? (yield* Cwd);
-        yield* runQuarantined(jsonOn, () => initProject({ argv, cwd, json: jsonOn }));
-    })));
+    }, (opts) => {
+        // Restore the swallowed `--json` for the reporter flag too (see initBody).
+        const json = opts.json ||
+            (Option.isSome(opts.nameFlag) && opts.nameFlag.value === '--json');
+        return runHandler(commandName, { json }, initBody(opts));
+    });
 }
 export const initCmd = makeInitCmd('init');
 export const createCmd = makeInitCmd('create');
@@ -311,6 +497,9 @@ Options:
   --type <type>            App type: workflow-action | sync-source | empty
   --template <id>          Starter template id: deals-tagger | empty | sync-source
   --app-name <name>        HubSpot app display name (defaults from project name)
+  --distribution <mode>    private (default) | marketplace
+  --auth <mode>            oauth (default) | static
+  --ui-extension           Scaffold a starter UI-extension app card (--no-ui-extension to skip)
   --yes, -y                Accept defaults (install deps, no prompts)
   --no-install             Skip dependency install
   --force                  Overwrite an existing hsx.config.ts at target