@storystick/cli 0.0.0-stage → 0.2.0-rc.0

package/dist/init.js

@@ -0,0 +1,789 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+import pc from 'picocolors';
+import { serializeSchema } from '@storystick/core/serializer';
+import { canonicalLocaleCode } from '@storystick/core/locale-routing';
+import { whoami } from './auth-device.js';
+import { acknowledgeCliBootstrap, prepareCliBootstrap, } from './bootstrap-client.js';
+import { StorystickError } from './cli-error.js';
+import { commitGeneratedFiles } from './generated-transaction.js';
+import { callHubApi } from './hub-client.js';
+import { readInitOperation, runInitOrchestrator, shellQuote, } from './init-operation.js';
+import { assertInitScaffoldReady, isNextProject, planInitScaffold, writeInitScaffold, } from './init-scaffold.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logFinishedStep, logMessage, maybeExitOnCancel, promptDeviceAuth, promptSelect, promptText, withInterrupt, } from './output.js';
+import { PROJECT_CONNECTION_ENV_KEYS, commitProjectConnection, findProjectConnectionEnvFile, parseEnvAssignment, parseProjectConnection, parseProjectShortId, resolveProjectConnection, validateProjectTokenReadback, } from './project-connection.js';
+import { assertSchemaPlanAllowed, fetchSchemaChangePlan, fetchSchemaPushToken, pushSchema, schemaPlanFence, schemaToPushBody, } from './push-client.js';
+import { resolveCliRuntimeConfig } from './runtime-config.js';
+import { ensurePreparedStarterMaterialized, loadStarterCatalog, preparedStarterRoot, prepareStarter, readStarterManifest, selectStarter, } from './starter-resolver.js';
+export async function runInit(projectNameArg, options = {}) {
+    configureOutput({ json: options.json === true });
+    try {
+        if (projectNameArg && options.link) {
+            throw new StorystickError('Choose either a project name or --link, not both.', { code: 'INIT_INTENT_AMBIGUOUS', category: 'validation' });
+        }
+        let intent;
+        if (options.link) {
+            intent = {
+                kind: 'link',
+                requestedShortId: parseProjectShortId(options.link),
+            };
+        }
+        else if (projectNameArg) {
+            intent = createIntent(projectNameArg, options.team);
+        }
+        else {
+            if (options.json) {
+                throw new StorystickError('Pass a project name or --link when using --json.', { code: 'INIT_INTENT_REQUIRED', category: 'validation' });
+            }
+            intent = await promptForIntent(options.team);
+        }
+        if (options.newTeam !== undefined) {
+            if (!options.newTeam.trim())
+                throw new StorystickError('The new team name cannot be empty.', { code: 'INVALID_TEAM_NAME', category: 'validation' });
+            if (options.team || intent.kind !== 'create')
+                throw new StorystickError('--new-team requires project creation and cannot be combined with --team.', { code: 'INIT_TEAM_CONFLICT', category: 'validation' });
+            intent = { ...intent, requestedNewTeamName: options.newTeam.trim() };
+        }
+        const defaultDir = intent.kind === 'create'
+            ? toSlug(intent.projectName)
+            : intent.requestedShortId;
+        if (!defaultDir) {
+            throw new StorystickError('Project name must contain a letter or number.', {
+                code: 'INVALID_PROJECT_NAME',
+                category: 'validation',
+            });
+        }
+        const targetDir = resolve(options.into ?? defaultDir);
+        const existingReceipt = readInitOperation(targetDir);
+        const locale = await resolveSiteLocale(options.locale, existingReceipt);
+        const siteUrl = await resolveSiteUrl(options.siteUrl, existingReceipt);
+        const catalogInterrupt = withInterrupt();
+        let starter;
+        try {
+            starter = await resolveInitStarter({
+                requested: options.starter,
+                existingReceipt,
+                signal: catalogInterrupt.signal,
+            });
+        }
+        finally {
+            catalogInterrupt.dispose();
+        }
+        const targetExists = existsSync(targetDir);
+        const strategy = existingReceipt?.strategy ??
+            (targetExists && isNextProject(targetDir) ? 'existing-next' : 'starter');
+        if (targetExists && !existingReceipt && strategy === 'starter') {
+            throw new StorystickError(`Target already exists and is not a Next application: ${targetDir}`, { code: 'INIT_TARGET_EXISTS', category: 'conflict' });
+        }
+        if (strategy === 'existing-next' && starter.framework !== 'next') {
+            throw new StorystickError('An Astro starter cannot be overlaid on a Next application. Choose a new directory.', { code: 'INIT_FRAMEWORK_MISMATCH', category: 'validation' });
+        }
+        if (strategy === 'existing-next' && !isNextProject(targetDir)) {
+            throw new StorystickError(`Target is not a Next application: ${targetDir}`, {
+                code: 'INIT_TARGET_NOT_NEXT',
+                category: 'validation',
+            });
+        }
+        if (strategy === 'starter' && options.force) {
+            throw new StorystickError('--force applies only to known Storystick files in an existing Next application.', { code: 'INIT_FORCE_NOT_APPLICABLE', category: 'validation' });
+        }
+        if (!existingReceipt && findProjectConnectionEnvFile(targetDir)) {
+            throw new StorystickError('This application already has a ProjectConnection. Use `storystick connect` to replace it.', { code: 'INIT_CONNECTION_EXISTS', category: 'conflict' });
+        }
+        const origin = normalizeOrigin(options.origin ?? 'http://localhost:3000');
+        const identity = {
+            targetDir,
+            intent,
+            strategy,
+            starter: {
+                catalogVersion: 2,
+                id: starter.id,
+                release: starter.release,
+                framework: starter.framework,
+                source: starter.source,
+                integrity: starter.integrity,
+                ...(starter.localDirectory
+                    ? { localDirectory: starter.localDirectory }
+                    : {}),
+            },
+            origins: [origin],
+            originMode: intent.kind === 'create' || options.origin
+                ? 'append'
+                : 'default-if-empty',
+            locale,
+            ...(siteUrl ? { siteUrl } : {}),
+            force: options.force === true,
+        };
+        const { signal, dispose } = withInterrupt();
+        let receipt;
+        try {
+            receipt = await runInitOrchestrator({
+                identity,
+                operationId: options.operationId,
+                dependencies: createInitDependencies(signal),
+            });
+        }
+        finally {
+            dispose();
+        }
+        printInitOutro({
+            dirName: relativeTarget(targetDir),
+            shortId: receipt.projectShortId,
+            projectName: receipt.projectName ??
+                (receipt.intent.kind === 'create'
+                    ? receipt.intent.projectName
+                    : receipt.intent.requestedShortId),
+            team: receipt.selectedTeam,
+            linked: receipt.intent.kind === 'link',
+            receipt,
+        });
+    }
+    catch (error) {
+        maybeExitOnCancel(error);
+        if (getOutputMode() === 'json') {
+            exitJsonFailure({ command: 'init', err: error });
+        }
+        exitWithError(error);
+    }
+}
+function createInitDependencies(signal) {
+    return {
+        async planLocal(receipt) {
+            assertInitSiteEnvironmentCompatible(receipt);
+            await prepareStarter({
+                entry: receipt.starter,
+                targetDir: receipt.targetDir,
+            });
+            if (receipt.strategy === 'existing-next') {
+                const starterRoot = preparedStarterRoot(receipt.targetDir);
+                const manifest = readStarterManifest(starterRoot);
+                assertInitScaffoldReady(planInitScaffold({
+                    rootDir: receipt.targetDir,
+                    starterRoot,
+                    manifest,
+                    force: receipt.force,
+                }));
+            }
+        },
+        async materializeAndInstall(receipt) {
+            const starterRoot = preparedStarterRoot(receipt.targetDir);
+            const manifest = readStarterManifest(starterRoot);
+            if (receipt.strategy === 'existing-next') {
+                writeInitScaffold(planInitScaffold({
+                    rootDir: receipt.targetDir,
+                    starterRoot,
+                    manifest,
+                    force: receipt.force,
+                }));
+            }
+            else {
+                ensurePreparedStarterMaterialized(receipt.targetDir, receipt.starter);
+                // Astro starters already contain their complete native integration.
+                // Keep the Next kernel scoped to its own framework.
+                if (manifest.framework === 'next') {
+                    writeInitScaffold(planInitScaffold({
+                        rootDir: receipt.targetDir,
+                        starterRoot,
+                        manifest,
+                        force: true,
+                    }));
+                }
+                const packageName = receipt.intent.kind === 'create'
+                    ? toSlug(receipt.intent.projectName)
+                    : receipt.intent.requestedShortId;
+                substituteInFile(join(receipt.targetDir, 'package.json'), {
+                    '{{PROJECT_NAME}}': packageName,
+                });
+            }
+            writeInitSiteEnvironment(receipt);
+            ensureInitReceiptIgnored(receipt.targetDir);
+            await installDependencies(receipt.targetDir, signal);
+        },
+        async prepareGeneration(receipt) {
+            const { findCorePath, preparePipeline } = await import('./cli.js');
+            const pipeline = await preparePipeline({
+                rootDir: receipt.targetDir,
+                storyDirs: ['stories'],
+                corePath: findCorePath(receipt.targetDir),
+            });
+            if (!pipeline.success) {
+                const errors = pipeline.diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+                throw new StorystickError(`Story preparation failed with ${errors} error(s).`, { code: 'INIT_STORY_PREPARATION_FAILED', category: 'validation' });
+            }
+            return {
+                pipeline,
+                schema: serializeSchema(pipeline.stories, pipeline.diagnostics),
+            };
+        },
+        async authorizeAndSelect(receipt) {
+            if (receipt.intent.kind === 'create') {
+                const teams = await fetchEligibleProjectTeams(signal, receipt.targetDir);
+                await logAuthenticatedUser(receipt.targetDir);
+                const selectedTeam = await selectEligibleProjectTeam(teams, {
+                    requestedShortId: receipt.intent.requestedTeamShortId,
+                    newTeamName: receipt.intent.requestedNewTeamName,
+                    interactive: process.stdin.isTTY === true && getOutputMode() !== 'json',
+                });
+                return {
+                    projectName: receipt.intent.projectName,
+                    ...('newTeamName' in selectedTeam ? { newTeamName: selectedTeam.newTeamName } : {
+                        selectedTeam: { shortId: selectedTeam.shortId, name: selectedTeam.name },
+                    }),
+                    endpoint: resolveCliRuntimeConfig({ rootDir: receipt.targetDir })
+                        .gatewayUrl,
+                };
+            }
+            const project = await callHubApi(`/api/cli/projects/for-user-by-shortId?shortId=${encodeURIComponent(receipt.intent.requestedShortId)}`, {
+                rootDir: receipt.targetDir,
+                onAuthPrompt: promptDeviceAuth,
+                signal,
+            });
+            await logAuthenticatedUser(receipt.targetDir);
+            return {
+                projectName: project.name,
+                endpoint: project.endpoint,
+            };
+        },
+        async recoverCommittedConnection(receipt) {
+            const connection = resolveProjectConnection(receipt.targetDir, {});
+            if (!connection || connection.shortId !== receipt.projectShortId) {
+                return false;
+            }
+            const token = await fetchSchemaPushToken(gatewayFor(receipt), connection.apiKey, { signal });
+            validateProjectTokenReadback(token, connection);
+            return true;
+        },
+        async prepareBootstrap(receipt) {
+            const intent = remoteIntent(receipt);
+            const prepared = await prepareCliBootstrap(receipt.operationId, intent, {
+                rootDir: receipt.targetDir,
+                onAuthPrompt: promptDeviceAuth,
+                signal,
+            });
+            if (!prepared.credentials) {
+                throw new StorystickError('Bootstrap returned no credentials before local connection commit.', { code: 'BOOTSTRAP_CREDENTIALS_MISSING', category: 'system' });
+            }
+            return {
+                receiptPatch: {
+                    selectedTeam: prepared.receipt.team ?? receipt.selectedTeam,
+                    projectShortId: prepared.receipt.projectShortId,
+                    keyPairVersion: prepared.receipt.keyPairVersion,
+                },
+                credentials: prepared.credentials,
+            };
+        },
+        async commitConnection(receipt, prepared) {
+            const shortId = prepared.receiptPatch.projectShortId;
+            const connection = parseProjectConnection({
+                projectId: shortId,
+                publicProjectId: shortId,
+                apiKey: prepared.credentials.apiKey,
+                publishableKey: prepared.credentials.publishableKey,
+            });
+            const token = await fetchSchemaPushToken(gatewayFor(receipt), connection.apiKey, { signal });
+            validateProjectTokenReadback(token, connection);
+            commitProjectConnection(join(receipt.targetDir, '.env.local'), connection);
+        },
+        async pushSchema(receipt, prepared) {
+            const connection = requireLocalConnection(receipt);
+            const token = await fetchSchemaPushToken(gatewayFor(receipt), connection.apiKey, { signal });
+            validateProjectTokenReadback(token, connection);
+            const body = schemaToPushBody(prepared.schema);
+            const plan = await fetchSchemaChangePlan(gatewayFor(receipt), token, body, { signal });
+            assertSchemaPlanAllowed(plan);
+            const pushed = await pushSchema(gatewayFor(receipt), token, body, schemaPlanFence(plan), { signal });
+            return { schemaVersion: pushed.version, projectionSeq: pushed.projectionSeq };
+        },
+        async commitGeneration(receipt, prepared) {
+            await commitGeneratedFiles(join(receipt.targetDir, 'generated', 'storystick'), prepared.pipeline.generated);
+        },
+        async acknowledge(receipt) {
+            if (!receipt.keyPairVersion) {
+                throw new StorystickError('Bootstrap key-pair version is missing.', {
+                    code: 'BOOTSTRAP_VERSION_MISSING',
+                    category: 'system',
+                });
+            }
+            const result = await acknowledgeCliBootstrap(receipt.operationId, remoteIntent(receipt), receipt.keyPairVersion, {
+                rootDir: receipt.targetDir,
+                onAuthPrompt: promptDeviceAuth,
+                signal,
+            });
+            if (result.receipt.state !== 'connection_acknowledged') {
+                throw new StorystickError('Bootstrap acknowledgement is incomplete.', {
+                    code: 'BOOTSTRAP_ACK_INCOMPLETE',
+                    category: 'system',
+                });
+            }
+            const connection = requireLocalConnection(receipt);
+            const token = await fetchSchemaPushToken(gatewayFor(receipt), connection.apiKey, { signal });
+            const { waitForProjection } = await import('./init-readiness.js');
+            await waitForProjection({ endpoint: gatewayFor(receipt), token,
+                version: receipt.schemaVersion, seq: receipt.projectionSeq, signal });
+        },
+        async initializeGit(receipt) {
+            if (receipt.strategy === 'existing-next')
+                return;
+            if (existsSync(join(receipt.targetDir, '.git')))
+                return;
+            const { execa } = await import('execa');
+            await execa('git', ['init'], {
+                cwd: receipt.targetDir,
+                stdio: 'pipe',
+                cancelSignal: signal,
+            });
+            await execa('git', ['add', '-A'], {
+                cwd: receipt.targetDir,
+                stdio: 'pipe',
+                cancelSignal: signal,
+            });
+            await execa('git', ['commit', '-m', 'Initial Storystick project'], {
+                cwd: receipt.targetDir,
+                stdio: 'pipe',
+                cancelSignal: signal,
+            });
+        },
+    };
+}
+function remoteIntent(receipt) {
+    if (receipt.intent.kind === 'create') {
+        if (!receipt.selectedTeam && !receipt.newTeamName) {
+            throw new StorystickError('No eligible Team was selected.', {
+                code: 'TEAM_REQUIRED',
+                category: 'validation',
+            });
+        }
+        return {
+            kind: 'create',
+            projectName: receipt.intent.projectName,
+            ...(receipt.newTeamName ? { newTeamName: receipt.newTeamName } : { teamShortId: receipt.selectedTeam.shortId }),
+            initialLocale: receipt.locale,
+            initialLocaleLabel: localeDisplayName(receipt.locale),
+            initialAllowedOrigins: receipt.origins,
+            originMode: 'append',
+        };
+    }
+    return {
+        kind: 'link',
+        requestedShortId: receipt.intent.requestedShortId,
+        initialAllowedOrigins: receipt.origins,
+        originMode: receipt.originMode,
+    };
+}
+function requireLocalConnection(receipt) {
+    const connection = resolveProjectConnection(receipt.targetDir, {});
+    if (!connection || connection.shortId !== receipt.projectShortId) {
+        throw new StorystickError('Local ProjectConnection does not match bootstrap.', {
+            code: 'BOOTSTRAP_LOCAL_CONNECTION_MISSING',
+            category: 'validation',
+        });
+    }
+    return connection;
+}
+function gatewayFor(receipt) {
+    return resolveCliRuntimeConfig({
+        rootDir: receipt.targetDir,
+        gatewayUrl: receipt.endpoint,
+    }).gatewayUrl;
+}
+export function sanitizedInstallEnvironment(env = process.env) {
+    const clean = { ...env };
+    for (const key of PROJECT_CONNECTION_ENV_KEYS)
+        delete clean[key];
+    return clean;
+}
+export async function installDependencies(targetDir, signal) {
+    const manager = detectPackageManager(targetDir);
+    const { execa } = await import('execa');
+    await execa(manager, ['install'], {
+        cwd: targetDir,
+        stdio: 'pipe',
+        env: sanitizedInstallEnvironment(),
+        cancelSignal: signal,
+    });
+}
+function detectPackageManager(targetDir) {
+    if (existsSync(join(targetDir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(targetDir, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(targetDir, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+function ensureInitReceiptIgnored(targetDir) {
+    const path = join(targetDir, '.gitignore');
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    if (/^\.storystick\/$/mu.test(current))
+        return;
+    const prefix = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
+    writeFileSync(path, `${current}${prefix}.storystick/\n`, 'utf8');
+}
+function substituteInFile(path, values) {
+    if (!existsSync(path))
+        return;
+    let content = readFileSync(path, 'utf8');
+    for (const [from, to] of Object.entries(values)) {
+        content = content.replaceAll(from, to);
+    }
+    writeFileSync(path, content, 'utf8');
+}
+async function resolveInitStarter({ requested, existingReceipt, signal, }) {
+    if (existingReceipt) {
+        if (requested && requested.trim() !== existingReceipt.starter.id) {
+            throw new StorystickError(`Initialization is already pinned to starter "${existingReceipt.starter.id}".`, { code: 'INIT_INTENT_MISMATCH', category: 'conflict' });
+        }
+        return existingReceipt.starter;
+    }
+    const catalog = await loadStarterCatalog({ signal });
+    if (requested?.trim())
+        return selectStarter(catalog, requested);
+    if (catalog.starters.length > 1 &&
+        process.stdin.isTTY === true &&
+        getOutputMode() !== 'json') {
+        return selectStarter(catalog, await promptStarter(catalog));
+    }
+    return selectStarter(catalog);
+}
+async function promptStarter(catalog) {
+    try {
+        return await promptSelect('Starter', catalog.starters.map((starter) => ({
+            value: starter.id,
+            name: starter.label,
+            description: starter.description,
+        })));
+    }
+    catch (error) {
+        maybeExitOnCancel(error);
+        throw error;
+    }
+}
+async function resolveSiteLocale(requested, existingReceipt) {
+    const existing = existingReceipt?.locale;
+    if (requested?.trim())
+        return normalizeLocale(requested);
+    if (existing)
+        return existing;
+    if (process.stdin.isTTY !== true || getOutputMode() === 'json') {
+        throw new StorystickError('Pass --locale with the primary BCP 47 language tag outside an interactive terminal.', { code: 'INIT_LOCALE_REQUIRED', category: 'validation' });
+    }
+    const detected = normalizeLocale(Intl.DateTimeFormat().resolvedOptions().locale || 'en');
+    try {
+        const locale = await promptText('Primary site locale', {
+            placeholder: detected,
+            validate: (value) => {
+                try {
+                    normalizeLocale(value);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+            },
+        });
+        return normalizeLocale(locale);
+    }
+    catch (error) {
+        maybeExitOnCancel(error);
+        throw error;
+    }
+}
+async function resolveSiteUrl(requested, existingReceipt) {
+    if (requested?.trim())
+        return normalizeSiteUrl(requested);
+    if (existingReceipt?.siteUrl)
+        return existingReceipt.siteUrl;
+    if (process.stdin.isTTY !== true || getOutputMode() === 'json')
+        return undefined;
+    try {
+        const value = await promptText('Production site URL (optional)', {
+            validate: (candidate) => {
+                if (!candidate.trim())
+                    return undefined;
+                try {
+                    normalizeSiteUrl(candidate);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+            },
+        });
+        return value.trim() ? normalizeSiteUrl(value) : undefined;
+    }
+    catch (error) {
+        maybeExitOnCancel(error);
+        throw error;
+    }
+}
+function normalizeLocale(raw) {
+    try {
+        return canonicalLocaleCode(raw);
+    }
+    catch {
+        throw new StorystickError('--locale must be a BCP 47 language tag such as fr, en-GB or zh-Hant-TW.', { code: 'INVALID_LOCALE', category: 'validation' });
+    }
+}
+function localeDisplayName(locale) {
+    try {
+        const label = new Intl.DisplayNames(['en'], { type: 'language' }).of(locale);
+        return label && label.length <= 80 ? label : locale;
+    }
+    catch {
+        return locale;
+    }
+}
+function normalizeSiteUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new StorystickError('--site-url must be an HTTP(S) site origin.', {
+            code: 'INVALID_SITE_URL',
+            category: 'validation',
+        });
+    }
+    if (!['http:', 'https:'].includes(url.protocol) ||
+        url.pathname !== '/' ||
+        url.search ||
+        url.hash ||
+        url.username ||
+        url.password) {
+        throw new StorystickError('--site-url must be an HTTP(S) origin without a path.', { code: 'INVALID_SITE_URL', category: 'validation' });
+    }
+    return url.origin;
+}
+function writeInitSiteEnvironment(receipt) {
+    assertInitSiteEnvironmentCompatible(receipt);
+    const path = join(receipt.targetDir, '.env.local');
+    const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const values = desiredSiteEnvironment(receipt);
+    const newline = current.includes('\r\n') ? '\r\n' : '\n';
+    const body = current.replace(/(?:\r?\n)+$/u, '');
+    const lines = body ? body.split(/\r?\n/u) : [];
+    const missing = [];
+    for (const [key, value] of Object.entries(values)) {
+        const index = lines.findIndex((line) => parseEnvAssignment(line)?.key === key);
+        if (index >= 0) {
+            lines[index] = `${key}=${value}`;
+        }
+        else {
+            missing.push(`${key}=${value}`);
+        }
+    }
+    if (missing.length > 0) {
+        if (lines.length > 0 && lines.at(-1) !== '')
+            lines.push('');
+        lines.push(...missing);
+    }
+    const content = `${lines.join(newline)}${newline}`;
+    writeFileSync(path, content, { encoding: 'utf8', mode: 0o600 });
+}
+function assertInitSiteEnvironmentCompatible(receipt) {
+    const path = join(receipt.targetDir, '.env.local');
+    if (!existsSync(path))
+        return;
+    const assignments = readFileSync(path, 'utf8')
+        .split(/\r?\n/u)
+        .map(parseEnvAssignment)
+        .filter((value) => value !== null);
+    for (const [key, value] of Object.entries(desiredSiteEnvironment(receipt))) {
+        const matches = assignments.filter((entry) => entry.key === key);
+        if (matches.length > 1) {
+            throw new StorystickError(`${key} is declared more than once in .env.local.`, { code: 'INIT_SITE_CONFIG_CONFLICT', category: 'conflict' });
+        }
+        const existing = matches[0]?.value;
+        if (existing && existing !== value) {
+            throw new StorystickError(`${key} already has a different value in .env.local.`, { code: 'INIT_SITE_CONFIG_CONFLICT', category: 'conflict' });
+        }
+    }
+}
+function desiredSiteEnvironment(receipt) {
+    return {
+        ...(receipt.siteUrl ? { STORYSTICK_SITE_URL: receipt.siteUrl } : {}),
+    };
+}
+async function promptForIntent(team) {
+    try {
+        const choice = await promptSelect('What do you want to do?', [
+            { value: 'create', name: 'Create a new Storystick project' },
+            { value: 'link', name: 'Link to an existing project' },
+        ]);
+        if (choice === 'link') {
+            const shortId = await promptText('Project shortId', {
+                validate: (value) => {
+                    try {
+                        parseProjectShortId(value);
+                        return undefined;
+                    }
+                    catch (error) {
+                        return error instanceof Error ? error.message : String(error);
+                    }
+                },
+            });
+            return { kind: 'link', requestedShortId: parseProjectShortId(shortId) };
+        }
+        const projectName = await promptText('Project name', {
+            placeholder: 'my-project',
+            validate: (value) => value.trim().length > 0 ? undefined : 'Project name is required',
+        });
+        return createIntent(projectName, team);
+    }
+    catch (error) {
+        maybeExitOnCancel(error);
+        throw error;
+    }
+}
+function createIntent(projectName, team) {
+    const normalized = projectName.trim();
+    if (!normalized) {
+        throw new StorystickError('Project name is required.', {
+            code: 'INVALID_PROJECT_NAME',
+            category: 'validation',
+        });
+    }
+    return {
+        kind: 'create',
+        projectName: normalized,
+        ...(team?.trim() ? { requestedTeamShortId: team.trim() } : {}),
+    };
+}
+function normalizeOrigin(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new StorystickError('--origin must be an HTTP(S) origin.', {
+            code: 'INVALID_ORIGIN',
+            category: 'validation',
+        });
+    }
+    if ((url.protocol !== 'http:' && url.protocol !== 'https:') ||
+        url.pathname !== '/' ||
+        url.search ||
+        url.hash ||
+        url.username ||
+        url.password) {
+        throw new StorystickError('--origin must be an HTTP(S) origin without a path.', {
+            code: 'INVALID_ORIGIN',
+            category: 'validation',
+        });
+    }
+    return url.origin;
+}
+function toSlug(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export function relativeTarget(targetDir, cwd = process.cwd()) {
+    const target = resolve(targetDir);
+    const current = resolve(cwd);
+    if (target === current)
+        return '.';
+    const candidate = relative(current, target);
+    return candidate === '..' || candidate.startsWith(`..${sep}`)
+        ? target
+        : candidate;
+}
+async function logAuthenticatedUser(rootDir) {
+    const currentUser = await whoami({ rootDir });
+    if (currentUser?.email) {
+        logMessage(`Authenticated as ${pc.bold(currentUser.email)}`);
+    }
+}
+function eligibleTeamChoices(teams) {
+    return teams
+        .map((team) => `  ${team.name} (${team.shortId}) — ${team.role}${team.isPersonal ? ', personal' : ''}`)
+        .join('\n');
+}
+export async function selectEligibleProjectTeam(teams, options) {
+    const requestedShortId = options.requestedShortId?.trim();
+    if (requestedShortId) {
+        const requested = teams.find((team) => team.shortId === requestedShortId);
+        if (requested)
+            return requested;
+        const suffix = teams.length > 0 ? `\nEligible Teams:\n${eligibleTeamChoices(teams)}` : '';
+        throw new StorystickError(`Team "${requestedShortId}" is not eligible for project creation.${suffix}`, { code: 'TEAM_NOT_ELIGIBLE', category: 'validation' });
+    }
+    if (options.newTeamName)
+        return { newTeamName: options.newTeamName };
+    if (!options.interactive) {
+        throw new StorystickError('Choose --team <teamShortId> or --new-team <name> before creating a project.', { code: 'TEAM_REQUIRED', category: 'validation' });
+    }
+    const selectedShortId = await (options.prompt ?? promptSelect)('Select the Team that will own this project:', [...teams.map((team) => ({
+            value: team.shortId,
+            name: `${team.name} (${team.shortId})`,
+            description: `${team.role}${team.isPersonal ? ', personal' : ''}`,
+        })), { value: '__create_team__', name: 'Create a new team', description: 'You will own the new team' }]);
+    if (selectedShortId === '__create_team__') {
+        const name = (await promptText('Team name')).trim();
+        if (!name || name.length > 120)
+            throw new StorystickError('Team name must contain between 1 and 120 characters.', { code: 'TEAM_NAME_INVALID', category: 'validation' });
+        return { newTeamName: name };
+    }
+    const selected = teams.find((team) => team.shortId === selectedShortId);
+    if (!selected) {
+        throw new StorystickError('The selected Team is no longer eligible.', {
+            code: 'TEAM_NOT_ELIGIBLE',
+            category: 'validation',
+        });
+    }
+    return selected;
+}
+export async function fetchEligibleProjectTeams(signal, rootDir) {
+    return await callHubApi('/api/cli/teams/eligible-for-project-creation', {
+        rootDir,
+        onAuthPrompt: promptDeviceAuth,
+        signal,
+    });
+}
+export function printInitOutro(args) {
+    if (getOutputMode() === 'json') {
+        emitJsonResult({
+            command: 'init',
+            ok: true,
+            data: {
+                outcome: 'complete',
+                projectName: args.projectName,
+                shortId: args.shortId,
+                dirName: args.dirName,
+                team: args.team,
+                receipt: args.receipt,
+            },
+        });
+        return;
+    }
+    logFinishedStep(args.linked
+        ? `Linked to ${pc.bold(args.projectName)} (${args.shortId})`
+        : `Project ${pc.bold(args.projectName)} (${args.shortId}) created`);
+    if (args.team) {
+        logMessage(`Team: ${pc.bold(args.team.name)} (${args.team.shortId})`);
+    }
+    logMessage('');
+    logMessage('Next steps:');
+    if (args.dirName !== '.') {
+        logMessage(`  ${pc.bold(`cd ${shellArgument(args.dirName)}`)}`);
+    }
+    const devOrigin = args.receipt?.origins[0] ? new URL(args.receipt.origins[0]) : null;
+    const local = devOrigin && ['localhost', '127.0.0.1', '[::1]'].includes(devOrigin.hostname) && devOrigin.protocol === 'http:';
+    logMessage(`  ${pc.bold(local ? `npm run dev -- --port ${devOrigin.port || '80'}` : 'npm run dev')}`);
+    if (!args.linked) {
+        logMessage('Your project has content types but no pages yet. Create a page in the Studio, then open Preview.');
+        logMessage(`  ${resolveCliRuntimeConfig().hubUrl}/p/${args.shortId}`);
+    }
+    logMessage('');
+    logMessage(`${pc.yellow('!')}  Your ${pc.bold('.env.local')} contains a secret API key (STORYSTICK_API_KEY).`);
+    logMessage('   It is in .gitignore — keep it that way. Never commit it.');
+    logMessage('');
+    const hubUrl = resolveCliRuntimeConfig().hubUrl;
+    logMessage(`${pc.yellow('!')}  Manage keys in the Hub:`);
+    logMessage(`   ${hubUrl}/p/${args.shortId}/settings/api-keys`);
+    logMessage('');
+}
+function shellArgument(value) {
+    return /^[A-Za-z0-9_@%+=:,./-]+$/u.test(value) ? value : shellQuote(value);
+}