ts-prorm-orm 1.1.0 → 1.2.0

package/dist/cli/commands/pull.js

@@ -0,0 +1,306 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// `pull` commands: pull credentials/config from the dashboard into the local
+// project. The dashboard brokers the AWS Secrets Manager vault + S3, so these
+// commands never touch AWS directly — they just fetch already-resolved
+// credentials and materialize them as dotenv files.
+const fs = __importStar(require("fs"));
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const io_1 = require("../io");
+// ─── Local helpers ────────────────────────────────────────────────────────────
+/**
+ * Write KEY=VALUE lines to a dotenv `file`, merging with any existing contents:
+ * keys already present are replaced in place, new keys are appended. Everything
+ * else in the file (comments, blank lines, unrelated keys) is preserved.
+ */
+function writeEnv(file, vars) {
+    // Credentials are about to land on disk — warn if the target isn't gitignored.
+    (0, io_1.warnIfTracked)(file);
+    const pending = new Map(Object.entries(vars));
+    let existing = '';
+    try {
+        existing = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        existing = '';
+    }
+    const lines = existing.length ? existing.split(/\r?\n/) : [];
+    // Drop a single trailing empty element from a final newline so we don't grow
+    // the file with blank lines on every write.
+    if (lines.length && lines[lines.length - 1] === '')
+        lines.pop();
+    const out2 = [];
+    for (const line of lines) {
+        const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+        const key = m?.[1];
+        if (key && pending.has(key)) {
+            out2.push(`${key}=${pending.get(key)}`);
+            pending.delete(key);
+        }
+        else {
+            out2.push(line);
+        }
+    }
+    for (const [key, value] of pending) {
+        out2.push(`${key}=${value}`);
+    }
+    fs.writeFileSync(file, out2.join('\n') + '\n');
+}
+/** Build a postgres connection URL from a resolved secret payload. */
+function buildPostgresUrl(data) {
+    if (data.connectionString)
+        return data.connectionString;
+    const host = data.host ?? 'localhost';
+    const port = data.port ?? 5432;
+    const database = data.database ?? 'postgres';
+    const user = data.username ?? '';
+    const pass = data.password ?? '';
+    const auth = user
+        ? `${encodeURIComponent(user)}${pass ? `:${encodeURIComponent(pass)}` : ''}@`
+        : '';
+    return `postgres://${auth}${host}:${port}/${database}`;
+}
+/** Mask a secret value for display, keeping just enough to be recognizable. */
+function mask(value) {
+    const s = value == null ? '' : String(value);
+    if (!s)
+        return '';
+    if (s.length <= 4)
+        return '****';
+    return `${s.slice(0, 2)}${'*'.repeat(Math.min(8, s.length - 4))}${s.slice(-2)}`;
+}
+// ─── pull creds ────────────────────────────────────────────────────────────────
+const pullCreds = (0, framework_1.defineCommand)({
+    name: 'pull creds',
+    description: 'Pull the raw credentials for a connection from the vault.',
+    group: 'Pull',
+    positionals: [
+        { name: 'connection', description: 'Connection id or name', required: true },
+    ],
+    flags: [
+        { name: 'json', type: 'boolean', description: 'Output raw JSON' },
+        { name: 'out', type: 'string', description: 'Write credentials to a dotenv file instead of stdout' },
+    ],
+    examples: [
+        'orm-cli pull creds my-db',
+        'orm-cli pull creds my-db --json',
+        'orm-cli pull creds my-db --out .env.local',
+    ],
+    async run(ctx) {
+        (0, cloud_1.requireAuth)();
+        const connection = ctx.positionals[0];
+        const data = await (0, cloud_1.api)('/api/cli/secrets/pull', { query: { connection } });
+        if (ctx.flags.json) {
+            framework_1.out.json(data);
+            return;
+        }
+        if (typeof ctx.flags.out === 'string') {
+            const file = ctx.flags.out;
+            const vars = {};
+            for (const [k, v] of Object.entries(data)) {
+                if (v == null)
+                    continue;
+                vars[k.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase()] = String(v);
+            }
+            writeEnv(file, vars);
+            framework_1.out.success(`Wrote credentials for ${connection} to ${file}`);
+            return;
+        }
+        const rows = Object.entries(data)
+            .filter(([, v]) => v != null)
+            .map(([field, value]) => ({
+            field,
+            value: /password|secret|token|key/i.test(field) ? mask(value) : String(value),
+        }));
+        framework_1.out.table(rows);
+    },
+});
+// ─── pull db ───────────────────────────────────────────────────────────────────
+const pullDb = (0, framework_1.defineCommand)({
+    name: 'pull db',
+    description: 'Pull a database connection and write its URL to a dotenv file.',
+    group: 'Pull',
+    positionals: [
+        { name: 'connection', description: 'Connection id or name', required: true },
+    ],
+    flags: [
+        { name: 'out', type: 'string', description: 'Dotenv file to write', default: '.env' },
+        { name: 'var', type: 'string', description: 'Env var name for the URL', default: 'DATABASE_URL' },
+        { name: 'stdout', type: 'boolean', description: 'Print the URL to stdout instead of writing a file.' },
+    ],
+    examples: [
+        'orm-cli pull db my-db',
+        'orm-cli pull db my-db --var PG_URL --out .env.local',
+        'orm-cli pull db my-db --stdout',
+    ],
+    async run(ctx) {
+        (0, cloud_1.requireAuth)();
+        const connection = ctx.positionals[0];
+        const file = String(ctx.flags.out);
+        const varName = String(ctx.flags.var);
+        const data = await (0, cloud_1.api)('/api/cli/secrets/pull', { query: { connection } });
+        const url = buildPostgresUrl(data);
+        if (ctx.flags.stdout) {
+            framework_1.out.info(url);
+            return;
+        }
+        writeEnv(file, { [varName]: url });
+        framework_1.out.success(`Wrote ${varName} to ${file}`);
+    },
+});
+const pullBucket = (0, framework_1.defineCommand)({
+    name: 'pull bucket',
+    description: 'Pull S3 bucket access credentials into a dotenv file.',
+    group: 'Pull',
+    positionals: [
+        { name: 'name', description: 'Bucket name', required: true },
+    ],
+    flags: [
+        { name: 'out', type: 'string', description: 'Dotenv file to write', default: '.env' },
+        { name: 'stdout', type: 'boolean', description: 'Print KEY=VALUE lines to stdout instead of writing a file.' },
+    ],
+    examples: [
+        'orm-cli pull bucket my-uploads',
+        'orm-cli pull bucket my-uploads --out .env.local',
+        'orm-cli pull bucket my-uploads --stdout',
+    ],
+    async run(ctx) {
+        (0, cloud_1.requireAuth)();
+        const name = ctx.positionals[0];
+        const file = String(ctx.flags.out);
+        const data = await (0, cloud_1.api)('/api/cli/storage/access', { query: { bucket: name } });
+        const vars = {
+            S3_BUCKET: data.bucket,
+            AWS_REGION: data.region,
+        };
+        if (data.accessKeyId)
+            vars.AWS_ACCESS_KEY_ID = data.accessKeyId;
+        if (data.secretAccessKey)
+            vars.AWS_SECRET_ACCESS_KEY = data.secretAccessKey;
+        if (data.endpoint)
+            vars.S3_ENDPOINT = data.endpoint;
+        if (ctx.flags.stdout) {
+            for (const [k, v] of Object.entries(vars))
+                framework_1.out.info(`${k}=${v}`);
+            return;
+        }
+        writeEnv(file, vars);
+        framework_1.out.success(`Wrote bucket access for ${data.bucket} to ${file}`);
+    },
+});
+const pullSecrets = (0, framework_1.defineCommand)({
+    name: 'pull secrets',
+    description: 'Pull all vault secrets for a team into a dotenv file.',
+    group: 'Pull',
+    flags: [
+        { name: 'team', type: 'string', description: 'Team id or slug (defaults to current context)' },
+        { name: 'out', type: 'string', description: 'Dotenv file to write', default: '.env' },
+        { name: 'json', type: 'boolean', description: 'Output raw JSON instead of writing a file' },
+    ],
+    examples: [
+        'orm-cli pull secrets',
+        'orm-cli pull secrets --team acme --out .env.local',
+        'orm-cli pull secrets --json',
+    ],
+    async run(ctx) {
+        (0, cloud_1.requireAuth)();
+        const team = typeof ctx.flags.team === 'string' ? ctx.flags.team : undefined;
+        const file = String(ctx.flags.out);
+        const data = await (0, cloud_1.api)('/api/cli/secrets', { query: { team } });
+        if (ctx.flags.json) {
+            framework_1.out.json(data);
+            return;
+        }
+        const vars = {};
+        for (const s of data.secrets ?? [])
+            vars[s.name] = s.value;
+        writeEnv(file, vars);
+        framework_1.out.success(`Wrote ${Object.keys(vars).length} secret(s) to ${file}`);
+    },
+});
+// ─── pull env ──────────────────────────────────────────────────────────────────
+const pullEnv = (0, framework_1.defineCommand)({
+    name: 'pull env',
+    description: 'Pull the database URL, bucket access, and secrets for the current context.',
+    group: 'Pull',
+    flags: [
+        { name: 'out', type: 'string', description: 'Dotenv file to write', default: '.env' },
+        { name: 'team', type: 'string', description: 'Team id or slug (defaults to current context)' },
+        { name: 'connection', type: 'string', description: 'Database connection name (defaults to the team).' },
+        { name: 'bucket', type: 'string', description: 'Bucket name (defaults to the team).' },
+        { name: 'skip-db', type: 'boolean', description: 'Skip the database URL.' },
+        { name: 'skip-bucket', type: 'boolean', description: 'Skip bucket access.' },
+    ],
+    examples: [
+        'orm-cli pull env',
+        'orm-cli pull env --team acme --out .env.local',
+        'orm-cli pull env --connection prod-db --bucket uploads',
+    ],
+    async run(ctx) {
+        (0, cloud_1.requireAuth)();
+        const file = String(ctx.flags.out);
+        const team = typeof ctx.flags.team === 'string' ? ctx.flags.team : (0, cloud_1.loadConfig)().teamSlug;
+        // The default connection/bucket are named after the team, but that is only a
+        // convention — allow explicit overrides so it works when they differ.
+        const connection = typeof ctx.flags.connection === 'string' && ctx.flags.connection ? ctx.flags.connection : team;
+        const bucketName = typeof ctx.flags.bucket === 'string' && ctx.flags.bucket ? ctx.flags.bucket : team;
+        const merged = {};
+        if (ctx.flags['skip-db'] !== true) {
+            const db = await (0, cloud_1.api)('/api/cli/secrets/pull', { query: { connection } });
+            merged.DATABASE_URL = buildPostgresUrl(db);
+        }
+        if (ctx.flags['skip-bucket'] !== true) {
+            const bucket = await (0, cloud_1.api)('/api/cli/storage/access', { query: { bucket: bucketName } });
+            merged.S3_BUCKET = bucket.bucket;
+            merged.AWS_REGION = bucket.region;
+            if (bucket.accessKeyId)
+                merged.AWS_ACCESS_KEY_ID = bucket.accessKeyId;
+            if (bucket.secretAccessKey)
+                merged.AWS_SECRET_ACCESS_KEY = bucket.secretAccessKey;
+            if (bucket.endpoint)
+                merged.S3_ENDPOINT = bucket.endpoint;
+        }
+        // Team secrets.
+        const secrets = await (0, cloud_1.api)('/api/cli/secrets', { query: { team } });
+        for (const s of secrets.secrets ?? [])
+            merged[s.name] = s.value;
+        writeEnv(file, merged);
+        framework_1.out.success(`Wrote ${Object.keys(merged).length} entr(ies) to ${file}`);
+    },
+});
+exports.commands = [pullCreds, pullDb, pullBucket, pullSecrets, pullEnv];

package/dist/cli/commands/runners.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];

package/dist/cli/commands/runners.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+// Runners command module for the prorm CLI. A runner is a single execution of a
+// code snippet inside a sandbox: it carries a sandboxId, a status, the docker
+// image it ran on, and timing/exit metadata. These commands start runners, list
+// them, tail their logs, and stop them against the dashboard API.
+const framework_1 = require("../framework");
+const cloud_1 = require("../cloud");
+const io_1 = require("../io");
+/** Statuses that mean the runner has finished and will not transition again. */
+const TERMINAL = ['success', 'failed', 'stopped'];
+/** Small sleep helper. */
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Fetch a runner's logs, resolving a presigned logsUrl via the shared client. */
+async function fetchLogs(id) {
+    const res = await (0, cloud_1.api)('/api/dashboard/runners/' + id + '/logs');
+    if (res.logsUrl) {
+        // Route the presigned fetch through the shared client so it inherits the
+        // timeout/retry/proxy behavior instead of a bare fetch that can hang.
+        const text = await (0, cloud_1.api)(res.logsUrl, { auth: false });
+        return typeof text === 'string' ? text : JSON.stringify(text);
+    }
+    return res.logs ?? '';
+}
+const run = (0, framework_1.defineCommand)({
+    name: 'run',
+    description: 'Start a runner for a code snippet in a sandbox.',
+    group: 'Runners',
+    positionals: [{ name: 'codeId', description: 'ID of the code snippet to run.', required: true }],
+    flags: [
+        { name: 'image', type: 'string', description: 'Docker image to run in.' },
+        { name: 'dialect', type: 'string', description: 'Database dialect to target.' },
+        { name: 'wait', alias: 'w', type: 'boolean', description: 'Poll until the runner finishes.' },
+        { name: 'wait-timeout', type: 'number', description: 'Seconds to wait when --wait is set.', default: 120 },
+    ],
+    examples: [
+        'orm-cli run code_123',
+        'orm-cli run code_123 --image node:20 --dialect postgres',
+        'orm-cli run code_123 --wait --wait-timeout 600',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const codeId = ctx.positionals[0];
+        const body = { codeId };
+        if (typeof ctx.flags.image === 'string' && ctx.flags.image)
+            body.image = ctx.flags.image;
+        if (typeof ctx.flags.dialect === 'string' && ctx.flags.dialect)
+            body.dialect = ctx.flags.dialect;
+        const started = await (0, cloud_1.api)('/api/dashboard/runners', { method: 'POST', body });
+        framework_1.out.success(`Started runner ${started.id} (${started.status})`);
+        if (started.sandboxId)
+            framework_1.out.dim(`sandbox: ${started.sandboxId}`);
+        if (!ctx.flags.wait)
+            return 0;
+        const waitSec = typeof ctx.flags['wait-timeout'] === 'number' ? ctx.flags['wait-timeout'] : 120;
+        let last = started.status;
+        const deadline = Date.now() + waitSec * 1000;
+        let runner = { id: started.id, status: started.status };
+        const spin = (0, io_1.spinner)(`Running… (${runner.status})`);
+        try {
+            while (!TERMINAL.includes(runner.status) && Date.now() < deadline) {
+                await sleep(2000);
+                runner = await (0, cloud_1.api)('/api/dashboard/runners/' + started.id);
+                if (runner.status !== last) {
+                    framework_1.out.info(`→ ${runner.status}`);
+                    last = runner.status;
+                }
+                spin.update(`Running… (${runner.status})`);
+            }
+        }
+        finally {
+            spin.stop();
+        }
+        if (!TERMINAL.includes(runner.status)) {
+            // Don't leave a sandbox running (and billing) after we give up waiting —
+            // stop it so --wait can't silently leak compute. Use a distinct exit code
+            // so scripts can tell a timeout apart from a runner failure.
+            framework_1.out.warn(`Timed out after ${waitSec}s waiting for runner ${started.id} (still ${runner.status}); stopping it.`);
+            try {
+                await (0, cloud_1.api)('/api/dashboard/runners/' + started.id + '/stop', { method: 'POST' });
+                framework_1.out.dim(`Stopped ${started.id}.`);
+            }
+            catch (err) {
+                framework_1.out.warn(`Could not stop ${started.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return framework_1.EXIT.TIMEOUT;
+        }
+        if (runner.exitCode !== undefined)
+            framework_1.out.info(`exitCode: ${runner.exitCode}`);
+        if (runner.durationMs !== undefined)
+            framework_1.out.info(`duration: ${runner.durationMs}ms`);
+        return runner.status === 'success' ? 0 : 1;
+    },
+});
+const runsList = (0, framework_1.defineCommand)({
+    name: 'runs list',
+    description: 'List recent runners.',
+    group: 'Runners',
+    aliases: ['runs ls'],
+    flags: [
+        { name: 'json', type: 'boolean', description: 'Output raw JSON.' },
+        {
+            name: 'status',
+            type: 'string',
+            description: 'Filter by status.',
+            choices: ['queued', 'running', 'success', 'failed', 'stopped'],
+        },
+        { name: 'limit', type: 'number', description: 'Maximum number of runners to return.', default: 20 },
+        { name: 'offset', type: 'number', description: 'Number of runners to skip (pagination).', default: 0 },
+    ],
+    examples: [
+        'orm-cli runs list',
+        'orm-cli runs list --status running --limit 50',
+        'orm-cli runs list --limit 20 --offset 40',
+        'orm-cli runs list --json',
+    ],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const query = {};
+        if (typeof ctx.flags.status === 'string')
+            query.status = ctx.flags.status;
+        if (typeof ctx.flags.limit === 'number')
+            query.limit = ctx.flags.limit;
+        if (typeof ctx.flags.offset === 'number' && ctx.flags.offset > 0)
+            query.offset = ctx.flags.offset;
+        const { runners, pagination } = await (0, cloud_1.api)('/api/dashboard/runners', { query });
+        if (ctx.flags.json) {
+            framework_1.out.json(runners);
+            return;
+        }
+        framework_1.out.table(runners.map((r) => ({
+            id: r.id,
+            codeId: r.codeId ?? '',
+            status: r.status,
+            image: r.image ?? '',
+            durationMs: r.durationMs ?? '',
+            createdAt: r.createdAt ?? '',
+        })));
+        if (pagination && pagination.hasMore) {
+            framework_1.out.dim(`Showing ${pagination.offset + 1}-${pagination.offset + runners.length} of ${pagination.total}. ` +
+                `Next: --offset ${pagination.offset + pagination.limit}`);
+        }
+    },
+});
+const runGet = (0, framework_1.defineCommand)({
+    name: 'runs get',
+    description: "Show a single runner's full metadata.",
+    group: 'Runners',
+    positionals: [{ name: 'id', description: 'Runner ID.', required: true }],
+    flags: [{ name: 'json', type: 'boolean', description: 'Output raw JSON.' }],
+    examples: ['orm-cli runs get runner_123', 'orm-cli runs get runner_123 --json'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const runner = await (0, cloud_1.api)('/api/dashboard/runners/' + ctx.positionals[0]);
+        if (ctx.flags.json) {
+            framework_1.out.json(runner);
+            return;
+        }
+        framework_1.out.table(Object.entries(runner).map(([field, value]) => ({ field, value: value ?? '' })));
+    },
+});
+const runLogs = (0, framework_1.defineCommand)({
+    name: 'run logs',
+    description: 'Show (or follow) the logs for a runner.',
+    group: 'Runners',
+    positionals: [{ name: 'id', description: 'Runner ID.', required: true }],
+    flags: [
+        { name: 'json', type: 'boolean', description: 'Output raw JSON.' },
+        { name: 'follow', alias: 'f', type: 'boolean', description: 'Stream new log output until the runner finishes.' },
+    ],
+    examples: ['orm-cli run logs runner_123', 'orm-cli run logs runner_123 -f'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const id = ctx.positionals[0];
+        if (ctx.flags.follow && !ctx.flags.json) {
+            // Tail: poll logs + status, printing only the newly-appended tail, until
+            // the runner reaches a terminal state.
+            let printed = 0;
+            for (;;) {
+                const text = await fetchLogs(id);
+                if (text.length > printed) {
+                    process.stdout.write(text.slice(printed));
+                    printed = text.length;
+                }
+                const runner = await (0, cloud_1.api)('/api/dashboard/runners/' + id);
+                if (TERMINAL.includes(runner.status)) {
+                    if (printed === 0 || !text.endsWith('\n'))
+                        process.stdout.write('\n');
+                    framework_1.out.dim(`runner ${runner.status}`);
+                    return runner.status === 'success' ? 0 : 1;
+                }
+                await sleep(2000);
+            }
+        }
+        if (ctx.flags.json) {
+            const res = await (0, cloud_1.api)('/api/dashboard/runners/' + id + '/logs');
+            framework_1.out.json(res);
+            return 0;
+        }
+        framework_1.out.info(await fetchLogs(id));
+        return 0;
+    },
+});
+const runStop = (0, framework_1.defineCommand)({
+    name: 'run stop',
+    description: 'Stop a running runner.',
+    group: 'Runners',
+    positionals: [{ name: 'id', description: 'Runner ID.', required: true }],
+    examples: ['orm-cli run stop runner_123'],
+    run: async (ctx) => {
+        (0, cloud_1.requireAuth)();
+        const id = ctx.positionals[0];
+        await (0, cloud_1.api)('/api/dashboard/runners/' + id + '/stop', { method: 'POST' });
+        framework_1.out.success(`Stopped ${id}`);
+    },
+});
+exports.commands = [run, runsList, runGet, runLogs, runStop];

package/dist/cli/commands/scaffold.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from '../framework';
+export declare const commands: Command[];