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

package/dist/commands/archive.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `storystick archive <shortId>` (SPEC-1 Item #4).
+ *
+ * Soft-deletes the given project via `/api/cli/projects/archive`. The Hub
+ * patches `deletedAt: now()`; the existing daily GC cron hard-deletes 30d
+ * later. `deletedAt` + 30d is echoed back so the CLI can show the user the
+ * hard-delete date without baking the grace constant into CLI code.
+ *
+ * Always prompts for confirmation (no `--yes` flag for first ship — CI
+ * scripts can come later).
+ */
+export interface ArchiveOptions {
+    json?: boolean;
+    /** Skip the interactive confirmation prompt (ADR-072 §F6 / T6). */
+    yes?: boolean;
+}
+export declare function runArchive(shortId: string, options?: ArchiveOptions): Promise<void>;

package/dist/commands/archive.js

@@ -0,0 +1,86 @@
+/**
+ * `storystick archive <shortId>` (SPEC-1 Item #4).
+ *
+ * Soft-deletes the given project via `/api/cli/projects/archive`. The Hub
+ * patches `deletedAt: now()`; the existing daily GC cron hard-deletes 30d
+ * later. `deletedAt` + 30d is echoed back so the CLI can show the user the
+ * hard-delete date without baking the grace constant into CLI code.
+ *
+ * Always prompts for confirmation (no `--yes` flag for first ship — CI
+ * scripts can come later).
+ */
+import pc from 'picocolors';
+import { callHubApi } from '../hub-client.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logFinishedStep, logMessage, maybeExitOnCancel, promptConfirm, promptDeviceAuth, withInterrupt, } from '../output.js';
+export async function runArchive(shortId, options = {}) {
+    configureOutput({ json: options.json === true });
+    if (!shortId || shortId.trim().length === 0) {
+        exitWithError('Missing shortId. Usage: storystick archive <shortId>');
+    }
+    // ADR-072 §F6 / T6: in non-interactive contexts (no TTY OR --json) the
+    // prompt cannot reach a human — require --yes so the user opts into
+    // the destructive action explicitly. Single rule covers CI scripts,
+    // AI agents, piped stdin, and npm-script headless environments.
+    const interactive = process.stdin.isTTY && getOutputMode() !== 'json';
+    if (!interactive && options.yes !== true) {
+        if (getOutputMode() === 'json') {
+            exitJsonFailure({
+                command: 'archive',
+                err: new Error('Cannot prompt for confirmation in non-interactive mode.'),
+                hint: 'Pass --yes to skip confirmation in non-interactive mode.',
+            });
+        }
+        exitWithError('Cannot prompt for confirmation in non-interactive mode.', 'Pass --yes to skip confirmation in non-interactive mode.');
+    }
+    // Confirm before talking to the Hub — a cancelled archive should cost
+    // zero network round-trips. --yes skips the prompt in interactive mode
+    // too (the user opted in via flag).
+    if (!options.yes) {
+        let ok;
+        try {
+            ok = await promptConfirm(`Archive '${shortId}'? Data is recoverable for 30 days.`, { default: false });
+        }
+        catch (err) {
+            // ADR-072 §A5 / D16: Ctrl-C / Esc out of prompt routes through
+            // maybeExitOnCancel — exit 130 (was exit 0 pre-ADR-072).
+            maybeExitOnCancel(err);
+            throw err;
+        }
+        if (!ok) {
+            // ADR-072 §A4: "n" at promptConfirm is an intentional decline → exit 0.
+            logMessage(pc.dim('Cancelled.'));
+            return;
+        }
+    }
+    const { signal, dispose } = withInterrupt();
+    try {
+        const result = await callHubApi('/api/cli/projects/archive', {
+            method: 'POST',
+            body: { shortId },
+            onAuthPrompt: promptDeviceAuth,
+            signal,
+        });
+        if (getOutputMode() === 'json') {
+            emitJsonResult({
+                command: 'archive',
+                ok: true,
+                data: {
+                    shortId: result.shortId,
+                    deletedAt: result.deletedAt,
+                    hardDeleteAt: result.hardDeleteAt,
+                },
+            });
+            return;
+        }
+        const hardDate = new Date(result.hardDeleteAt).toISOString().slice(0, 10);
+        logFinishedStep(`Archived ${pc.bold(shortId)} (hard-deleted on ${hardDate})`);
+        logMessage(pc.dim('  Your .env.local was not touched — run `storystick connect <other>` ' +
+            'to point it at a different project.'));
+    }
+    catch (err) {
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}

package/dist/commands/backfill-refs.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `storystick backfill-refs` — Layer 2 of the simplified backfill design
+ * (ADR-062 §Q7 + §D21).
+ *
+ * Re-extracts live references for the active project — the CLI-only path
+ * a user runs after a schema change that affects ref-relevant field types
+ * (the diff-gate on `storystick push` surfaces the recommendation).
+ *
+ * Granularity flags:
+ *   --storyType <name>       Limit to one story type.
+ *   --document <shortId>     Limit to one document.
+ *   --dry-run                Count what would change without writing.
+ *
+ * The endpoint is chunked: a single mutation call processes one page and
+ * returns a continuation cursor. This command loops until the server
+ * reports `hasMore === false`, surfacing per-call progress via the
+ * spinner so a backfill of a large project shows liveness.
+ *
+ * Token + endpoint resolution mirrors `storystick push`: the complete local
+ * ProjectConnection is validated, its secret key is exchanged for a
+ * short-lived project JWT, then the token is read back before the request to
+ * `<gateway>/api/m/operations/backfill-refs`. See ADR-058 §Pattern D.
+ */
+import { type BackfillRefsBody, type BackfillRefsResult } from '../operations-client.js';
+import type { ProjectRequestOptions } from '../push-client.js';
+export interface BackfillRefsOptions {
+    /** Limit scan to one story type. Mutually exclusive with `documentId`. */
+    storyType?: string;
+    /** Limit scan to one document. Mutually exclusive with `storyType`. */
+    documentId?: string;
+    /** Don't write — count what would change. */
+    dryRun?: boolean;
+    /** Emit JSONL events (one per chunk + a final event) on stdout. */
+    json?: boolean;
+    /** Render info-level diagnostics. */
+    verbose?: boolean;
+    /** Suppress success and warning output (failures still emit). */
+    quiet?: boolean;
+    /** Project root directory. Defaults to cwd. */
+    root?: string;
+    /**
+     * Override gateway URL — tests inject a mock server here. Production
+     * resolves the URL from `.env.local` / falls back to the well-known
+     * Storystick Central endpoint.
+     */
+    gatewayUrl?: string;
+    /**
+     * Override token + the entire HTTP transport. Tests bypass the real
+     * `fetchSchemaPushToken` + `backfillRefs` calls by providing both.
+     */
+    fetchTokenImpl?: (gatewayUrl: string, apiKey: string, options?: ProjectRequestOptions) => Promise<string>;
+    fetchBackfillImpl?: (gatewayUrl: string, token: string, body: BackfillRefsBody, options?: ProjectRequestOptions) => Promise<BackfillRefsResult>;
+}
+export declare function runBackfillRefs(options?: BackfillRefsOptions): Promise<void>;

package/dist/commands/backfill-refs.js

@@ -0,0 +1,217 @@
+/**
+ * `storystick backfill-refs` — Layer 2 of the simplified backfill design
+ * (ADR-062 §Q7 + §D21).
+ *
+ * Re-extracts live references for the active project — the CLI-only path
+ * a user runs after a schema change that affects ref-relevant field types
+ * (the diff-gate on `storystick push` surfaces the recommendation).
+ *
+ * Granularity flags:
+ *   --storyType <name>       Limit to one story type.
+ *   --document <shortId>     Limit to one document.
+ *   --dry-run                Count what would change without writing.
+ *
+ * The endpoint is chunked: a single mutation call processes one page and
+ * returns a continuation cursor. This command loops until the server
+ * reports `hasMore === false`, surfacing per-call progress via the
+ * spinner so a backfill of a large project shows liveness.
+ *
+ * Token + endpoint resolution mirrors `storystick push`: the complete local
+ * ProjectConnection is validated, its secret key is exchanged for a
+ * short-lived project JWT, then the token is read back before the request to
+ * `<gateway>/api/m/operations/backfill-refs`. See ADR-058 §Pattern D.
+ */
+import { resolve } from 'node:path';
+import pc from 'picocolors';
+import { backfillRefs, } from '../operations-client.js';
+import { fetchSchemaPushToken } from '../push-client.js';
+import { changeSpinner, configureOutput, emitJsonlFailure, emitJsonlEvent, exitWithError, failSpinner, getOutputMode, logFinishedStep, logMessage, showSpinner, succeedSpinner, withInterrupt, } from '../output.js';
+import { resolveCliRuntimeConfig } from '../runtime-config.js';
+import { requireProjectConnection, validateProjectTokenReadback, } from '../project-connection.js';
+// ─────────────────────────────────────────────────────────────
+// Entry point
+// ─────────────────────────────────────────────────────────────
+export async function runBackfillRefs(options = {}) {
+    configureOutput({
+        json: options.json === true,
+        verbose: options.verbose === true,
+        quiet: options.quiet === true,
+    });
+    if (options.storyType !== undefined && options.documentId !== undefined) {
+        exitWithError('`--storyType` and `--document` are mutually exclusive. Pass one or the other.');
+    }
+    const rootDir = resolve(options.root ?? '.');
+    const scope = describeScope(options);
+    const dryRunSuffix = options.dryRun ? pc.dim(' (dry-run)') : '';
+    logMessage(`${pc.bold('Storystick')} — backfilling refs${dryRunSuffix}...`);
+    logMessage(pc.dim(`Scope: ${scope}`));
+    const { signal, dispose } = withInterrupt();
+    try {
+        const connection = requireProjectConnection(rootDir);
+        const gatewayUrl = resolveCliRuntimeConfig({
+            rootDir,
+            gatewayUrl: options.gatewayUrl,
+        }).gatewayUrl;
+        const fetchTokenFn = options.fetchTokenImpl ?? fetchSchemaPushToken;
+        const fetchBackfillFn = options.fetchBackfillImpl ?? backfillRefs;
+        const token = await fetchTokenFn(gatewayUrl, connection.apiKey, { signal });
+        validateProjectTokenReadback(token, connection);
+        let cursor = undefined;
+        let totalScanned = 0;
+        let totalAdded = 0;
+        let totalRemoved = 0;
+        let totalRoutabilityPatched = 0;
+        let totalDisplayNamesPatched = 0;
+        let calls = 0;
+        let hashUpdated = false;
+        const startedAt = Date.now();
+        await showSpinner('Starting backfill...');
+        while (true) {
+            if (signal.aborted) {
+                // ADR-072 §A5 / D16: Ctrl-C mid-loop must exit 130, not return
+                // (which would silently exit 0 — the pre-ADR-072 behaviour).
+                failSpinner('Backfill cancelled.');
+                process.exit(130);
+            }
+            const body = {
+                storyType: options.storyType,
+                documentId: options.documentId,
+                dryRun: options.dryRun,
+                cursor,
+            };
+            const result = await fetchBackfillFn(gatewayUrl, token, body, { signal });
+            calls += 1;
+            totalScanned += result.docsScanned;
+            totalAdded += result.refsAdded;
+            totalRemoved += result.refsRemoved;
+            totalRoutabilityPatched += result.routabilityPatched ?? 0;
+            totalDisplayNamesPatched += result.displayNamesPatched ?? 0;
+            hashUpdated = hashUpdated || result.hashUpdated;
+            cursor = result.continueCursor;
+            changeSpinner(`Scanned ${totalScanned} doc${totalScanned === 1 ? '' : 's'}` +
+                ` · ${totalAdded} added · ${totalRemoved} removed` +
+                (totalRoutabilityPatched > 0
+                    ? ` · ${totalRoutabilityPatched} routability patched`
+                    : '') +
+                (totalDisplayNamesPatched > 0
+                    ? ` · ${totalDisplayNamesPatched} names patched`
+                    : ''));
+            // ADR-072 §A3 / D15 / L5: under --json, emit one progress event
+            // per chunk so streaming consumers can show liveness without
+            // parsing the human spinner.
+            if (getOutputMode() === 'json') {
+                emitJsonlEvent({
+                    command: 'backfill-refs',
+                    event: 'progress',
+                    data: {
+                        docsScanned: totalScanned,
+                        refsAdded: totalAdded,
+                        refsRemoved: totalRemoved,
+                        routabilityPatched: totalRoutabilityPatched,
+                        displayNamesPatched: totalDisplayNamesPatched,
+                        calls,
+                        hasMore: result.hasMore,
+                    },
+                });
+            }
+            if (!result.hasMore)
+                break;
+            // Hard safety cap so a stuck server can't loop us forever.
+            if (calls > 10_000) {
+                failSpinner('Backfill aborted: too many continuation calls.');
+                exitWithError('Backfill did not converge after 10,000 chunks. Please report this.');
+            }
+        }
+        const elapsedMs = Date.now() - startedAt;
+        const elapsed = formatElapsed(elapsedMs);
+        if (getOutputMode() === 'json') {
+            emitJsonlEvent({
+                command: 'backfill-refs',
+                event: 'final',
+                ok: true,
+                data: {
+                    docsScanned: totalScanned,
+                    refsAdded: totalAdded,
+                    refsRemoved: totalRemoved,
+                    routabilityPatched: totalRoutabilityPatched,
+                    displayNamesPatched: totalDisplayNamesPatched,
+                    calls,
+                    hashUpdated,
+                    dryRun: options.dryRun === true,
+                    elapsedMs,
+                },
+            });
+            return;
+        }
+        if (options.dryRun) {
+            const hasChanges = totalAdded > 0 ||
+                totalRemoved > 0 ||
+                totalRoutabilityPatched > 0 ||
+                totalDisplayNamesPatched > 0;
+            const verb = hasChanges ? 'Would' : 'No changes';
+            const summary = verb === 'No changes'
+                ? `${verb} (scanned ${totalScanned} doc${totalScanned === 1 ? '' : 's'} in ${elapsed})`
+                : `${verb} add ${totalAdded}, remove ${totalRemoved} ref` +
+                    (totalAdded + totalRemoved === 1 ? '' : 's') +
+                    (totalRoutabilityPatched > 0
+                        ? `, patch ${totalRoutabilityPatched} routability flag` +
+                            (totalRoutabilityPatched === 1 ? '' : 's')
+                        : '') +
+                    (totalDisplayNamesPatched > 0
+                        ? `, patch ${totalDisplayNamesPatched} document name` +
+                            (totalDisplayNamesPatched === 1 ? '' : 's')
+                        : '') +
+                    ` across ${totalScanned} doc${totalScanned === 1 ? '' : 's'} (dry-run, ${elapsed})`;
+            succeedSpinner(summary);
+            return;
+        }
+        const summary = `${totalScanned} doc${totalScanned === 1 ? '' : 's'} scanned, ` +
+            `${totalAdded} ref${totalAdded === 1 ? '' : 's'} added, ` +
+            `${totalRemoved} ref${totalRemoved === 1 ? '' : 's'} removed` +
+            (totalRoutabilityPatched > 0
+                ? `, ${totalRoutabilityPatched} routability flag` +
+                    (totalRoutabilityPatched === 1 ? '' : 's') +
+                    ' patched'
+                : '') +
+            (totalDisplayNamesPatched > 0
+                ? `, ${totalDisplayNamesPatched} document name` +
+                    (totalDisplayNamesPatched === 1 ? '' : 's') +
+                    ' patched'
+                : '') +
+            ` (${elapsed})`;
+        succeedSpinner(summary);
+        if (hashUpdated) {
+            logFinishedStep('Project marked as fully reconciled.');
+        }
+    }
+    catch (err) {
+        failSpinner('Backfill failed.');
+        if (getOutputMode() === 'json') {
+            emitJsonlFailure({ command: 'backfill-refs', err });
+        }
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}
+// ─────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────
+function describeScope(options) {
+    if (options.documentId)
+        return `document ${options.documentId}`;
+    if (options.storyType)
+        return `storyType ${options.storyType}`;
+    return 'project-wide';
+}
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const s = ms / 1000;
+    if (s < 60)
+        return `${s.toFixed(1)}s`;
+    const m = Math.floor(s / 60);
+    const rem = s - m * 60;
+    return `${m}m ${rem.toFixed(0)}s`;
+}

package/dist/commands/connect.d.ts

@@ -0,0 +1,11 @@
+export interface ConnectOptions {
+    root?: string;
+    origin?: string;
+    dryRun?: boolean;
+    json?: boolean;
+    /** @internal deterministic idempotency seam. */
+    operationId?: string;
+    /** @internal deterministic filesystem failure seam. */
+    connectionFaultAt?: 'before-rename';
+}
+export declare function runConnect(requestedShortId: string, options?: ConnectOptions): Promise<void>;

package/dist/commands/connect.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import pc from 'picocolors';
+import { StorystickError } from '../cli-error.js';
+import { acknowledgeCliBootstrap, prepareCliBootstrap, } from '../bootstrap-client.js';
+import { callHubApi } from '../hub-client.js';
+import { commitProjectConnection, findProjectConnectionEnvFile, parseProjectConnection, parseProjectShortId, planProjectConnection, requireProjectConnection, validateProjectTokenReadback, } from '../project-connection.js';
+import { fetchSchemaPushToken } from '../push-client.js';
+import { resolveCliRuntimeConfig } from '../runtime-config.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logFinishedStep, logMessage, logOutput, promptDeviceAuth, withInterrupt, } from '../output.js';
+export async function runConnect(requestedShortId, options = {}) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    try {
+        const shortId = parseProjectShortId(requestedShortId);
+        const rootDir = resolve(options.root ?? '.');
+        if (!existsSync(rootDir) || !statSync(rootDir).isDirectory()) {
+            throw new StorystickError(`Project root does not exist: ${rootDir}`, {
+                code: 'PROJECT_ROOT_NOT_FOUND',
+                category: 'validation',
+            });
+        }
+        const project = await callHubApi(`/api/cli/projects/for-user-by-shortId?shortId=${encodeURIComponent(shortId)}`, { onAuthPrompt: promptDeviceAuth, signal, rootDir });
+        if (parseProjectShortId(project.shortId) !== shortId) {
+            throw new StorystickError('Gateway resolved a different project than the requested shortId.', {
+                code: 'PROJECT_RESOLUTION_MISMATCH',
+                category: 'system',
+            });
+        }
+        const envFile = findProjectConnectionEnvFile(rootDir) ?? join(rootDir, '.env.local');
+        // A public dry-run has no remote mutation: it proves access and renders
+        // only the target path + redacted four-field plan.
+        if (options.dryRun === true) {
+            renderConnectResult(shortId, project.name, planProjectConnection(envFile, shortId), true);
+            return;
+        }
+        const operationId = options.operationId ?? randomUUID();
+        const intent = {
+            kind: 'link',
+            requestedShortId: shortId,
+            initialAllowedOrigins: [options.origin ?? 'http://localhost:3000'],
+            originMode: options.origin ? 'append' : 'default-if-empty',
+        };
+        const prepared = await prepareCliBootstrap(operationId, intent, {
+            rootDir,
+            signal,
+            onAuthPrompt: promptDeviceAuth,
+        });
+        if (prepared.receipt.projectShortId !== shortId) {
+            throw new StorystickError('Bootstrap receipt points to a different project.', { code: 'BOOTSTRAP_PROJECT_MISMATCH', category: 'system' });
+        }
+        const connection = prepared.credentials
+            ? parseProjectConnection({
+                projectId: shortId,
+                publicProjectId: shortId,
+                apiKey: prepared.credentials.apiKey,
+                publishableKey: prepared.credentials.publishableKey,
+            })
+            : requireProjectConnection(rootDir);
+        if (connection.shortId !== shortId) {
+            throw new StorystickError('Acknowledged bootstrap has no matching local ProjectConnection.', { code: 'BOOTSTRAP_LOCAL_CONNECTION_MISSING', category: 'validation' });
+        }
+        const gatewayUrl = resolveCliRuntimeConfig({
+            rootDir,
+            gatewayUrl: project.endpoint,
+        }).gatewayUrl;
+        const token = await fetchSchemaPushToken(gatewayUrl, connection.apiKey, {
+            signal,
+        });
+        validateProjectTokenReadback(token, connection);
+        const result = commitProjectConnection(envFile, connection, {
+            faultAt: options.connectionFaultAt,
+        });
+        const receipt = prepared.credentials
+            ? (await acknowledgeCliBootstrap(operationId, intent, prepared.receipt.keyPairVersion, { rootDir, signal, onAuthPrompt: promptDeviceAuth })).receipt
+            : prepared.receipt;
+        if (receipt.state !== 'connection_acknowledged') {
+            throw new StorystickError('Bootstrap acknowledgement was not committed.', {
+                code: 'BOOTSTRAP_ACK_INCOMPLETE',
+                category: 'system',
+            });
+        }
+        renderConnectResult(shortId, project.name, result, false, receipt);
+    }
+    catch (error) {
+        const hint = error instanceof StorystickError && error.status === 404
+            ? 'Run `storystick list` to see your projects.'
+            : undefined;
+        if (getOutputMode() === 'json') {
+            exitJsonFailure({ command: 'connect', err: error, hint });
+        }
+        exitWithError(error, hint);
+    }
+    finally {
+        dispose();
+    }
+}
+function renderConnectResult(shortId, projectName, result, dryRun, receipt) {
+    const data = {
+        shortId,
+        envFile: result.envFile,
+        created: result.created,
+        changed: result.changed,
+        dryRun,
+        changes: result.changes,
+        ...(receipt ? { receipt } : {}),
+    };
+    if (getOutputMode() === 'json') {
+        emitJsonResult({ command: 'connect', ok: true, data });
+        return;
+    }
+    if (dryRun) {
+        const lines = [
+            `Would connect ${projectName} (${shortId})`,
+            `Env file: ${result.envFile}`,
+            ...result.changes.map((change) => `${change.name}=${change.value} (${change.action})`),
+        ];
+        logOutput(lines.join('\n') + '\n');
+        return;
+    }
+    logFinishedStep(`Connected to ${pc.bold(projectName)} (${shortId})`);
+    logMessage(pc.dim(`  ${result.envFile}${result.created ? ' created' : ' updated'}`));
+}

package/dist/commands/connection.d.ts

@@ -0,0 +1,57 @@
+type Options = {
+    root?: string;
+    project?: string;
+    provider?: string;
+    attempt?: string;
+    cursor?: string;
+    installation?: string;
+    repository?: string;
+    fullName?: string;
+    branch?: string;
+    destination?: string;
+    json?: boolean;
+};
+export declare function connectionRequest(operation: string, options: Options): {
+    operation: string;
+    provider?: undefined;
+    attemptId?: undefined;
+    selection?: undefined;
+} | {
+    operation: string;
+    provider: string | undefined;
+    attemptId?: undefined;
+    selection?: undefined;
+} | {
+    installationId?: string | undefined;
+    cursor?: string | undefined;
+    operation: string;
+    attemptId: string;
+    provider?: undefined;
+    selection?: undefined;
+} | {
+    operation: string;
+    attemptId: string;
+    selection: {
+        provider: string;
+        destinationId: string | undefined;
+        installationId?: undefined;
+        repositoryId?: undefined;
+        fullName?: undefined;
+        branch?: undefined;
+    };
+    provider?: undefined;
+} | {
+    operation: string;
+    attemptId: string;
+    selection: {
+        provider: string;
+        installationId: number;
+        repositoryId: number;
+        fullName: string;
+        branch: string;
+        destinationId?: undefined;
+    };
+    provider?: undefined;
+};
+export declare function runConnection(operation: string, options: Options): Promise<void>;
+export {};

package/dist/commands/connection.js

@@ -0,0 +1,83 @@
+import { resolve } from 'node:path';
+import { callHubApi } from '../hub-client.js';
+import { resolveCliRuntimeConfig } from '../runtime-config.js';
+import { resolveProjectConnection } from '../project-connection.js';
+import { configureOutput, emitJsonResult, exitJsonFailure, exitWithError, getOutputMode, logMessage, withInterrupt, } from '../output.js';
+export function connectionRequest(operation, options) {
+    if (operation === 'status')
+        return { operation };
+    if (['begin', 'disconnect'].includes(operation)) {
+        if (!['github', 'vercel'].includes(options.provider ?? ''))
+            throw Error('Specify --provider github or vercel.');
+        return { operation, provider: options.provider };
+    }
+    if (!options.attempt)
+        throw Error('Specify the --attempt returned by connection status or begin.');
+    if (operation === 'resources')
+        return {
+            operation,
+            attemptId: options.attempt,
+            ...(options.cursor ? { cursor: options.cursor } : {}),
+            ...(options.installation ? { installationId: options.installation } : {}),
+        };
+    if (operation === 'select') {
+        if (options.provider === 'vercel' && /^prj_[a-zA-Z0-9]+$/.test(options.destination ?? ''))
+            return {
+                operation,
+                attemptId: options.attempt,
+                selection: { provider: 'vercel', destinationId: options.destination },
+            };
+        if (options.provider === 'github' &&
+            /^[1-9][0-9]*$/.test(options.installation ?? '') &&
+            /^[1-9][0-9]*$/.test(options.repository ?? '') &&
+            options.fullName &&
+            options.branch)
+            return {
+                operation,
+                attemptId: options.attempt,
+                selection: {
+                    provider: 'github',
+                    installationId: Number(options.installation),
+                    repositoryId: Number(options.repository),
+                    fullName: options.fullName,
+                    branch: options.branch,
+                },
+            };
+        throw Error('Select a returned resource: Vercel needs --destination; GitHub needs --installation, --repository, --full-name and --branch.');
+    }
+    throw Error('Use connection status, begin, resources, select or disconnect.');
+}
+export async function runConnection(operation, options) {
+    configureOutput({ json: options.json === true });
+    const { signal, dispose } = withInterrupt();
+    try {
+        if (process.env.STORYSTICK_RELEASE_SESSION)
+            throw Error('Account connections require your CLI login outside a release sandbox.');
+        const request = connectionRequest(operation, options);
+        const rootDir = resolve(options.root ?? '.');
+        const projectShortId = options.project ?? resolveProjectConnection(rootDir)?.shortId;
+        if (!projectShortId)
+            throw Error('Connect a project or specify --project <shortId>.');
+        const data = await callHubApi('/api/cli/project-setup', {
+            rootDir,
+            gatewayUrl: resolveCliRuntimeConfig({ rootDir }).gatewayUrl,
+            method: 'POST',
+            body: { projectShortId, operation: 'connection', request },
+            signal,
+            interactiveAuth: false,
+            timeoutMs: 90_000,
+        });
+        if (getOutputMode() === 'json')
+            emitJsonResult({ command: 'connection', ok: true, data });
+        else
+            logMessage(JSON.stringify(data, null, 2));
+    }
+    catch (err) {
+        if (getOutputMode() === 'json')
+            exitJsonFailure({ command: 'connection', err });
+        exitWithError(err);
+    }
+    finally {
+        dispose();
+    }
+}

package/dist/commands/content.d.ts

@@ -0,0 +1,11 @@
+export declare function runContent(action: string, target: string | undefined, options: {
+    root?: string;
+    project?: string;
+    json?: boolean;
+    dryRun?: boolean;
+    apply?: boolean;
+    plan?: string;
+    resume?: string;
+    newRun?: boolean;
+    renew?: string;
+}): Promise<void>;