runcloud 0.1.2 → 0.1.3

package/dist/commands/environment.js

@@ -0,0 +1,290 @@
+import { createInterface } from 'node:readline/promises';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { runEnvironmentDatabaseShell } from '../environmentShell.js';
+import { clearEnvironmentSelection, readEnvironmentSelection, requireCredentials, requireEnvironmentSelection, resolveProject, writeEnvironmentSelection, } from '../config.js';
+const POLL_INTERVAL_MS = 2_000;
+const POLL_TIMEOUT_MS = 10 * 60 * 1_000;
+function client() {
+    const credentials = requireCredentials();
+    return new ApiClient(credentials.apiUrl, credentials.token);
+}
+async function projectEnvironments(api, projectId) {
+    const response = await api.get(`/projects/${encodeURIComponent(projectId)}/environments`);
+    return response.environments;
+}
+function resolveEnvironment(rows, value) {
+    const matches = rows.filter((row) => row.id === value || row.name === value);
+    if (matches.length === 0)
+        throw new Error(`Environment not found: ${value}`);
+    if (matches.length > 1)
+        throw new Error(`Environment name is ambiguous; use its ID: ${value}`);
+    return matches[0];
+}
+export function resolveNamedResource(rows, value, kind) {
+    if (!value) {
+        if (rows.length === 1)
+            return rows[0];
+        if (rows.length === 0)
+            throw new Error(`This environment has no ${kind}s.`);
+        throw new Error(`This environment has multiple ${kind}s; specify a name or ID.`);
+    }
+    const matches = rows.filter((row) => row.id === value || row.name === value);
+    if (matches.length === 0)
+        throw new Error(`${kind} not found: ${value}`);
+    if (matches.length > 1)
+        throw new Error(`${kind} name is ambiguous; use its ID: ${value}`);
+    return matches[0];
+}
+export function formatEnvironmentLog(entry) {
+    return `${entry.timestamp || '-'}  ${entry.level.padEnd(5)}  ${entry.message}`;
+}
+export function resolveSourceEnvironment(rows, value) {
+    const source = value
+        ? resolveEnvironment(rows, value)
+        : (() => {
+            const production = rows.filter((row) => row.class === 'production');
+            if (production.length === 0)
+                throw new Error('Production environment is not ready yet.');
+            if (production.length > 1)
+                throw new Error('Production environment is ambiguous; use --from <id>.');
+            return production[0];
+        })();
+    if (source.class !== 'production') {
+        throw new Error('--from must identify the production environment');
+    }
+    if (source.status !== 'ready') {
+        throw new Error(`Production environment is not ready yet (${source.stage}).`);
+    }
+    return source;
+}
+async function waitForEnvironment(api, environmentId, terminal) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    for (;;) {
+        const environment = await api.get(`/environments/${encodeURIComponent(environmentId)}`);
+        if (terminal.has(environment.status))
+            return environment;
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out waiting for environment ${environment.name} (${environment.stage}).`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+}
+function printEnvironment(environment) {
+    console.log(`${environment.name}  ${environment.id}  ${environment.status}  ${environment.region}`);
+    for (const database of environment.databases) {
+        console.log(`database  ${database.name}  ${database.status}`);
+    }
+    for (const service of environment.services) {
+        console.log(`service   ${service.name}  ${service.status}`);
+    }
+    for (const route of environment.routes) {
+        console.log(`route     ${route.status}  https://${route.hostname}`);
+    }
+    if (environment.lastError)
+        console.log(`error     ${environment.lastError}`);
+}
+async function confirmDelete(name) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`Delete environment ${name}? Type its name to confirm: `);
+        return answer === name;
+    }
+    finally {
+        rl.close();
+    }
+}
+export function registerEnvironment(program) {
+    const env = program.command('env').description('Create, select, and operate environments');
+    env.command('list')
+        .description('List environments for the linked project')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = readEnvironmentSelection(process.cwd())?.id;
+            for (const row of await projectEnvironments(client(), projectId)) {
+                console.log(`${row.id === selected ? '*' : ' '} ${row.name}\t${row.id}\t${row.status}\t${row.region}`);
+            }
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    env.command('use')
+        .description('Select an environment for this workspace')
+        .argument('<environment>', 'environment name or id')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (value, opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = resolveEnvironment(await projectEnvironments(client(), projectId), value);
+            writeEnvironmentSelection(process.cwd(), {
+                id: selected.id,
+                name: selected.name,
+                projectId,
+            });
+            console.log(`Using ${selected.name} (${selected.id}) in this workspace.`);
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    env.command('current')
+        .description('Show the selected environment')
+        .action(() => {
+        const selected = readEnvironmentSelection(process.cwd());
+        if (!selected) {
+            console.log('No environment selected.');
+            return;
+        }
+        console.log(`${selected.name} (${selected.id})`);
+    });
+    env.command('clear')
+        .description('Clear the selected environment')
+        .action(() => {
+        clearEnvironmentSelection(process.cwd());
+        console.log('Environment selection cleared.');
+    });
+    env.command('create')
+        .description('Fork production and select the new environment')
+        .argument('<name>', 'new environment name')
+        .option('--from <environment>', 'source production environment name or id')
+        .option('--region <region>', 'region (defaults to the source region)')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (name, opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const api = client();
+            const source = resolveSourceEnvironment(await projectEnvironments(api, projectId), opts.from);
+            console.log(`Creating environment ${name} from ${source.name}…`);
+            const created = await api.post(`/projects/${encodeURIComponent(projectId)}/environments`, {
+                name,
+                sourceEnvironmentId: source.id,
+                region: opts.region ?? source.region,
+            });
+            const ready = await waitForEnvironment(api, created.id, new Set(['ready', 'failed']));
+            if (ready.status === 'failed') {
+                throw new Error(`Environment provisioning failed at ${ready.stage}: ${ready.lastError ?? 'unknown error'}`);
+            }
+            writeEnvironmentSelection(process.cwd(), { id: ready.id, name: ready.name, projectId });
+            printEnvironment(ready);
+            console.log(`\nUsing ${ready.name} (${ready.id}) in this workspace.`);
+            console.log('Deploy with: newly deploy');
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    env.command('status')
+        .description('Show the selected environment and its resources')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = requireEnvironmentSelection(process.cwd(), projectId);
+            printEnvironment(await client().get(`/environments/${encodeURIComponent(selected.id)}`));
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    env.command('logs')
+        .description('Show logs for a service in the selected environment')
+        .argument('[service]', 'service name or id (optional when there is only one)')
+        .option('-n, --lines <count>', 'maximum log entries', '100')
+        .option('--since <timestamp>', 'ISO timestamp (defaults to one hour ago)')
+        .option('-f, --follow', 'keep polling for new logs', false)
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (value, opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = requireEnvironmentSelection(process.cwd(), projectId);
+            const api = client();
+            const environment = await api.get(`/environments/${encodeURIComponent(selected.id)}`);
+            const service = resolveNamedResource(environment.services, value, 'service');
+            const lines = Number(opts.lines);
+            if (!Number.isInteger(lines) || lines < 1 || lines > 2_000) {
+                throw new Error('--lines must be an integer from 1 to 2000');
+            }
+            let since = opts.since ?? new Date(Date.now() - 3_600_000).toISOString();
+            if (Number.isNaN(new Date(since).getTime()))
+                throw new Error('--since must be an ISO timestamp');
+            const seen = new Set();
+            for (;;) {
+                const result = await api.get(`/environment-services/${encodeURIComponent(service.id)}/logs` +
+                    `?limit=${lines}&since=${encodeURIComponent(since)}`);
+                for (const entry of result.entries) {
+                    if (seen.has(entry.id))
+                        continue;
+                    seen.add(entry.id);
+                    console.log(formatEnvironmentLog(entry));
+                    if (entry.timestamp && new Date(entry.timestamp).getTime() >= new Date(since).getTime()) {
+                        since = entry.timestamp;
+                    }
+                }
+                if (!opts.follow)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+            }
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    const database = env.command('db').description('Operate databases in the selected environment');
+    database.command('shell')
+        .description('Open a Postgres shell for an environment database')
+        .argument('[database]', 'database name or id (optional when there is only one)')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (value, opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = requireEnvironmentSelection(process.cwd(), projectId);
+            const credentials = requireCredentials();
+            const environment = await new ApiClient(credentials.apiUrl, credentials.token).get(`/environments/${encodeURIComponent(selected.id)}`);
+            const resource = resolveNamedResource(environment.databases, value, 'database');
+            if (resource.status !== 'ready')
+                throw new Error(`Database is not ready (${resource.status}).`);
+            process.exitCode = await runEnvironmentDatabaseShell({
+                apiUrl: credentials.apiUrl,
+                token: credentials.token,
+                databaseId: resource.id,
+            });
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+    env.command('delete')
+        .description('Delete the selected environment')
+        .option('--yes', 'skip interactive confirmation', false)
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (opts) => {
+        try {
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const selected = requireEnvironmentSelection(process.cwd(), projectId);
+            if (!opts.yes && !await confirmDelete(selected.name))
+                throw new Error('Deletion cancelled.');
+            const api = client();
+            await api.delete(`/environments/${encodeURIComponent(selected.id)}`);
+            const deleted = await waitForEnvironment(api, selected.id, new Set(['deleted', 'failed']));
+            if (deleted.status === 'failed') {
+                throw new Error(`Environment deletion failed: ${deleted.lastError ?? 'unknown error'}`);
+            }
+            clearEnvironmentSelection(process.cwd());
+            console.log(`Deleted ${selected.name} (${selected.id}).`);
+        }
+        catch (error) {
+            console.error(friendlyApiError(error));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/login.js

@@ -2,7 +2,6 @@ import http from 'node:http';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { clearCredentials, credentialsDisplayPath, saveCredentials } from '../config.js';
-const DEFAULT_APP_URL = process.env.NEWLY_APP_URL ?? 'https://newly.app';
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 export async function startCallbackServer(state, appOrigin, timeoutMs) {
     let resolvePayload;
@@ -91,10 +90,13 @@ export function parseManualCredential(blob) {
     return { token: c.token, expiresIn: c.expiresIn, apiUrl: c.apiUrl };
 }
 export function registerLogin(program) {
+    const defaultAppUrl = program.name() === 'runcloud'
+        ? process.env.RUN_CLOUD_APP_URL ?? 'https://run.cloud'
+        : process.env.NEWLY_APP_URL ?? 'https://newly.app';
     program
         .command('login')
         .description('Log in with your Newly account via the browser')
-        .option('--app-url <url>', 'Newly web app URL', DEFAULT_APP_URL)
+        .option('--app-url <url>', 'product web app URL', defaultAppUrl)
         .option('--manual', 'paste the credential from the browser instead of using the local callback', false)
         .option('--api-url <url>', 'explicit API URL (skips browser; use with --token)')
         .option('--token <token>', 'explicit credential token (skips browser; use with --api-url)')