becky-cli 0.2.12

package/dist/commands/postgres-setup.js

@@ -0,0 +1,132 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { saveCredentials } from "../config/store.js";
+import { detectPlatform, linuxDistroLabel } from "../platform/detect.js";
+import { installPostgresUbuntu } from "../platform/linux-ubuntu.js";
+import { buildDatabaseUrl, ensureServiceRunning, getPostgresStatus, setupDatabaseUser, } from "../postgres/admin.js";
+import { projectDbName, projectDbUser, loadProject } from "../project/load.js";
+import { resolveDbIdentity } from "../project/identity.js";
+import { promptHidden, promptText } from "../util/prompt.js";
+import { detail, error, info, step, success, warn } from "../util/log.js";
+function loadSpecDefaults(specPath) {
+    const absolute = resolve(specPath);
+    const raw = readFileSync(absolute, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.projectName === "string" && parsed.projectName.trim()) {
+        return {
+            database: projectDbName(parsed.projectName),
+            user: projectDbUser(parsed.projectName),
+        };
+    }
+    return null;
+}
+async function confirm(message, yes) {
+    if (yes)
+        return true;
+    const answer = await promptText(`${message} (y/N)`, "n");
+    return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+function assertLinuxUbuntu(platform) {
+    if (platform.os !== "linux") {
+        throw new Error(`PostgreSQL setup is not implemented for ${platform.os} yet. Linux (Ubuntu) is supported first.`);
+    }
+    if (platform.linuxDistro !== "ubuntu" && platform.linuxDistro !== "debian") {
+        throw new Error(`PostgreSQL setup on ${linuxDistroLabel(platform)} is not supported yet. Use Ubuntu or Debian for now.`);
+    }
+}
+export async function runPostgresSetup(options) {
+    const platform = detectPlatform();
+    assertLinuxUbuntu(platform);
+    let database = options.database?.trim();
+    let user = options.user?.trim();
+    if (options.specPath) {
+        const fromSpec = loadSpecDefaults(options.specPath);
+        if (fromSpec) {
+            if (!database)
+                database = fromSpec.database;
+            if (!user)
+                user = fromSpec.user;
+            detail(`From project-spec: user=${fromSpec.user} database=${fromSpec.database}`);
+        }
+    }
+    database = database || "my_backend";
+    user = user || database;
+    // When wired to a generated project directory, apply the same identity rules as `up`
+    if (options.specPath) {
+        try {
+            const projectDir = resolve(options.specPath, "..");
+            const project = loadProject(projectDir);
+            const identity = resolveDbIdentity(project, { user: options.user, database: options.database });
+            user = identity.user;
+            database = identity.database;
+        }
+        catch {
+            /* spec-only setup without full project layout */
+        }
+    }
+    if (user === "app" && database !== "app") {
+        warn(`Replacing legacy DB user "app" with "${database}"`);
+        user = database;
+    }
+    step(`Becky — PostgreSQL setup (${linuxDistroLabel(platform)})`);
+    detail("This command may ask for your sudo password to install packages and manage Postgres.");
+    let status = await getPostgresStatus();
+    if (!status.installed) {
+        info("PostgreSQL is not installed");
+        const proceed = await confirm("Install latest PostgreSQL from PGDG?", options.yes);
+        if (!proceed) {
+            warn("Aborted — PostgreSQL was not installed");
+            return;
+        }
+        await installPostgresUbuntu(platform);
+        status = await getPostgresStatus();
+    }
+    else {
+        success(`PostgreSQL already installed${status.version ? `: ${status.version}` : ""}`);
+    }
+    await ensureServiceRunning();
+    let password = options.password;
+    if (!password) {
+        password = await promptHidden("Database password (input hidden)");
+        if (!password) {
+            throw new Error("A database password is required");
+        }
+    }
+    step("Create database user and database");
+    detail(`User: ${user}`);
+    detail(`Database: ${database}`);
+    await setupDatabaseUser({
+        user,
+        password,
+        database,
+    });
+    const url = buildDatabaseUrl(user, password, database, options.host, options.port);
+    saveCredentials({
+        host: options.host,
+        port: options.port,
+        user,
+        password,
+        database,
+        databaseUrl: url,
+    });
+    info("Saved credentials to ~/.becky/credentials.json");
+    step("Done");
+    success("PostgreSQL is ready for local development");
+    console.log("");
+    console.log("Connection details:");
+    console.log(`  Host:     ${options.host}`);
+    console.log(`  Port:     ${options.port}`);
+    console.log(`  User:     ${user}`);
+    console.log(`  Database: ${database}`);
+    console.log(`  URL:      ${url}`);
+    console.log("");
+    info("Wire a generated project with:");
+    console.log("  becky connect .");
+    console.log("  # or all-in-one:");
+    console.log("  becky up .");
+}
+export function printUnsupportedPlatform() {
+    const platform = detectPlatform();
+    error(`PostgreSQL setup is not available on ${platform.os} yet.`);
+    info("Linux (Ubuntu/Debian) is supported. macOS and Windows support is planned.");
+}

package/dist/commands/up.d.ts

@@ -0,0 +1,13 @@
+export type UpOptions = {
+    dir: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    host: string;
+    port: number;
+    yes: boolean;
+    skipInstall?: boolean;
+    skipMigrate?: boolean;
+    force?: boolean;
+};
+export declare function runUp(options: UpOptions): Promise<void>;

package/dist/commands/up.js

@@ -0,0 +1,58 @@
+import { runConnect } from "./connect.js";
+import { runMigrate } from "./migrate.js";
+import { runPostgresSetup } from "./postgres-setup.js";
+import { detail, info, step, success } from "../util/log.js";
+import { loadProject } from "../project/load.js";
+import { resolveDbIdentity } from "../project/identity.js";
+export async function runUp(options) {
+    const project = loadProject(options.dir);
+    const { user, database } = resolveDbIdentity(project, {
+        user: options.user,
+        database: options.database,
+    });
+    step(`Becky — up (${project.spec.projectName})`);
+    detail("Will: ensure Postgres → create DB → write .env → migrate");
+    detail(`Postgres role: ${user}`);
+    detail(`Database:      ${database} (local PostgreSQL on this machine)`);
+    if (!options.skipInstall) {
+        await runPostgresSetup({
+            user,
+            password: options.password,
+            database,
+            host: options.host,
+            port: options.port,
+            yes: options.yes,
+            specPath: project.specPath,
+        });
+    }
+    else {
+        info("Skipping postgres setup (--skip-install)");
+    }
+    await runConnect({
+        dir: options.dir,
+        user,
+        password: options.password,
+        database,
+        host: options.host,
+        port: options.port,
+        force: options.force ?? true,
+    });
+    if (!options.skipMigrate) {
+        await runMigrate({
+            dir: options.dir,
+            user,
+            password: options.password,
+            database,
+            host: options.host,
+            port: options.port,
+        });
+    }
+    else {
+        info("Skipping migrate (--skip-migrate)");
+    }
+    step("All set");
+    success("Postgres is ready and linked to this backend");
+    console.log("");
+    info("Start the API (from the generated project README), then:");
+    console.log("  becky doctor .");
+}

package/dist/config/store.d.ts

@@ -0,0 +1,19 @@
+export type StoredCredentials = {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    databaseUrl: string;
+    updatedAt: string;
+};
+export type BeckyConfig = {
+    openaiApiKey?: string;
+    defaultModel?: string;
+};
+export declare function getConfigDir(): string;
+export declare function saveCredentials(creds: Omit<StoredCredentials, "updatedAt">): void;
+export declare function loadCredentials(): StoredCredentials | null;
+export declare function loadConfig(): BeckyConfig;
+export declare function saveConfig(patch: Partial<BeckyConfig>): BeckyConfig;
+export declare function resolveOpenAiKey(cliFlag?: string): string | undefined;

package/dist/config/store.js

@@ -0,0 +1,65 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".becky");
+const CREDENTIALS_PATH = join(CONFIG_DIR, "credentials.json");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function secureWrite(path, content) {
+    ensureConfigDir();
+    writeFileSync(path, content, { encoding: "utf8", mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* best effort on platforms that ignore mode */
+    }
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export function saveCredentials(creds) {
+    const payload = {
+        ...creds,
+        updatedAt: new Date().toISOString(),
+    };
+    secureWrite(CREDENTIALS_PATH, `${JSON.stringify(payload, null, 2)}\n`);
+}
+export function loadCredentials() {
+    try {
+        if (!existsSync(CREDENTIALS_PATH))
+            return null;
+        return JSON.parse(readFileSync(CREDENTIALS_PATH, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_PATH))
+            return {};
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(patch) {
+    const next = { ...loadConfig(), ...patch };
+    secureWrite(CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`);
+    return next;
+}
+export function resolveOpenAiKey(cliFlag) {
+    const fromFlag = cliFlag?.trim();
+    if (fromFlag)
+        return fromFlag;
+    const fromEnv = process.env.OPENAI_API_KEY?.trim() || process.env.BECKY_OPENAI_KEY?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return loadConfig().openaiApiKey?.trim() || undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { runConfigSetKey, runConfigSetModel, runConfigShow } from "./commands/config.js";
+import { runConnect } from "./commands/connect.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runMigrate } from "./commands/migrate.js";
+import { runPostgresSetup } from "./commands/postgres-setup.js";
+import { runUp } from "./commands/up.js";
+import { detectPlatform } from "./platform/detect.js";
+const program = new Command();
+const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../package.json"), "utf8"));
+program
+    .name("becky")
+    .description("Becky CLI — Postgres setup, connect backends, migrate, and doctor")
+    .version(pkg.version);
+function fail(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`\nError: ${message}`);
+    process.exit(1);
+}
+const postgres = program.command("postgres").description("PostgreSQL utilities");
+postgres
+    .command("setup")
+    .description("Install PostgreSQL (Ubuntu/Debian) and create a local user + database")
+    .option("-u, --user <name>", "Database user (defaults to project/database name)")
+    .option("-p, --password <password>", "Database password (prompted if omitted)")
+    .option("-d, --database <name>", "Database name (defaults from --spec or my_backend)")
+    .option("--host <host>", "Database host", "localhost")
+    .option("--port <port>", "Database port", "5432")
+    .option("--spec <path>", "project-spec.json — derive user + database from project name")
+    .option("-y, --yes", "Skip install confirmation prompts", false)
+    .action(async (opts) => {
+    try {
+        await runPostgresSetup({
+            user: opts.user,
+            password: opts.password,
+            database: opts.database,
+            host: opts.host,
+            port: Number(opts.port),
+            yes: Boolean(opts.yes),
+            specPath: opts.spec,
+        });
+    }
+    catch (err) {
+        if (detectPlatform().os !== "linux") {
+            console.error("\nTip: Linux (Ubuntu/Debian) is supported first.");
+        }
+        fail(err);
+    }
+});
+postgres
+    .command("status")
+    .description("Check whether PostgreSQL is installed and running")
+    .action(async () => {
+    const { getPostgresStatus } = await import("./postgres/admin.js");
+    const { detectPlatform, linuxDistroLabel } = await import("./platform/detect.js");
+    const platform = detectPlatform();
+    const status = await getPostgresStatus();
+    console.log(`Platform: ${platform.os}${platform.linuxDistro ? ` (${linuxDistroLabel(platform)})` : ""}`);
+    console.log(`Installed: ${status.installed ? "yes" : "no"}`);
+    if (status.version)
+        console.log(`Version:   ${status.version}`);
+    console.log(`Service:   ${status.serviceActive ? "running" : "not running"}`);
+});
+program
+    .command("connect [dir]")
+    .description("Write .env from credentials / project-spec.json and test the DB connection")
+    .option("-u, --user <name>", "Database user")
+    .option("-p, --password <password>", "Database password")
+    .option("-d, --database <name>", "Database name")
+    .option("--host <host>", "Database host")
+    .option("--port <port>", "Database port")
+    .option("-f, --force", "Overwrite existing .env", false)
+    .option("--skip-test", "Skip connection test", false)
+    .action(async (dir, opts) => {
+    try {
+        await runConnect({
+            dir: dir || ".",
+            user: opts.user,
+            password: opts.password,
+            database: opts.database,
+            host: opts.host,
+            port: opts.port != null ? Number(opts.port) : undefined,
+            force: Boolean(opts.force),
+            skipTest: Boolean(opts.skipTest),
+        });
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+program
+    .command("migrate [dir]")
+    .description("Run stack migrations (Prisma / Alembic / scripts)")
+    .option("-u, --user <name>", "Database user")
+    .option("-p, --password <password>", "Database password")
+    .option("-d, --database <name>", "Database name")
+    .option("--host <host>", "Database host")
+    .option("--port <port>", "Database port")
+    .action(async (dir, opts) => {
+    try {
+        await runMigrate({
+            dir: dir || ".",
+            user: opts.user,
+            password: opts.password,
+            database: opts.database,
+            host: opts.host,
+            port: opts.port != null ? Number(opts.port) : undefined,
+        });
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+program
+    .command("up [dir]")
+    .description("Postgres setup + connect + migrate for a generated project")
+    .option("-u, --user <name>", "Database user (defaults to project name slug)")
+    .option("-p, --password <password>", "Database password (prompted if omitted)")
+    .option("-d, --database <name>", "Database name (defaults from project-spec.json)")
+    .option("--host <host>", "Database host", "localhost")
+    .option("--port <port>", "Database port", "5432")
+    .option("-y, --yes", "Skip install confirmation prompts", false)
+    .option("--skip-install", "Skip postgres install/setup", false)
+    .option("--skip-migrate", "Skip migrations", false)
+    .option("-f, --force", "Overwrite .env", true)
+    .action(async (dir, opts) => {
+    try {
+        await runUp({
+            dir: dir || ".",
+            user: opts.user,
+            password: opts.password,
+            database: opts.database,
+            host: opts.host,
+            port: Number(opts.port),
+            yes: Boolean(opts.yes),
+            skipInstall: Boolean(opts.skipInstall),
+            skipMigrate: Boolean(opts.skipMigrate),
+            force: opts.force !== false,
+        });
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+program
+    .command("doctor [dir]")
+    .description("Health-check Postgres + .env + API; use OpenAI when something fails")
+    .option("--api-key <key>", "OpenAI API key (or OPENAI_API_KEY / becky config)")
+    .option("--model <model>", "OpenAI model", "gpt-4o-mini")
+    .option("--skip-ai", "Only run checks — no OpenAI diagnosis", false)
+    .action(async (dir, opts) => {
+    try {
+        await runDoctor({
+            dir: dir || ".",
+            apiKey: opts.apiKey,
+            model: opts.model,
+            noAi: Boolean(opts.skipAi),
+        });
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+const config = program.command("config").description("CLI configuration (OpenAI key, model)");
+config
+    .command("set-key [key]")
+    .description("Save OpenAI API key to ~/.becky/config.json")
+    .action(async (key) => {
+    try {
+        await runConfigSetKey(key);
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+config
+    .command("set-model <model>")
+    .description("Set default OpenAI model (e.g. gpt-4o-mini)")
+    .action((model) => {
+    try {
+        runConfigSetModel(model);
+    }
+    catch (err) {
+        fail(err);
+    }
+});
+config
+    .command("show")
+    .description("Show current CLI config (key is masked)")
+    .action(() => {
+    runConfigShow();
+});
+program.parseAsync(process.argv);

package/dist/platform/detect.d.ts

@@ -0,0 +1,10 @@
+export type OsFamily = "linux" | "darwin" | "win32" | "unsupported";
+export type LinuxDistro = "ubuntu" | "debian" | "other";
+export type PlatformInfo = {
+    os: OsFamily;
+    linuxDistro?: LinuxDistro;
+    id?: string;
+    versionId?: string;
+};
+export declare function detectPlatform(): PlatformInfo;
+export declare function linuxDistroLabel(info: PlatformInfo): string;

package/dist/platform/detect.js

@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+function parseOsRelease(content) {
+    const values = {};
+    for (const line of content.split("\n")) {
+        const match = line.match(/^([A-Z0-9_]+)=(.+)$/);
+        if (!match)
+            continue;
+        values[match[1]] = match[2].replace(/^"|"$/g, "");
+    }
+    return values;
+}
+export function detectPlatform() {
+    const platform = process.platform;
+    if (platform === "linux") {
+        try {
+            const release = parseOsRelease(readFileSync("/etc/os-release", "utf8"));
+            const id = release.ID?.toLowerCase();
+            const idLike = release.ID_LIKE?.toLowerCase() ?? "";
+            let linuxDistro = "other";
+            if (id === "ubuntu")
+                linuxDistro = "ubuntu";
+            else if (id === "debian" || idLike.includes("debian"))
+                linuxDistro = "debian";
+            return {
+                os: "linux",
+                linuxDistro,
+                id,
+                versionId: release.VERSION_ID,
+            };
+        }
+        catch {
+            return { os: "linux", linuxDistro: "other" };
+        }
+    }
+    if (platform === "darwin")
+        return { os: "darwin" };
+    if (platform === "win32")
+        return { os: "win32" };
+    return { os: "unsupported" };
+}
+export function linuxDistroLabel(info) {
+    if (info.id === "ubuntu")
+        return `Ubuntu ${info.versionId ?? ""}`.trim();
+    if (info.id === "debian")
+        return `Debian ${info.versionId ?? ""}`.trim();
+    return info.id ?? "Linux";
+}

package/dist/platform/linux-ubuntu.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformInfo } from "../platform/detect.js";
+export declare function installPostgresUbuntu(platform: PlatformInfo): Promise<void>;

package/dist/platform/linux-ubuntu.js

@@ -0,0 +1,48 @@
+import { commandExists, runOrThrow } from "../util/exec.js";
+import { detail, info, step, success } from "../util/log.js";
+const PGDG_LIST = "/etc/apt/sources.list.d/pgdg.list";
+const PGDG_KEYRING = "/usr/share/keyrings/postgresql.gpg";
+async function hasPgdgRepo() {
+    try {
+        const { readFileSync } = await import("node:fs");
+        readFileSync(PGDG_LIST, "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function addPgdgRepo(codename) {
+    info("Adding PostgreSQL APT (PGDG) repository for latest packages");
+    await runOrThrow("sudo", ["apt-get", "update"], {}, "apt-get update failed");
+    await runOrThrow("sudo", ["apt-get", "install", "-y", "ca-certificates", "curl", "gnupg", "lsb-release"], {}, "Failed to install apt prerequisites");
+    await runOrThrow("sudo", [
+        "bash",
+        "-c",
+        `curl -fsSL https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor -o ${PGDG_KEYRING}`,
+    ], {}, "Failed to add PostgreSQL signing key");
+    const listLine = `deb [signed-by=${PGDG_KEYRING}] http://apt.postgresql.org/pub/repos/apt ${codename}-pgdg main`;
+    await runOrThrow("sudo", ["bash", "-c", `echo ${JSON.stringify(listLine)} > ${PGDG_LIST}`], {}, "Failed to write PGDG apt source");
+    await runOrThrow("sudo", ["apt-get", "update"], {}, "apt-get update failed after adding PGDG");
+    success("PGDG repository configured");
+}
+export async function installPostgresUbuntu(platform) {
+    step("Install PostgreSQL (Ubuntu/Debian)");
+    if (!(await commandExists("apt-get"))) {
+        throw new Error("apt-get not found. This installer currently supports Ubuntu/Debian only.");
+    }
+    const codename = await runOrThrow("lsb_release", ["-cs"], {}, "Could not detect Ubuntu codename (lsb_release)");
+    detail(`Detected codename: ${codename}`);
+    if (!(await hasPgdgRepo())) {
+        await addPgdgRepo(codename);
+    }
+    else {
+        detail("PGDG repository already configured");
+    }
+    info("Installing PostgreSQL packages (latest from PGDG)");
+    await runOrThrow("sudo", ["apt-get", "install", "-y", "postgresql", "postgresql-contrib"], {}, "Failed to install PostgreSQL");
+    info("Enabling PostgreSQL service");
+    await runOrThrow("sudo", ["systemctl", "enable", "--now", "postgresql"], {}, "Failed to enable PostgreSQL service");
+    const version = await runOrThrow("psql", ["--version"], {}, "PostgreSQL installed but psql not found");
+    success(version);
+}

package/dist/postgres/admin.d.ts

@@ -0,0 +1,19 @@
+export type PostgresStatus = {
+    installed: boolean;
+    version?: string;
+    serviceActive: boolean;
+};
+export declare function getPostgresStatus(): Promise<PostgresStatus>;
+export declare function sqlLiteral(value: string): string;
+export declare function postgresQuery(sql: string): Promise<string>;
+export declare function roleExists(name: string): Promise<boolean>;
+export declare function databaseExists(name: string): Promise<boolean>;
+export type SetupDatabaseOptions = {
+    user: string;
+    password: string;
+    database: string;
+    grantPrivileges?: boolean;
+};
+export declare function setupDatabaseUser(options: SetupDatabaseOptions): Promise<void>;
+export declare function buildDatabaseUrl(user: string, password: string, database: string, host?: string, port?: number): string;
+export declare function ensureServiceRunning(): Promise<void>;