@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/cli/app.js

@@ -0,0 +1,1329 @@
+#!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawn, spawnSync } from 'node:child_process';
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, dirname, extname, join, relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+import { resetLocalDatabase } from "../vite/localWorker.js";
+import { toolBin } from "./tools.js";
+function dependsOnPattern(directory) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
+        const dependencies = typeof manifest === 'object' && manifest !== null
+            ? Reflect.get(manifest, 'dependencies')
+            : undefined;
+        return (typeof dependencies === 'object' &&
+            dependencies !== null &&
+            '@trypattern/sdk' in dependencies);
+    }
+    catch {
+        return false;
+    }
+}
+function findRoot() {
+    const given = process.env['PATTERN_ROOT'];
+    if (given !== undefined)
+        return resolve(given);
+    let directory = process.cwd();
+    while (!dependsOnPattern(directory)) {
+        const parent = dirname(directory);
+        if (parent === directory) {
+            process.stderr.write('app: no Pattern project here. Run app inside a project that depends on @trypattern/sdk.\n');
+            process.exit(2);
+        }
+        directory = parent;
+    }
+    return directory;
+}
+const ROOT = findRoot();
+const SDK_SOURCE = resolve(import.meta.dirname, '..');
+const SDK_EXTENSION = extname(import.meta.filename);
+const FORMATTED_PATHS = [
+    'src',
+    'server',
+    'flows',
+    '.claude',
+    '*.{ts,json,jsonc,html,md}'
+];
+const LINT_CONFIG = resolve(SDK_SOURCE, '..', 'presets', 'oxlint.json');
+const MIGRATIONS_DIR = join('server', 'migrations');
+const DEV_DIR = join(ROOT, '.dev');
+const LOG_FILE = join(DEV_DIR, 'dev.log');
+const STATE_FILE = join(DEV_DIR, 'server.json');
+const START_TIMEOUT_MS = 20_000;
+const STOP_TIMEOUT_MS = 5_000;
+const LOG_TAIL_LINES = 30;
+const SHIM_DIR = join(homedir(), '.local', 'bin');
+const SHIM_PATH = join(SHIM_DIR, 'app');
+const SHIM_MARKER_LINE = 'PATTERN_APP_SHIM=1';
+const LAUNCHER_MARKER_LINE = 'PATTERN_APP_LAUNCHER=1';
+const LEGACY_SHIM_MARKERS = ['# starter-kit-app-shim', 'JIG_APP_SHIM=1'];
+const SCREENSHOTS_DIR = join(DEV_DIR, 'screenshots');
+const FLOW_SCREENSHOTS_DIR = join(SCREENSHOTS_DIR, 'flows');
+const CONTACT_SHEET = join(SCREENSHOTS_DIR, 'contact-sheet.png');
+const SCREENSHOT_WORKER = join(SDK_SOURCE, 'cli', `screenshot${SDK_EXTENSION}`);
+const VISUAL_URL_ENV = 'PATTERN_VISUAL_URL';
+const GLOBAL_FLAGS = ['--json', '--help', '-h'];
+const VALUE_FLAGS = new Set(['--commands', '--name', '--as']);
+const SHIM_SOURCE = `#!/bin/sh
+${SHIM_MARKER_LINE}
+dir=$PWD
+while :; do
+  if [ -f "$dir/app" ] && [ -x "$dir/app" ] && grep -qx '${LAUNCHER_MARKER_LINE}' "$dir/app" 2>/dev/null; then
+    exec "$dir/app" "$@"
+  fi
+  [ "$dir" = "/" ] && break
+  dir=$(dirname "$dir")
+done
+echo "app: no app found in $PWD or its parents" >&2
+exit 1
+`;
+const CHECK_STEPS = [
+    {
+        name: 'typecheck',
+        does: 'tsc over src/, flows/, schema.ts and seed.ts',
+        run: () => [toolBin('tsc'), '-p', '.']
+    },
+    {
+        name: 'typecheck-server',
+        does: 'tsc over server/',
+        run: () => [toolBin('tsc'), '-p', 'server']
+    },
+    {
+        name: 'lint',
+        does: "oxlint with Pattern's rules",
+        run: () => [toolBin('oxlint'), '--config', LINT_CONFIG, '--deny-warnings']
+    },
+    {
+        name: 'pattern-rules',
+        does: 'no comments in any file, and every file where it belongs',
+        run: () => [join(SDK_SOURCE, 'rules', `checkAllFiles${SDK_EXTENSION}`)]
+    },
+    {
+        name: 'format',
+        does: 'prettier --check',
+        run: () => [toolBin('prettier'), '--check', ...FORMATTED_PATHS]
+    },
+    {
+        name: 'flows',
+        does: 'every flow in flows/, headless',
+        run: () => [toolBin('vitest'), 'run']
+    },
+    {
+        name: 'build',
+        does: 'vite build',
+        run: () => [toolBin('vite'), 'build']
+    },
+    {
+        name: 'api-routing',
+        does: '/api reaches the worker and pages reach the app, in dev and in the build',
+        run: () => [join(SDK_SOURCE, 'rules', `checkApiRouting${SDK_EXTENSION}`)]
+    }
+];
+const DEV_USER = 'ada@acme.test';
+const COMMANDS = {
+    start: {
+        summary: 'Start the dev server in the background; wait until it responds, print its URL',
+        details: `Spawns Vite detached (port and strictPort set in vite.config.ts), logging to
+${LOG_FILE} (truncated on each start) and recording the pid in ${STATE_FILE}.
+Waits up to ${START_TIMEOUT_MS / 1000}s for the URL to respond. Fails if another process also answers on
+the port at 127.0.0.1 or ::1: strictPort misses this on macOS, because Node listens with SO_REUSEADDR,
+so Vite can bind ::1 while another server holds 127.0.0.1 or the wildcard address.
+If already running, prints the URL.
+Exit 0 when the server responds; otherwise prints the last ${LOG_TAIL_LINES} log lines and exits 1.
+Opens the URL in the default browser only when run in an interactive terminal (not with --json,
+not under CI, not when piped, so agents never trigger it). --no-open skips it.`,
+        run: startAndOpen,
+        flags: ['--no-open']
+    },
+    stop: {
+        summary: 'Stop the dev server started by `app start` (idempotent)',
+        details: `Sends SIGTERM to the server's whole process group (SIGKILL after ${STOP_TIMEOUT_MS / 1000}s)
+and removes the pid file. Exits 0 if nothing is running. Stale pid files are removed.`,
+        run: stop
+    },
+    status: {
+        summary: 'Show whether the dev server is running, with its URL and log; exit 1 if stopped',
+        details: `Reports the dev server state and the log path (${LOG_FILE}).
+Stale pid files (process gone or not Vite) are detected and removed.`,
+        run: status
+    },
+    check: {
+        summary: 'Typecheck + lint + Pattern rules + format + flows + build; exit non-zero on any failure',
+        details: `The definition of done. Runs every step even if an earlier one fails, so one run shows
+all problems. Prints ✓/✗ per step; a failing step shows its output and how to rerun just it.
+app check <step> runs one step. Steps:
+${CHECK_STEPS.map((step) => `  ${step.name.padEnd(17)} ${step.does}`).join('\n')}`,
+        run: check,
+        takesArgument: true
+    },
+    fix: {
+        summary: 'Apply every automatic fix: formatting and auto-fixable lint rules',
+        details: `Runs prettier --write over the project and oxlint --fix with Pattern's rules, then
+app check format and app check lint pass for anything a tool can fix by itself.`,
+        run: fix
+    },
+    reset: {
+        summary: 'Empty the local database and fill it again from seed.ts',
+        details: `Deletes every row in every table of the local database (signed-in users stay) and inserts
+the rows in seed.ts again. app start only fills an empty table, so run this after changing seed.ts.
+Works while the dev server runs; reload the page to see the new rows.`,
+        run: reset
+    },
+    migration: {
+        summary: 'Write a database migration for the tables in schema.ts',
+        details: `app migration add_due_dates
+Compares the tables in schema.ts (plus Pattern's users and sessions tables) with server/migrations and writes the
+SQL that moves the database from one to the other, named <number>_<name>.sql. app start applies new
+migrations to the local database. Prints "No schema changes" when the migrations already match.`,
+        run: migration,
+        takesArgument: true
+    },
+    build: {
+        summary: 'Build the app for production into dist/',
+        details: 'Runs vite build: the browser app and the Cloudflare Worker that serves /api.',
+        run: build
+    },
+    send: {
+        summary: 'Send a command to the app open in your browser and print its snapshot',
+        details: `app send '{"type":"app.navigate","to":"/settings"}'
+Runs the command in the running app (app start, with the page open) exactly as a click would,
+then prints the app's snapshot (page, path, every model's and store's state). The same commands
+drive flows/*.flow.ts. A command is a model's command() field, "<model>.<command>", declared in
+src/models/*.ts with its input. An unknown command lists every valid one.`,
+        run: send,
+        takesArgument: true
+    },
+    screenshot: {
+        summary: 'Screenshot a path at desktop and compact sizes in headless Chrome; fail on browser errors',
+        details: `app screenshot /settings
+app screenshot / --commands '[{"type":"shell.toggleSidebar"}]' --name sidebar-drawer
+Opens <path> in headless Google Chrome, runs --commands once, in order (a JSON array of the
+commands app send takes, the same ones app send and flows use), waits for fonts and an idle
+network with motion off (prefers-reduced-motion), then shows the same page at the desktop and
+compact (phone, sidebar as a drawer) sizes and saves ${pathFromCwd(SCREENSHOTS_DIR)}/<name>-desktop.png and
+<name>-compact.png. --name defaults to the path: /settings gives settings, / gives index.
+Signs in as ${DEV_USER} first (dev sign-in, no Google); --as <email> picks the user, --signed-out
+shows the app signed out.
+Then look at both PNGs (agents: open them with your file/image reader).
+Exit 1 if the page logs a console error, throws an uncaught error, or a request fails; the PNGs are
+still saved. Uses the running dev server, or starts one and stops it afterwards. Needs Google
+Chrome installed; no browser is downloaded.`,
+        run: screenshot,
+        takesArgument: true,
+        flags: ['--commands', '--name', '--as', '--signed-out']
+    },
+    test: {
+        summary: 'Run every flow in flows/ headlessly (no browser); --visual runs them in Chrome with screenshots',
+        details: `Flows drive the real route table and app store with commands, then check the app's
+snapshot (page, path, model and store state). They run in Node with no browser, so the whole suite takes about
+a second. Write one per feature in flows/<Name>.flow.ts using flow(name, steps). A
+{ screenshot: '<name>' } step is skipped here; only its name is checked.
+
+--visual runs the same flows in headless Google Chrome at the desktop and compact viewports: each
+command runs in the real app and each expect checks its snapshot. Every screenshot step saves
+${pathFromCwd(FLOW_SCREENSHOTS_DIR)}/<name>-desktop.png and <name>-compact.png, and all of them are laid out
+with labels in one contact sheet, ${pathFromCwd(CONTACT_SHEET)}, to review the whole app in one look.
+Console errors, uncaught errors and failed requests fail the run. Uses the running dev server, or
+starts one and stops it afterwards. Not part of app check.`,
+        run: test,
+        flags: ['--visual']
+    },
+    'sign-in': {
+        summary: 'Sign the app open in your browser in as a dev user (no Google); creates the user if new',
+        details: `app sign-in
+app sign-in grace@acme.test
+Runs the signIn.signInAsDevUser command in the open app, which calls /api/auth/dev-sign-in: the server finds or
+creates that user in the local D1 database and sets the same session cookie Google sign-in sets, so
+everything after it is the real signed-in app. Defaults to ${DEV_USER}. The route only exists in the
+dev server (app check proves the production build has none). Sign out with app send '{"type":"app.signOut"}'.`,
+        run: (argument) => send(JSON.stringify({
+            type: 'signIn.signInAsDevUser',
+            email: argument ?? DEV_USER
+        })),
+        takesArgument: true
+    },
+    setup: {
+        summary: 'Verify Node/pnpm match the pins, pnpm install, install the global `app` shim',
+        details: `Idempotent. Fails if Node != .nvmrc or pnpm != package.json "packageManager".
+Then runs \`pnpm install\` and installs ${SHIM_PATH}, a tiny shim that walks up from the
+current directory to the nearest project launcher (an executable ./app containing the line
+${LAUNCHER_MARKER_LINE}) and runs it, so each project's CLI lives in its repo and the shim
+never needs updating. Replaces older Jig or starter-kit shims; refuses to overwrite an
+existing ${SHIM_PATH} that was not installed by Pattern.`,
+        run: setup
+    },
+    help: {
+        summary: 'Show this help (`app <command> --help` for details)',
+        details: 'Lists commands. Flags: --json (machine-readable stdout), --help, --no-open (start only), --visual (test only), --commands, --name, --as and --signed-out (screenshot only).',
+        run: help
+    }
+};
+let jsonMode = false;
+let openBrowser = false;
+function progressStream() {
+    return jsonMode ? process.stderr : process.stdout;
+}
+function say(line) {
+    progressStream().write(`${line}\n`);
+}
+function pathFromCwd(path) {
+    const rel = relative(process.cwd(), path);
+    if (!relative(ROOT, process.cwd()).startsWith('..'))
+        return rel;
+    const home = homedir();
+    return path.startsWith(`${home}/`) ? `~/${relative(home, path)}` : rel;
+}
+function indent(text) {
+    return text
+        .split('\n')
+        .map((line) => `    ${line}`)
+        .join('\n');
+}
+function capture(bin, args, env = process.env) {
+    return new Promise((done) => {
+        let output = '';
+        let stdout = '';
+        const child = spawn(bin, args, {
+            cwd: ROOT,
+            env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        child.stdout.on('data', (chunk) => {
+            output += chunk.toString();
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => (output += chunk.toString()));
+        child.on('error', (err) => done({
+            code: 127,
+            output: `failed to run ${bin}: ${err.message}`,
+            stdout: ''
+        }));
+        child.on('close', (code) => done({ code: code ?? 1, output, stdout }));
+    });
+}
+function errCode(err) {
+    if (err instanceof Error && 'code' in err && typeof err.code === 'string') {
+        return err.code;
+    }
+    return undefined;
+}
+function sleep(ms) {
+    return new Promise((done) => setTimeout(done, ms));
+}
+function letPendingSpawnErrorEventFire() {
+    return sleep(0);
+}
+function readText(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function tail(text, lines) {
+    return text.trimEnd().split('\n').slice(-lines).join('\n');
+}
+function isServerState(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const v = value;
+    return (typeof v['pid'] === 'number' &&
+        (typeof v['url'] === 'string' || v['url'] === null) &&
+        typeof v['startedAt'] === 'string');
+}
+const UNREADABLE_STATE_TREATED_AS_STALE = {
+    pid: -1,
+    url: null,
+    startedAt: ''
+};
+function readState() {
+    const raw = readText(STATE_FILE);
+    if (raw === '')
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return isServerState(parsed) ? parsed : UNREADABLE_STATE_TREATED_AS_STALE;
+    }
+    catch {
+        return UNREADABLE_STATE_TREATED_AS_STALE;
+    }
+}
+function writeState(state) {
+    mkdirSync(DEV_DIR, { recursive: true });
+    writeFileSync(STATE_FILE, `${JSON.stringify(state, null, 2)}\n`);
+}
+function clearState() {
+    rmSync(STATE_FILE, { force: true });
+}
+function isLiveViteProcessNotAReusedPid(pid) {
+    if (pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+    }
+    catch (err) {
+        if (errCode(err) !== 'EPERM')
+            return false;
+    }
+    const ps = spawnSync('ps', ['-o', 'command=', '-p', String(pid)], {
+        encoding: 'utf8'
+    });
+    return ps.status === 0 && ps.stdout.includes('vite');
+}
+function groupAlive(pgid) {
+    try {
+        process.kill(-pgid, 0);
+        return true;
+    }
+    catch (err) {
+        return errCode(err) === 'EPERM';
+    }
+}
+async function killGroup(pgid) {
+    try {
+        process.kill(-pgid, 'SIGTERM');
+    }
+    catch (err) {
+        if (errCode(err) === 'ESRCH')
+            return;
+        throw err;
+    }
+    const deadline = Date.now() + STOP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (!groupAlive(pgid))
+            return;
+        await sleep(50);
+    }
+    try {
+        process.kill(-pgid, 'SIGKILL');
+    }
+    catch (err) {
+        if (errCode(err) !== 'ESRCH')
+            throw err;
+    }
+}
+function clearIfStale(state) {
+    if (state === undefined || isLiveViteProcessNotAReusedPid(state.pid))
+        return undefined;
+    clearState();
+    return state.pid;
+}
+function uptimeSeconds(state) {
+    return Math.max(0, Math.round((Date.now() - Date.parse(state.startedAt)) / 1000));
+}
+function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+}
+function runningOutcome(state, headline) {
+    const up = uptimeSeconds(state);
+    const url = state.url ?? '(url not yet known)';
+    return {
+        code: 0,
+        data: {
+            status: 'running',
+            url: state.url,
+            pid: state.pid,
+            uptimeSeconds: up,
+            log: LOG_FILE
+        },
+        text: [
+            `✓ ${headline} ${url}`,
+            `  up    ${formatUptime(up)}`,
+            `  log   ${pathFromCwd(LOG_FILE)}`,
+            `  stop  app stop`
+        ].join('\n')
+    };
+}
+function status() {
+    const state = readState();
+    if (state !== undefined && isLiveViteProcessNotAReusedPid(state.pid)) {
+        return runningOutcome(state, 'Dev server running at');
+    }
+    const stalePid = clearIfStale(state);
+    return {
+        code: 1,
+        data: {
+            status: 'stopped',
+            log: LOG_FILE,
+            removedStalePid: stalePid ?? null
+        },
+        text: [
+            'Dev server is not running',
+            `  start  app start`,
+            `  log    ${pathFromCwd(LOG_FILE)} (last run)`
+        ].join('\n')
+    };
+}
+async function fetchBodyOrUndefined(url) {
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(1000) });
+        return await res.text();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function servesThisProjectsPackageJsonViaViteFs(base) {
+    const body = await fetchBodyOrUndefined(`${base}@fs${ROOT}/package.json`);
+    return body !== undefined && body === readText(join(ROOT, 'package.json'));
+}
+const LOOPBACK_HOSTS_STRICT_PORT_CANNOT_GUARD_ON_MACOS = ['127.0.0.1', '[::1]'];
+async function foreignListenersOnDevPort(url) {
+    const { port } = new URL(url);
+    const foreign = [];
+    for (const host of LOOPBACK_HOSTS_STRICT_PORT_CANNOT_GUARD_ON_MACOS) {
+        const base = `http://${host}:${port}/`;
+        if ((await fetchBodyOrUndefined(base)) !== undefined &&
+            !(await servesThisProjectsPackageJsonViaViteFs(base))) {
+            foreign.push(base);
+        }
+    }
+    return foreign;
+}
+async function start() {
+    const existing = readState();
+    if (existing !== undefined && isLiveViteProcessNotAReusedPid(existing.pid)) {
+        return runningOutcome(existing, 'Dev server already running at');
+    }
+    clearIfStale(existing);
+    const viteBin = installedTool('vite');
+    if (viteBin === undefined) {
+        return {
+            code: 1,
+            data: { error: 'dependencies not installed' },
+            text: '✗ Dev server failed to start: dependencies are not installed\n  fix  app setup'
+        };
+    }
+    mkdirSync(DEV_DIR, { recursive: true });
+    const logFd = openSync(LOG_FILE, 'w');
+    const child = spawn(process.execPath, [viteBin], {
+        cwd: ROOT,
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' }
+    });
+    closeSync(logFd);
+    child.unref();
+    let exitReason;
+    child.on('error', (err) => {
+        exitReason = `spawn error: ${err.message}`;
+    });
+    child.on('exit', (code, signal) => {
+        exitReason = `vite exited (${signal ?? `code ${code}`}) before responding`;
+    });
+    const pid = child.pid;
+    if (pid === undefined) {
+        await letPendingSpawnErrorEventFire();
+        return startFailure(exitReason ?? 'spawn failed');
+    }
+    const state = {
+        pid,
+        url: null,
+        startedAt: new Date().toISOString()
+    };
+    writeState(state);
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (exitReason === undefined && Date.now() < deadline) {
+        if (state.url === null) {
+            const match = /Local:\s+(https?:\/\/\S+)/.exec(readText(LOG_FILE));
+            if (match?.[1] !== undefined) {
+                state.url = match[1];
+                writeState(state);
+            }
+        }
+        if (state.url !== null &&
+            (await servesThisProjectsPackageJsonViaViteFs(state.url))) {
+            const foreign = await foreignListenersOnDevPort(state.url);
+            if (foreign.length === 0) {
+                return runningOutcome(state, 'Dev server running at');
+            }
+            await killGroup(pid);
+            return startFailure(`port ${new URL(state.url).port} is already in use by another process (answering at ${foreign.join(', ')}). Stop it or change server.port in vite.config.ts.`);
+        }
+        await sleep(100);
+    }
+    if (exitReason === undefined) {
+        exitReason = `no response within ${START_TIMEOUT_MS / 1000}s`;
+        await killGroup(pid);
+    }
+    return startFailure(exitReason);
+}
+const SEEDED_FILE = join(DEV_DIR, 'seeded.json');
+async function importExport(file, name) {
+    if (!existsSync(join(ROOT, file)))
+        return undefined;
+    const module = await import(__rewriteRelativeImportExtension(pathToFileURL(join(ROOT, file)).href));
+    return typeof module === 'object' && module !== null
+        ? Reflect.get(module, name)
+        : undefined;
+}
+async function projectData() {
+    const tables = await importExport('schema.ts', 'tables');
+    if (typeof tables !== 'object' || tables === null) {
+        throw new Error('schema.ts must export `tables`');
+    }
+    const seed = (await importExport('seed.ts', 'seed')) ?? {};
+    if (typeof seed !== 'object' || seed === null) {
+        throw new Error('seed.ts must export `seed`');
+    }
+    return { tables: tables, seed };
+}
+function fingerprint(seed) {
+    return createHash('sha256').update(JSON.stringify(seed)).digest('hex');
+}
+function recordSeed(seed) {
+    mkdirSync(DEV_DIR, { recursive: true });
+    writeFileSync(SEEDED_FILE, JSON.stringify({ seed: fingerprint(seed) }));
+}
+async function seedChangedNotice() {
+    const { seed } = await projectData();
+    if (!existsSync(SEEDED_FILE)) {
+        recordSeed(seed);
+        return undefined;
+    }
+    const recorded = JSON.parse(readText(SEEDED_FILE));
+    const previous = typeof recorded === 'object' && recorded !== null
+        ? Reflect.get(recorded, 'seed')
+        : undefined;
+    return previous === fingerprint(seed)
+        ? undefined
+        : '  seed  seed.ts changed since the local database was filled; app reset fills it again';
+}
+async function reset() {
+    try {
+        const { tables, seed } = await projectData();
+        resetLocalDatabase(ROOT, tables, seed);
+        recordSeed(seed);
+        const rows = Object.values(seed).reduce((total, list) => total + (list?.length ?? 0), 0);
+        return {
+            code: 0,
+            data: { rows },
+            text: `✓ Local database emptied and filled with the ${rows} rows in seed.ts\n  next  reload the page`
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            code: 1,
+            data: { error: message },
+            text: `✗ Could not reset the local database: ${message}`
+        };
+    }
+}
+async function startAndOpen() {
+    const started = await start();
+    const notice = started.code === 0 ? await seedChangedNotice() : undefined;
+    const outcome = notice === undefined
+        ? started
+        : { ...started, text: `${started.text}\n${notice}` };
+    const url = outcome.data['url'];
+    if (openBrowser && outcome.code === 0 && typeof url === 'string') {
+        openUrl(url);
+        return { ...outcome, text: `${outcome.text}\n  Opened in your browser` };
+    }
+    return outcome;
+}
+function openUrl(url) {
+    const [bin, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    const child = spawn(bin, args, { detached: true, stdio: 'ignore' });
+    child.on('error', () => undefined);
+    child.unref();
+}
+function startFailure(reason) {
+    clearState();
+    const logTail = tail(readText(LOG_FILE), LOG_TAIL_LINES);
+    return {
+        code: 1,
+        data: { error: reason, log: LOG_FILE, logTail },
+        text: [
+            `✗ Dev server failed to start: ${reason}`,
+            `  log  ${pathFromCwd(LOG_FILE)} (last ${LOG_TAIL_LINES} lines below)`,
+            '',
+            indent(logTail)
+        ].join('\n')
+    };
+}
+async function stop() {
+    const state = readState();
+    if (state === undefined) {
+        return {
+            code: 0,
+            data: { status: 'stopped', wasRunning: false },
+            text: 'Dev server was not running'
+        };
+    }
+    if (!isLiveViteProcessNotAReusedPid(state.pid)) {
+        const stalePid = clearIfStale(state);
+        return {
+            code: 0,
+            data: {
+                status: 'stopped',
+                wasRunning: false,
+                removedStalePid: stalePid ?? null
+            },
+            text: 'Dev server was not running (cleaned up a leftover pid file)'
+        };
+    }
+    await killGroup(state.pid);
+    clearState();
+    return {
+        code: 0,
+        data: { status: 'stopped', wasRunning: true, pid: state.pid },
+        text: '✓ Dev server stopped'
+    };
+}
+function installedTool(tool) {
+    try {
+        return toolBin(tool);
+    }
+    catch {
+        return undefined;
+    }
+}
+function runTool(args) {
+    return capture(process.execPath, args);
+}
+function toolFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        code: 1,
+        data: { error: message },
+        text: `✗ ${message}\n  fix  app setup`
+    };
+}
+async function send(argument) {
+    const state = readState();
+    if (argument === undefined) {
+        return {
+            code: 2,
+            data: { error: 'missing command' },
+            text: '✗ Missing command\n  usage  app send \'{"type":"app.navigate","to":"/settings"}\''
+        };
+    }
+    if (state === undefined ||
+        state.url === null ||
+        !isLiveViteProcessNotAReusedPid(state.pid)) {
+        return {
+            code: 1,
+            data: { error: 'dev server not running' },
+            text: '✗ The dev server is not running\n  fix  app start'
+        };
+    }
+    try {
+        const response = await fetch(`${state.url}__pattern/send`, {
+            method: 'POST',
+            body: argument
+        });
+        const reply = await response.json();
+        const snapshot = typeof reply === 'object' && reply !== null && 'snapshot' in reply
+            ? reply.snapshot
+            : undefined;
+        if (!response.ok || snapshot === undefined) {
+            const error = typeof reply === 'object' && reply !== null && 'error' in reply
+                ? String(reply.error)
+                : `HTTP ${response.status}`;
+            return { code: 1, data: { error }, text: `✗ ${error}` };
+        }
+        return {
+            code: 0,
+            data: { snapshot },
+            text: `✓ Sent ${argument}\n${indent(JSON.stringify(snapshot, null, 2))}`
+        };
+    }
+    catch (error) {
+        return {
+            code: 1,
+            data: { error: String(error) },
+            text: `✗ Could not reach the dev server: ${String(error)}`
+        };
+    }
+}
+async function withDevServer(run) {
+    const existing = readState();
+    const wasRunning = existing !== undefined && isLiveViteProcessNotAReusedPid(existing.pid);
+    if (!wasRunning)
+        say('Starting the dev server for this run…');
+    const started = await start();
+    const url = started.data['url'];
+    if (started.code !== 0)
+        return started;
+    if (typeof url !== 'string') {
+        return {
+            code: 1,
+            data: { error: 'dev server URL not known yet' },
+            text: '✗ The dev server is still starting; rerun in a moment'
+        };
+    }
+    try {
+        return await run(url);
+    }
+    finally {
+        if (!wasRunning) {
+            await stop();
+            say('Stopped the dev server this run started');
+        }
+    }
+}
+function screenshotNameFromPath(path) {
+    const slug = path
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug === '' ? 'index' : slug;
+}
+function isScreenshotResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'screenshots' in value &&
+        Array.isArray(value.screenshots) &&
+        'problems' in value &&
+        Array.isArray(value.problems));
+}
+function workerError(value) {
+    return typeof value === 'object' &&
+        value !== null &&
+        'error' in value &&
+        typeof value.error === 'string'
+        ? value.error
+        : undefined;
+}
+function parseLastJsonLine(text) {
+    const line = text.trimEnd().split('\n').at(-1) ?? '';
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function screenshot(argument, options) {
+    const usage = '  usage  app screenshot /settings [--commands \'[{"type":"app.toggleSidebar"}]\'] [--name settings]';
+    if (argument === undefined || !argument.startsWith('/')) {
+        return {
+            code: 2,
+            data: { error: 'missing path' },
+            text: `✗ Give the path to screenshot, starting with /\n${usage}`
+        };
+    }
+    const rawCommands = options.get('--commands');
+    let commands = [];
+    if (typeof rawCommands === 'string') {
+        try {
+            commands = JSON.parse(rawCommands);
+        }
+        catch {
+            commands = undefined;
+        }
+    }
+    if (!Array.isArray(commands)) {
+        return {
+            code: 2,
+            data: { error: '--commands must be a JSON array of commands' },
+            text: `✗ --commands must be a JSON array of commands (the ones app send takes)\n${usage}`
+        };
+    }
+    const asOption = options.get('--as');
+    const signedInAs = options.has('--signed-out')
+        ? null
+        : typeof asOption === 'string'
+            ? asOption
+            : DEV_USER;
+    const nameOption = options.get('--name');
+    const name = typeof nameOption === 'string'
+        ? nameOption
+        : screenshotNameFromPath(argument);
+    const path = argument;
+    return withDevServer(async (url) => {
+        const { output, stdout } = await capture('node', [
+            SCREENSHOT_WORKER,
+            JSON.stringify({ url, path, name, commands, signedInAs })
+        ]);
+        const result = parseLastJsonLine(stdout);
+        const error = workerError(result);
+        if (!isScreenshotResult(result)) {
+            return {
+                code: 1,
+                data: { error: error ?? output.trimEnd() },
+                text: `✗ Screenshot of ${path} failed: ${error ?? 'the screenshot worker crashed'}${error === undefined ? `\n\n${indent(output.trimEnd())}` : ''}`
+            };
+        }
+        const files = result.screenshots.map((shot) => `  ${shot.viewport.padEnd(8)} ${`${shot.width}×${shot.height}`.padEnd(9)} ${pathFromCwd(shot.file)}`);
+        const ok = result.problems.length === 0;
+        const problems = result.problems.map((problem) => `  ✗ ${problem.message}  (${problem.viewports.join(', ')})`);
+        return {
+            code: ok ? 0 : 1,
+            data: { path, name, ...result },
+            text: ok
+                ? [`✓ Screenshots of ${path}`, ...files].join('\n')
+                : [
+                    `✗ Screenshots of ${path} found ${result.problems.length} problem${result.problems.length === 1 ? '' : 's'}`,
+                    ...problems,
+                    '',
+                    '  Screenshots were still saved:',
+                    ...files
+                ].join('\n')
+        };
+    });
+}
+async function runFlows(env) {
+    const { code, output } = await capture(process.execPath, [toolBin('vitest'), 'run', '--reporter=verbose'], env);
+    const results = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => /^[✓×✗]/.test(line))
+        .map((line) => line.replace(/\s+\d+ms$/, ''));
+    return { code, output, results };
+}
+function flowScreenshots() {
+    try {
+        return readdirSync(FLOW_SCREENSHOTS_DIR)
+            .filter((entry) => entry.endsWith('.png'))
+            .sort()
+            .map((entry) => join(FLOW_SCREENSHOTS_DIR, entry));
+    }
+    catch {
+        return [];
+    }
+}
+async function visualTest(url) {
+    const { code, output, results } = await runFlows({
+        ...process.env,
+        [VISUAL_URL_ENV]: url
+    });
+    const screenshots = flowScreenshots();
+    const contactSheet = existsSync(CONTACT_SHEET) ? CONTACT_SHEET : null;
+    const saved = [
+        `  screenshots    ${pathFromCwd(FLOW_SCREENSHOTS_DIR)}/ (${screenshots.length} PNGs)`,
+        ...(contactSheet === null
+            ? []
+            : [`  contact sheet  ${pathFromCwd(contactSheet)}`])
+    ];
+    const data = { results, screenshots, contactSheet };
+    if (code === 0) {
+        return {
+            code,
+            data,
+            text: [
+                ...results,
+                '',
+                `✓ ${results.length} flow runs passed in Chrome`,
+                ...saved,
+                '  Look at the contact sheet (agents: open it with your image reader).'
+            ].join('\n')
+        };
+    }
+    return {
+        code,
+        data: { ...data, output: output.trimEnd() },
+        text: [
+            indent(output.trimEnd()),
+            '',
+            '✗ Visual flows failed',
+            ...saved
+        ].join('\n')
+    };
+}
+async function test(_argument, options) {
+    if (options.has('--visual'))
+        return withDevServer(visualTest);
+    const { code, output, results } = await runFlows(process.env);
+    if (code === 0) {
+        return {
+            code,
+            data: { results },
+            text: [...results, '', `✓ ${results.length} flows passed`].join('\n')
+        };
+    }
+    return {
+        code,
+        data: { results, output: output.trimEnd() },
+        text: [indent(output.trimEnd()), '', '✗ Flows failed'].join('\n')
+    };
+}
+async function check(only) {
+    const fixes = {
+        format: 'app fix',
+        lint: 'app fix (auto-fixes StyleX key order and other fixable rules)'
+    };
+    const steps = only === undefined
+        ? CHECK_STEPS
+        : CHECK_STEPS.filter((step) => step.name === only);
+    if (steps.length === 0) {
+        return {
+            code: 2,
+            data: { error: `unknown step: ${only}` },
+            text: `✗ Unknown step ${only}. Steps: ${CHECK_STEPS.map((step) => step.name).join(', ')}`
+        };
+    }
+    const results = [];
+    const width = Math.max(...steps.map((s) => s.name.length));
+    for (const step of steps) {
+        let args;
+        try {
+            args = step.run();
+        }
+        catch (error) {
+            return toolFailure(error);
+        }
+        const { code, output } = await runTool(args);
+        const command = `app check ${step.name}`;
+        const ok = code === 0;
+        results.push({
+            name: step.name,
+            command,
+            exitCode: code,
+            ok,
+            ...(ok ? {} : { output: output.trimEnd() })
+        });
+        if (ok) {
+            say(`✓ ${step.name}`);
+        }
+        else {
+            const fix = fixes[step.name];
+            say([
+                `✗ ${step.name.padEnd(width)}  rerun: ${command}`,
+                ...(fix === undefined
+                    ? []
+                    : [`  ${''.padEnd(width)}  fix:   ${fix}`]),
+                '',
+                indent(output.trimEnd()),
+                ''
+            ].join('\n'));
+        }
+    }
+    const failed = results.filter((r) => !r.ok).map((r) => r.name);
+    return {
+        code: failed.length === 0 ? 0 : 1,
+        data: { steps: results, failed },
+        text: failed.length === 0
+            ? only === undefined
+                ? '\n✓ Check passed'
+                : ''
+            : `\n✗ Check failed: ${failed.join(', ')}`
+    };
+}
+async function fix() {
+    let commands;
+    try {
+        commands = [
+            [toolBin('prettier'), '--write', ...FORMATTED_PATHS],
+            [toolBin('oxlint'), '--config', LINT_CONFIG, '--fix']
+        ];
+    }
+    catch (error) {
+        return toolFailure(error);
+    }
+    for (const command of commands)
+        await runTool(command);
+    return {
+        code: 0,
+        data: {},
+        text: '✓ Formatted and applied lint fixes\n  next  app check'
+    };
+}
+async function writeDatabaseSchema() {
+    const project = await import(__rewriteRelativeImportExtension(pathToFileURL(join(ROOT, 'schema.ts')).href));
+    const tables = typeof project === 'object' && project !== null
+        ? Reflect.get(project, 'tables')
+        : undefined;
+    if (typeof tables !== 'object' || tables === null) {
+        throw new Error('schema.ts must export `tables`');
+    }
+    const keys = Object.keys(tables);
+    const notIdentifier = keys.find((key) => !/^[A-Za-z_$][\w$]*$/.test(key));
+    if (notIdentifier !== undefined) {
+        throw new Error(`"${notIdentifier}" in tables is not a plain name`);
+    }
+    const server = join(SDK_SOURCE, 'server');
+    const file = join(DEV_DIR, 'database.ts');
+    mkdirSync(DEV_DIR, { recursive: true });
+    writeFileSync(file, [
+        `import { sqlTable } from ${JSON.stringify(join(server, `tables${SDK_EXTENSION}`))}`,
+        `import { sessions } from ${JSON.stringify(join(server, `sessions${SDK_EXTENSION}`))}`,
+        `import { users } from ${JSON.stringify(join(server, `users${SDK_EXTENSION}`))}`,
+        `import { tables } from ${JSON.stringify(join(ROOT, 'schema.ts'))}`,
+        '',
+        'export { sessions, users }',
+        ...keys.map((key) => `export const ${key} = sqlTable(tables[${JSON.stringify(key)}])`),
+        ''
+    ].join('\n'));
+    return file;
+}
+async function migration(name) {
+    if (name === undefined || !/^[a-z0-9_]+$/.test(name)) {
+        return {
+            code: 2,
+            data: { error: 'missing name' },
+            text: '✗ Name the migration in snake_case\n  usage  app migration add_due_dates'
+        };
+    }
+    let drizzle;
+    try {
+        drizzle = toolBin('drizzle-kit');
+    }
+    catch (error) {
+        return toolFailure(error);
+    }
+    let schema;
+    try {
+        schema = await writeDatabaseSchema();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            code: 1,
+            data: { error: message },
+            text: `✗ Could not read the tables in schema.ts: ${message}`
+        };
+    }
+    const { code, output } = await runTool([
+        drizzle,
+        'generate',
+        '--dialect',
+        'sqlite',
+        '--schema',
+        schema,
+        '--out',
+        MIGRATIONS_DIR,
+        '--name',
+        name
+    ]);
+    const warning = code === 0 ? ownerBackfillWarning(name) : undefined;
+    return {
+        code,
+        data: { output: output.trimEnd(), ...(warning && { warning }) },
+        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${warning === undefined ? '' : `\n\n! ${warning}`}`
+    };
+}
+function ownerBackfillWarning(name) {
+    const file = readdirSync(MIGRATIONS_DIR)
+        .filter((entry) => entry.endsWith(`_${name}.sql`))
+        .sort()
+        .at(-1);
+    if (file === undefined)
+        return undefined;
+    const sql = readFileSync(join(MIGRATIONS_DIR, file), 'utf8');
+    const tables = [
+        ...sql.matchAll(/ALTER TABLE `(\w+)` ADD `owner_id`/g),
+        ...sql.matchAll(/CREATE TABLE `__new_(\w+)` \([^;]*`owner_id`/g)
+    ].map((match) => match[1]);
+    if (tables.length === 0)
+        return undefined;
+    return `${file} adds owner_id to ${tables.join(', ')}, which may already have rows. Backfill owner_id in this migration before the NOT NULL constraint, or reset the table.`;
+}
+async function build() {
+    let vite;
+    try {
+        vite = toolBin('vite');
+    }
+    catch (error) {
+        return toolFailure(error);
+    }
+    const { code, output } = await runTool([vite, 'build']);
+    return {
+        code,
+        data: { output: output.trimEnd() },
+        text: code === 0
+            ? '✓ Built into dist/'
+            : `✗ Build failed\n\n${indent(output.trimEnd())}`
+    };
+}
+function readPins() {
+    const node = readText(join(ROOT, '.nvmrc')).trim().replace(/^v/, '');
+    const pkg = JSON.parse(readText(join(ROOT, 'package.json')));
+    const pm = typeof pkg === 'object' && pkg !== null && 'packageManager' in pkg
+        ? String(pkg.packageManager)
+        : '';
+    return { node, pnpm: pm.replace(/^pnpm@/, '').split('+')[0] ?? '' };
+}
+function isPatternShim(source) {
+    const lines = source.split('\n');
+    return (lines.includes(SHIM_MARKER_LINE) ||
+        LEGACY_SHIM_MARKERS.some((marker) => source.includes(marker)));
+}
+function installShim() {
+    const current = existsSync(SHIM_PATH) ? readText(SHIM_PATH) : undefined;
+    if (current !== undefined && !isPatternShim(current)) {
+        return { status: 'refused', path: SHIM_PATH };
+    }
+    if (current === SHIM_SOURCE) {
+        chmodSync(SHIM_PATH, 0o755);
+        return { status: 'unchanged', path: SHIM_PATH };
+    }
+    mkdirSync(SHIM_DIR, { recursive: true });
+    writeFileSync(SHIM_PATH, SHIM_SOURCE);
+    chmodSync(SHIM_PATH, 0o755);
+    return {
+        status: current === undefined ? 'installed' : 'updated',
+        path: SHIM_PATH
+    };
+}
+async function setup() {
+    const pins = readPins();
+    const haveNode = process.versions.node;
+    const pnpmVersion = spawnSync('pnpm', ['--version'], {
+        cwd: ROOT,
+        encoding: 'utf8'
+    });
+    const havePnpm = (pnpmVersion.stdout ?? '').trim();
+    const problems = [];
+    if (haveNode !== pins.node) {
+        problems.push(`Node ${haveNode} does not match .nvmrc (${pins.node})\n  fix  nvm install && nvm use`);
+    }
+    if (havePnpm !== pins.pnpm) {
+        problems.push(`pnpm ${havePnpm || '(not found)'} does not match package.json packageManager (${pins.pnpm})\n  fix  corepack enable pnpm`);
+    }
+    const versions = { node: haveNode, pnpm: havePnpm, expected: pins };
+    if (problems.length > 0) {
+        return {
+            code: 1,
+            data: { versions, problems },
+            text: problems.map((p) => `✗ ${p}`).join('\n')
+        };
+    }
+    say(`✓ Node ${haveNode} and pnpm ${havePnpm} match the pins`);
+    const install = await capture('pnpm', ['install']);
+    if (install.code !== 0) {
+        return {
+            code: install.code,
+            data: { versions, error: 'pnpm install failed', output: install.output },
+            text: `✗ Installing dependencies failed  rerun: pnpm install\n\n${indent(install.output.trimEnd())}`
+        };
+    }
+    say('✓ Dependencies installed');
+    const shim = installShim();
+    const onPath = (process.env['PATH'] ?? '').split(delimiter).includes(SHIM_DIR);
+    const lines = [];
+    if (shim.status === 'refused') {
+        lines.push(`✗ Not installing the \`app\` command: ${pathFromCwd(SHIM_PATH)} already exists and isn't from Pattern`, '  fix  use ./app instead, or remove that file and rerun ./app setup');
+    }
+    else {
+        const verb = shim.status === 'unchanged' ? 'already installed' : shim.status;
+        lines.push(`✓ \`app\` command ${verb} (${pathFromCwd(SHIM_PATH)})`);
+        if (!onPath) {
+            lines.push(`  warning  ${pathFromCwd(SHIM_DIR)} is not on your PATH; add it to use \`app\` without ./`);
+        }
+    }
+    return {
+        code: shim.status === 'refused' ? 1 : 0,
+        data: { versions, shim, shimDirOnPath: onPath },
+        text: lines.join('\n')
+    };
+}
+function help() {
+    const width = Math.max(...Object.keys(COMMANDS).map((n) => n.length));
+    const lines = Object.entries(COMMANDS).map(([name, cmd]) => `app ${name.padEnd(width)}  ${cmd.summary}`);
+    lines.push('Flags: --json (machine-readable stdout), <command> --help (details and its own flags: start --no-open, test --visual, screenshot --commands --name --as --signed-out)');
+    return {
+        code: 0,
+        data: {
+            commands: Object.entries(COMMANDS).map(([name, cmd]) => ({
+                name,
+                summary: cmd.summary
+            }))
+        },
+        text: lines.join('\n')
+    };
+}
+function parseArguments(argv) {
+    const options = new Map();
+    const positional = [];
+    const problems = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        if (!arg.startsWith('-')) {
+            positional.push(arg);
+            continue;
+        }
+        const equals = arg.indexOf('=');
+        const flag = equals === -1 ? arg : arg.slice(0, equals);
+        if (!VALUE_FLAGS.has(flag)) {
+            options.set(arg, true);
+            continue;
+        }
+        const value = equals === -1 ? argv[(i += 1)] : arg.slice(equals + 1);
+        if (value === undefined)
+            problems.push(`${flag} needs a value`);
+        else
+            options.set(flag, value);
+    }
+    return { options, positional, problems };
+}
+async function main(argv) {
+    const { options, positional, problems } = parseArguments(argv);
+    jsonMode = options.has('--json');
+    const wantsHelp = options.has('--help') || options.has('-h');
+    openBrowser =
+        process.stdout.isTTY &&
+            !jsonMode &&
+            !options.has('--no-open') &&
+            !process.env['CI'];
+    const name = positional[0] ?? 'help';
+    const command = COMMANDS[name];
+    const allowedFlags = [...GLOBAL_FLAGS, ...(command?.flags ?? [])];
+    const unknownFlags = [...options.keys()].filter((f) => !allowedFlags.includes(f));
+    let outcome;
+    const allowedPositionals = command?.takesArgument === true ? 2 : 1;
+    if (command === undefined ||
+        positional.length > allowedPositionals ||
+        unknownFlags.length > 0 ||
+        problems.length > 0) {
+        const problem = command === undefined
+            ? `unknown command: ${name}`
+            : positional.length > allowedPositionals
+                ? `unexpected argument: ${positional[allowedPositionals]}`
+                : unknownFlags.length > 0
+                    ? `unknown flag for ${name}: ${unknownFlags.join(' ')}`
+                    : problems.join(', ');
+        const usage = help();
+        outcome = {
+            code: 2,
+            data: { error: problem, ...usage.data },
+            text: `app: ${problem}\n${usage.text}`
+        };
+    }
+    else if (wantsHelp) {
+        outcome = {
+            code: 0,
+            data: { name, summary: command.summary, details: command.details },
+            text: `app ${name} — ${command.summary}\n\n${command.details}`
+        };
+    }
+    else {
+        outcome = await command.run(positional[1], options);
+    }
+    if (jsonMode) {
+        const payload = {
+            command: name,
+            ok: outcome.code === 0,
+            exitCode: outcome.code,
+            ...outcome.data
+        };
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    }
+    else {
+        ;
+        (outcome.code === 2 ? process.stderr : process.stdout).write(`${outcome.text}\n`);
+    }
+    return outcome.code;
+}
+process.exitCode = await main(process.argv.slice(2));