becky-cli 0.2.12

package/dist/postgres/admin.js

@@ -0,0 +1,77 @@
+import { commandExists, run, runOrThrow } from "../util/exec.js";
+import { detail, info, success, warn } from "../util/log.js";
+export async function getPostgresStatus() {
+    const hasPsql = await commandExists("psql");
+    if (!hasPsql) {
+        return { installed: false, serviceActive: false };
+    }
+    let version;
+    try {
+        const out = await run("psql", ["--version"]);
+        version = out.stdout.trim() || out.stderr.trim();
+    }
+    catch {
+        version = undefined;
+    }
+    const service = await run("systemctl", ["is-active", "postgresql"]);
+    const serviceActive = service.stdout.trim() === "active";
+    return { installed: true, version, serviceActive };
+}
+export function sqlLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export async function postgresQuery(sql) {
+    return runOrThrow("sudo", ["-u", "postgres", "psql", "-v", "ON_ERROR_STOP=1", "-tAc", sql], {}, "PostgreSQL query failed");
+}
+export async function roleExists(name) {
+    const out = await postgresQuery(`SELECT 1 FROM pg_roles WHERE rolname=${sqlLiteral(name)}`);
+    return out.trim() === "1";
+}
+export async function databaseExists(name) {
+    const out = await postgresQuery(`SELECT 1 FROM pg_database WHERE datname=${sqlLiteral(name)}`);
+    return out.trim() === "1";
+}
+export async function setupDatabaseUser(options) {
+    const { user, password, database, grantPrivileges = true } = options;
+    if (await roleExists(user)) {
+        warn(`Role "${user}" already exists — updating password`);
+        await postgresQuery(`ALTER ROLE ${quoteIdent(user)} WITH LOGIN PASSWORD ${sqlLiteral(password)}`);
+    }
+    else {
+        info(`Creating role "${user}"`);
+        await postgresQuery(`CREATE ROLE ${quoteIdent(user)} WITH LOGIN PASSWORD ${sqlLiteral(password)} CREATEDB`);
+        success(`Role "${user}" created`);
+    }
+    if (await databaseExists(database)) {
+        warn(`Database "${database}" already exists — skipping create`);
+    }
+    else {
+        info(`Creating database "${database}"`);
+        await postgresQuery(`CREATE DATABASE ${quoteIdent(database)} OWNER ${quoteIdent(user)} ENCODING 'UTF8'`);
+        success(`Database "${database}" created`);
+    }
+    if (grantPrivileges) {
+        await postgresQuery(`GRANT ALL PRIVILEGES ON DATABASE ${quoteIdent(database)} TO ${quoteIdent(user)}`);
+        detail(`Granted privileges on "${database}" to "${user}"`);
+    }
+}
+function quoteIdent(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+}
+export function buildDatabaseUrl(user, password, database, host = "localhost", port = 5432) {
+    const encodedUser = encodeURIComponent(user);
+    const encodedPassword = encodeURIComponent(password);
+    return `postgresql://${encodedUser}:${encodedPassword}@${host}:${port}/${database}`;
+}
+export async function ensureServiceRunning() {
+    const status = await getPostgresStatus();
+    if (!status.installed)
+        return;
+    if (status.serviceActive) {
+        detail("PostgreSQL service is running");
+        return;
+    }
+    info("Starting PostgreSQL service");
+    await runOrThrow("sudo", ["systemctl", "enable", "--now", "postgresql"], {}, "Failed to start PostgreSQL");
+    success("PostgreSQL service started");
+}

package/dist/project/alembicScaffold.d.ts

@@ -0,0 +1,7 @@
+import type { LoadedProject } from "./load.js";
+export declare const ALEMBIC_INI = "[alembic]\nscript_location = alembic\nprepend_sys_path = .\nversion_path_separator = os\n\n[loggers]\nkeys = root,sqlalchemy,alembic\n\n[handlers]\nkeys = console\n\n[formatters]\nkeys = generic\n\n[logger_root]\nlevel = WARN\nhandlers = console\nqualname =\n\n[logger_sqlalchemy]\nlevel = WARN\nhandlers =\nqualname = sqlalchemy.engine\n\n[logger_alembic]\nlevel = INFO\nhandlers =\nqualname = alembic\n\n[handler_console]\nclass = StreamHandler\nargs = (sys.stderr,)\nlevel = NOTSET\nformatter = generic\n\n[formatter_generic]\nformat = %(levelname)-5.5s [%(name)s] %(message)s\ndatefmt = %H:%M:%S\n";
+export declare const ALEMBIC_ENV_PY = "import os\nfrom configparser import ConfigParser\nfrom logging.config import fileConfig\n\nfrom alembic import context\nfrom sqlalchemy import engine_from_config, pool\n\nconfig = context.config\nif config.config_file_name is not None:\n    _ini = ConfigParser()\n    _ini.read(config.config_file_name)\n    if _ini.has_section(\"formatters\"):\n        fileConfig(config.config_file_name)\n\nfrom db.session import Base  # noqa: E402\n\ntarget_metadata = Base.metadata\n\n\ndef get_url() -> str:\n    return os.environ[\"DATABASE_URL\"]\n\n\ndef run_migrations_offline() -> None:\n    context.configure(\n        url=get_url(),\n        target_metadata=target_metadata,\n        literal_binds=True,\n        dialect_opts={\"paramstyle\": \"named\"},\n    )\n    with context.begin_transaction():\n        context.run_migrations()\n\n\ndef run_migrations_online() -> None:\n    configuration = config.get_section(config.config_ini_section) or {}\n    configuration[\"sqlalchemy.url\"] = get_url()\n    connectable = engine_from_config(configuration, prefix=\"sqlalchemy.\", poolclass=pool.NullPool)\n    with connectable.connect() as connection:\n        context.configure(connection=connection, target_metadata=target_metadata)\n        with context.begin_transaction():\n            context.run_migrations()\n\n\nif context.is_offline_mode():\n    run_migrations_offline()\nelse:\n    run_migrations_online()\n";
+export declare const ALEMBIC_SCRIPT_MAKO = "\"\"\"\\${message}\n\nRevision ID: \\${up_revision}\nRevises: \\${down_revision | comma,n}\nCreate Date: \\${create_date}\n\"\"\"\nfrom alembic import op\nimport sqlalchemy as sa\n\\${imports if imports else \"\"}\n\nrevision = \\${repr(up_revision)}\ndown_revision = \\${repr(down_revision)}\nbranch_labels = \\${repr(branch_labels)}\ndepends_on = \\${repr(depends_on)}\n\n\ndef upgrade():\n    \\${upgrades if upgrades else \"pass\"}\n\n\ndef downgrade():\n    \\${downgrades if downgrades else \"pass\"}\n";
+export declare function migrateShContent(stackRoot: string): string;
+/** Write or repair alembic.ini + env.py when the AI scaffold omitted or truncated them. */
+export declare function ensureAlembicScaffold(project: LoadedProject): void;

package/dist/project/alembicScaffold.js

@@ -0,0 +1,161 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { info } from "../util/log.js";
+export const ALEMBIC_INI = `[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
+`;
+export const ALEMBIC_ENV_PY = `import os
+from configparser import ConfigParser
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+config = context.config
+if config.config_file_name is not None:
+    _ini = ConfigParser()
+    _ini.read(config.config_file_name)
+    if _ini.has_section("formatters"):
+        fileConfig(config.config_file_name)
+
+from db.session import Base  # noqa: E402
+
+target_metadata = Base.metadata
+
+
+def get_url() -> str:
+    return os.environ["DATABASE_URL"]
+
+
+def run_migrations_offline() -> None:
+    context.configure(
+        url=get_url(),
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    configuration = config.get_section(config.config_ini_section) or {}
+    configuration["sqlalchemy.url"] = get_url()
+    connectable = engine_from_config(configuration, prefix="sqlalchemy.", poolclass=pool.NullPool)
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
+`;
+export const ALEMBIC_SCRIPT_MAKO = `"""\\\${message}
+
+Revision ID: \\\${up_revision}
+Revises: \\\${down_revision | comma,n}
+Create Date: \\\${create_date}
+"""
+from alembic import op
+import sqlalchemy as sa
+\\\${imports if imports else ""}
+
+revision = \\\${repr(up_revision)}
+down_revision = \\\${repr(down_revision)}
+branch_labels = \\\${repr(branch_labels)}
+depends_on = \\\${repr(depends_on)}
+
+
+def upgrade():
+    \\\${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    \\\${downgrades if downgrades else "pass"}
+`;
+export function migrateShContent(stackRoot) {
+    return `#!/usr/bin/env bash
+set -euo pipefail
+cd "${stackRoot}"
+if [ -d .venv ]; then source .venv/bin/activate; fi
+python -m alembic upgrade head
+`;
+}
+/** Logging sections fileConfig() requires; alembic.ini without them raises KeyError. */
+const ALEMBIC_LOGGING_SECTIONS = ALEMBIC_INI.slice(ALEMBIC_INI.indexOf("[loggers]"));
+/** Write or repair alembic.ini + env.py when the AI scaffold omitted or truncated them. */
+export function ensureAlembicScaffold(project) {
+    const ini = join(project.stackRoot, "alembic.ini");
+    const envPy = join(project.stackRoot, "alembic", "env.py");
+    const mako = join(project.stackRoot, "alembic", "script.py.mako");
+    const versions = join(project.stackRoot, "alembic", "versions");
+    if (!existsSync(ini)) {
+        writeFileSync(ini, ALEMBIC_INI, "utf8");
+        info(`Created ${ini}`);
+    }
+    else {
+        const current = readFileSync(ini, "utf8");
+        if (!current.includes("[formatters]")) {
+            writeFileSync(ini, `${current.replace(/\n+$/, "")}\n\n${ALEMBIC_LOGGING_SECTIONS}`, "utf8");
+            info("Added missing logging sections to alembic.ini");
+        }
+    }
+    if (!existsSync(envPy)) {
+        mkdirSync(join(project.stackRoot, "alembic"), { recursive: true });
+        writeFileSync(envPy, ALEMBIC_ENV_PY, "utf8");
+        info(`Created ${envPy}`);
+    }
+    else {
+        const current = readFileSync(envPy, "utf8");
+        if (current.includes("fileConfig(config.config_file_name)") && !current.includes("has_section")) {
+            writeFileSync(envPy, ALEMBIC_ENV_PY, "utf8");
+            info("Rewrote alembic/env.py with a logging-safe config loader");
+        }
+    }
+    if (!existsSync(mako)) {
+        mkdirSync(join(project.stackRoot, "alembic"), { recursive: true });
+        writeFileSync(mako, ALEMBIC_SCRIPT_MAKO, "utf8");
+    }
+    if (!existsSync(versions)) {
+        mkdirSync(versions, { recursive: true });
+    }
+}

package/dist/project/env.d.ts

@@ -0,0 +1,25 @@
+import { type StoredCredentials } from "../config/store.js";
+import type { LoadedProject } from "../project/load.js";
+export type ConnectionTarget = {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    databaseUrl: string;
+};
+export type ResolveConnectionOptions = {
+    user?: string;
+    password?: string;
+    database?: string;
+    host?: string;
+    port?: number;
+    promptIfMissing?: boolean;
+};
+export declare function resolveConnection(project: LoadedProject, options?: ResolveConnectionOptions): Promise<ConnectionTarget>;
+/** Prisma reads .env next to schema.prisma (e.g. server/.env), not always project root. */
+export declare function envFilePaths(project: LoadedProject): string[];
+export declare function writeEnvFile(project: LoadedProject, connection: ConnectionTarget, force?: boolean): string[];
+export declare function testDatabaseConnection(connection: ConnectionTarget): Promise<void>;
+export declare function credentialsSummary(creds: StoredCredentials): string;
+export declare function confirmPrompt(message: string, yes: boolean): Promise<boolean>;

package/dist/project/env.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadCredentials } from "../config/store.js";
+import { buildDatabaseUrl } from "../postgres/admin.js";
+import { resolveDbIdentity } from "../project/identity.js";
+import { promptHidden, promptText } from "../util/prompt.js";
+import { detail, info, success, warn } from "../util/log.js";
+export async function resolveConnection(project, options = {}) {
+    const saved = loadCredentials();
+    const { user, database } = resolveDbIdentity(project, {
+        user: options.user,
+        database: options.database,
+    });
+    const host = options.host?.trim() || saved?.host || "localhost";
+    const port = options.port ?? saved?.port ?? 5432;
+    // Reuse password only when it matches this project user+db (or same db with matching user)
+    const savedPassword = saved &&
+        saved.database === database &&
+        (saved.user === user || saved.user === "app")
+        ? saved.password
+        : saved?.password && saved.user === user
+            ? saved.password
+            : undefined;
+    let password = options.password ?? savedPassword;
+    if (!password && options.promptIfMissing !== false) {
+        password = await promptHidden(`Database password for user "${user}"`);
+    }
+    if (!password) {
+        throw new Error("No database password found. Run `becky postgres setup` first, or pass --password.");
+    }
+    if (saved?.user === "app" && user !== "app") {
+        warn(`Ignoring legacy credentials user "app" — using project user "${user}"`);
+    }
+    return {
+        host,
+        port,
+        user,
+        password,
+        database,
+        databaseUrl: buildDatabaseUrl(user, password, database, host, port),
+    };
+}
+function envFileContent(connection, template) {
+    const lines = [
+        `# Generated by becky connect`,
+        `POSTGRES_USER=${connection.user}`,
+        `POSTGRES_PASSWORD=${connection.password}`,
+        `POSTGRES_DB=${connection.database}`,
+        `DATABASE_URL=${connection.databaseUrl}`,
+    ];
+    if (template) {
+        const preserved = [];
+        for (const line of template.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const key = trimmed.split("=")[0];
+            if (!key)
+                continue;
+            if (["POSTGRES_USER", "POSTGRES_PASSWORD", "POSTGRES_DB", "DATABASE_URL"].includes(key)) {
+                continue;
+            }
+            preserved.push(line);
+        }
+        if (preserved.length) {
+            lines.push("", "# From .env.example", ...preserved);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Prisma reads .env next to schema.prisma (e.g. server/.env), not always project root. */
+export function envFilePaths(project) {
+    const rootEnv = join(project.root, ".env");
+    const stackEnv = join(project.stackRoot, ".env");
+    return stackEnv === rootEnv ? [rootEnv] : [stackEnv, rootEnv];
+}
+export function writeEnvFile(project, connection, force = false) {
+    const template = existsSync(join(project.root, ".env.example"))
+        ? readFileSync(join(project.root, ".env.example"), "utf8")
+        : existsSync(join(project.stackRoot, ".env.example"))
+            ? readFileSync(join(project.stackRoot, ".env.example"), "utf8")
+            : "";
+    const content = envFileContent(connection, template);
+    const written = [];
+    for (const envPath of envFilePaths(project)) {
+        if (existsSync(envPath) && !force) {
+            warn(`.env already exists at ${envPath} — use --force to overwrite`);
+            continue;
+        }
+        writeFileSync(envPath, content, "utf8");
+        success(`Wrote ${envPath}`);
+        written.push(envPath);
+    }
+    if (!written.length) {
+        throw new Error("No .env files written — existing files blocked connect (use --force)");
+    }
+    return written;
+}
+export async function testDatabaseConnection(connection) {
+    const { run } = await import("../util/exec.js");
+    info("Testing database connection…");
+    const result = await run("psql", [
+        connection.databaseUrl,
+        "-v",
+        "ON_ERROR_STOP=1",
+        "-tAc",
+        "SELECT 1",
+    ]);
+    if (result.code !== 0) {
+        const detailText = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n");
+        throw new Error(`Could not connect to Postgres:\n${detailText}`);
+    }
+    success("Database connection OK");
+    detail(`${connection.user}@${connection.host}:${connection.port}/${connection.database}`);
+}
+export function credentialsSummary(creds) {
+    return `${creds.user}@${creds.host}:${creds.port}/${creds.database}`;
+}
+export async function confirmPrompt(message, yes) {
+    if (yes)
+        return true;
+    const answer = await promptText(`${message} (y/N)`, "n");
+    return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}

package/dist/project/fastapiPins.d.ts

@@ -0,0 +1,3 @@
+/** Python deps that install cleanly on Ubuntu + Python 3.11–3.13. */
+export declare const FASTAPI_REQUIREMENTS = "fastapi>=0.115.0\nuvicorn[standard]>=0.32.0\nsqlalchemy>=2.0.0\nalembic>=1.14.0\npsycopg2-binary>=2.9.9\npython-dotenv>=1.0.0\n";
+export declare function isLegacyFastapiRequirements(content: string): boolean;

package/dist/project/fastapiPins.js

@@ -0,0 +1,13 @@
+/** Python deps that install cleanly on Ubuntu + Python 3.11–3.13. */
+export const FASTAPI_REQUIREMENTS = `fastapi>=0.115.0
+uvicorn[standard]>=0.32.0
+sqlalchemy>=2.0.0
+alembic>=1.14.0
+psycopg2-binary>=2.9.9
+python-dotenv>=1.0.0
+`;
+export function isLegacyFastapiRequirements(content) {
+    return (/fastapi==0\.(9|[0-8])\./.test(content) ||
+        /uvicorn==0\.(2[0-1]|1[0-9]|[0-9])\./.test(content) ||
+        /sqlalchemy==1\./.test(content));
+}

package/dist/project/identity.d.ts

@@ -0,0 +1,13 @@
+import type { LoadedProject } from "./load.js";
+export type DbIdentityOptions = {
+    user?: string;
+    database?: string;
+};
+/**
+ * Resolve Postgres role + database for a generated project.
+ * Project slug always wins over legacy "app" (unless --user is explicit).
+ */
+export declare function resolveDbIdentity(project: LoadedProject, options?: DbIdentityOptions): {
+    user: string;
+    database: string;
+};

package/dist/project/identity.js

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { warn } from "../util/log.js";
+function readEnvExampleValue(project, key) {
+    for (const dir of [project.root, project.stackRoot]) {
+        const path = join(dir, ".env.example");
+        if (!existsSync(path))
+            continue;
+        const match = readFileSync(path, "utf8").match(new RegExp(`^${key}=(.+)$`, "m"));
+        const value = match?.[1]?.trim();
+        if (value && value !== "app" && !value.includes("{"))
+            return value;
+    }
+    return null;
+}
+/**
+ * Resolve Postgres role + database for a generated project.
+ * Project slug always wins over legacy "app" (unless --user is explicit).
+ */
+export function resolveDbIdentity(project, options = {}) {
+    const database = options.database?.trim() || project.databaseName;
+    const explicitUser = options.user?.trim();
+    let user = explicitUser || project.databaseUser || database;
+    if (!explicitUser) {
+        const fromExample = readEnvExampleValue(project, "POSTGRES_USER");
+        if (fromExample)
+            user = fromExample;
+        if (user === "app") {
+            const replacement = project.databaseUser || database;
+            if (replacement !== "app") {
+                warn(`Replacing legacy DB user "app" with project user "${replacement}"`);
+                user = replacement;
+            }
+        }
+    }
+    return { user, database };
+}

package/dist/project/load.d.ts

@@ -0,0 +1,27 @@
+export type Stack = "fastapi-postgres" | "express-postgres" | "nest-postgres";
+export type ProjectSpec = {
+    projectName: string;
+    stack: Stack;
+    auth?: string;
+    entities?: unknown[];
+    outputs?: {
+        docker?: boolean;
+        migrations?: boolean;
+        openapi?: boolean;
+    };
+};
+export type LoadedProject = {
+    root: string;
+    specPath: string;
+    spec: ProjectSpec;
+    stackRoot: string;
+    databaseName: string;
+    /** Postgres role — same slug as the database by default */
+    databaseUser: string;
+};
+/** Safe Postgres identifier from project name (e.g. bicycle-marketplace → bicycle_marketplace) */
+export declare function projectDbName(projectName: string): string;
+/** DB role defaults to the same name as the database */
+export declare function projectDbUser(projectName: string): string;
+export declare function findProjectSpec(dir: string): string | null;
+export declare function loadProject(dir?: string): LoadedProject;

package/dist/project/load.js

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+const STACK_ROOT = {
+    "fastapi-postgres": "backend",
+    "express-postgres": "server",
+    "nest-postgres": "api",
+};
+/** Safe Postgres identifier from project name (e.g. bicycle-marketplace → bicycle_marketplace) */
+export function projectDbName(projectName) {
+    const slug = projectName
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    const name = (slug || "my-backend").replace(/-/g, "_");
+    // Postgres identifiers max 63 chars; must start with a letter
+    const trimmed = name.slice(0, 63);
+    return /^[a-z]/.test(trimmed) ? trimmed : `app_${trimmed}`;
+}
+/** DB role defaults to the same name as the database */
+export function projectDbUser(projectName) {
+    return projectDbName(projectName);
+}
+export function findProjectSpec(dir) {
+    const absolute = resolve(dir);
+    const candidates = [join(absolute, "project-spec.json")];
+    // Also accept path that points directly at the file
+    if (basename(absolute) === "project-spec.json" && existsSync(absolute)) {
+        return absolute;
+    }
+    for (const path of candidates) {
+        if (existsSync(path))
+            return path;
+    }
+    return null;
+}
+export function loadProject(dir = ".") {
+    const absolute = resolve(dir);
+    const specPath = findProjectSpec(absolute);
+    if (!specPath) {
+        throw new Error(`No project-spec.json found in ${absolute}. Unzip a Becky project first, or pass the project directory.`);
+    }
+    const raw = JSON.parse(readFileSync(specPath, "utf8"));
+    if (!raw.projectName?.trim() || !raw.stack) {
+        throw new Error(`Invalid project-spec.json at ${specPath}`);
+    }
+    const stack = raw.stack;
+    if (!STACK_ROOT[stack]) {
+        throw new Error(`Unknown stack in project-spec.json: ${raw.stack}`);
+    }
+    const root = dirname(specPath);
+    const databaseName = projectDbName(raw.projectName);
+    return {
+        root,
+        specPath,
+        spec: {
+            projectName: raw.projectName.trim(),
+            stack,
+            auth: raw.auth,
+            entities: raw.entities,
+            outputs: raw.outputs,
+        },
+        stackRoot: join(root, STACK_ROOT[stack]),
+        databaseName,
+        databaseUser: projectDbUser(raw.projectName),
+    };
+}

package/dist/util/exec.d.ts

@@ -0,0 +1,15 @@
+export type ExecResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+type RunOptions = {
+    sudo?: boolean;
+    input?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function run(cmd: string, args?: string[], options?: RunOptions): Promise<ExecResult>;
+export declare function commandExists(name: string): Promise<boolean>;
+export declare function runOrThrow(cmd: string, args?: string[], options?: RunOptions, hint?: string): Promise<string>;
+export {};

package/dist/util/exec.js

@@ -0,0 +1,45 @@
+import { spawn } from "node:child_process";
+export function run(cmd, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+        const executable = options.sudo ? "sudo" : cmd;
+        const executableArgs = options.sudo ? [cmd, ...args] : args;
+        const child = spawn(executable, executableArgs, {
+            cwd: options.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: options.env ?? process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        if (options.input) {
+            child.stdin.write(options.input);
+        }
+        child.stdin.end();
+    });
+}
+export async function commandExists(name) {
+    const result = await run("sh", ["-c", `command -v ${name} >/dev/null 2>&1; echo $?`]);
+    return result.stdout.trim() === "0";
+}
+export async function runOrThrow(cmd, args = [], options = {}, hint) {
+    const result = await run(cmd, args, options);
+    if (result.code !== 0) {
+        const detail = [result.stderr.trim(), result.stdout.trim()].filter(Boolean).join("\n");
+        const msg = hint
+            ? detail
+                ? `${hint}\n${detail}`
+                : hint
+            : `Command failed: ${cmd} ${args.join(" ")}\n${detail}`;
+        throw new Error(msg);
+    }
+    return result.stdout.trim();
+}

package/dist/util/log.d.ts

@@ -0,0 +1,6 @@
+export declare function info(message: string): void;
+export declare function success(message: string): void;
+export declare function warn(message: string): void;
+export declare function error(message: string): void;
+export declare function step(title: string): void;
+export declare function detail(message: string): void;

package/dist/util/log.js

@@ -0,0 +1,27 @@
+const colors = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+    bold: "\x1b[1m",
+};
+export function info(message) {
+    console.log(`${colors.cyan}→${colors.reset} ${message}`);
+}
+export function success(message) {
+    console.log(`${colors.green}✓${colors.reset} ${message}`);
+}
+export function warn(message) {
+    console.log(`${colors.yellow}!${colors.reset} ${message}`);
+}
+export function error(message) {
+    console.error(`${colors.red}✗${colors.reset} ${message}`);
+}
+export function step(title) {
+    console.log(`\n${colors.bold}${title}${colors.reset}`);
+}
+export function detail(message) {
+    console.log(`${colors.dim}  ${message}${colors.reset}`);
+}

package/dist/util/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function promptHidden(label: string): Promise<string>;
+export declare function promptText(label: string, defaultValue?: string): Promise<string>;