@newly/cli 0.1.1 → 0.1.27

package/dist/commands/deploy.js

@@ -1,154 +1,125 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { build } from 'esbuild';
 import { ApiClient, ApiError, friendlyApiError } from '../api.js';
-import { requireCredentials, resolveProject } from '../config.js';
-import { createSnapshot } from '../archive.js';
-import { parseSseFrames } from '../sse.js';
-import { assertKnownServices, parseServiceFilter, readBackendServices } from '../services-manifest.js';
-const POLL_INTERVAL_MS = 5_000;
+import { requireCredentials, requireEnvironmentSelection, resolveProject } from '../config.js';
+import { assertKnownServices, readBackendServices } from '../services-manifest.js';
+const POLL_INTERVAL_MS = 2_000;
 const POLL_TIMEOUT_MS = 20 * 60 * 1000;
-export async function pollRun(client, runId, opts = {}) {
-    const intervalMs = opts.intervalMs ?? POLL_INTERVAL_MS;
-    const timeoutMs = opts.timeoutMs ?? POLL_TIMEOUT_MS;
-    const deadline = Date.now() + timeoutMs;
-    for (;;) {
-        const run = await client.get(`/newly_backend/deploy_runs/${runId}`);
-        if (run.status !== 'running')
-            return run;
-        if (Date.now() > deadline)
-            throw new Error(`Deploy run ${runId} timed out after ${timeoutMs / 1000}s`);
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
+function sha256(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
 }
-export async function streamRun(client, runId, print = (s) => process.stdout.write(s)) {
-    let buffer = '';
-    let started = false;
-    try {
-        for await (const chunk of client.stream(`/newly_backend/deploy_runs/${runId}/logs/stream`)) {
-            started = true;
-            buffer = (buffer + chunk).replace(/\r\n/g, '\n');
-            const lastSep = buffer.lastIndexOf('\n\n');
-            if (lastSep === -1)
-                continue;
-            const ready = buffer.slice(0, lastSep + 2);
-            buffer = buffer.slice(lastSep + 2);
-            for (const frame of parseSseFrames(ready)) {
-                if (frame.event === 'done') {
-                    return JSON.parse(frame.data);
-                }
-                try {
-                    print(JSON.parse(frame.data));
-                }
-                catch {
-                    print(frame.data);
-                }
-            }
+function serviceEntry(dir, service) {
+    const serviceRoot = resolve(dir, 'backend', service.path);
+    const candidates = [];
+    const packagePath = join(serviceRoot, 'package.json');
+    if (existsSync(packagePath)) {
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+        for (const value of [pkg.module, pkg.main]) {
+            if (typeof value === 'string')
+                candidates.push(resolve(serviceRoot, value));
         }
     }
-    catch (e) {
-        if (e instanceof ApiError && e.status === 404) {
-            return pollRun(client, runId);
-        }
-        if (started) {
-            return pollRun(client, runId);
-        }
-        throw e;
+    candidates.push(join(serviceRoot, 'src/index.ts'), join(serviceRoot, 'src/index.js'), join(serviceRoot, 'index.ts'), join(serviceRoot, 'index.js'));
+    if (service.name === 'api') {
+        candidates.push(join(dir, 'backend/src/index.ts'), join(dir, 'backend/src/index.js'));
     }
-    return pollRun(client, runId);
+    const entry = candidates.find(existsSync);
+    if (!entry) {
+        throw new Error(`Could not find an entry point for service ${service.name} under backend/${service.path}`);
+    }
+    return entry;
+}
+export async function bundleService(dir, service) {
+    const result = await build({
+        entryPoints: [serviceEntry(dir, service)],
+        bundle: true,
+        write: false,
+        format: 'esm',
+        platform: 'browser',
+        target: 'es2022',
+        conditions: ['workerd', 'worker', 'browser'],
+        sourcemap: false,
+        legalComments: 'none',
+    });
+    const output = result.outputFiles[0];
+    if (!output)
+        throw new Error(`Bundling service ${service.name} produced no output`);
+    return Buffer.from(output.contents);
 }
-export function finishOrThrow(run, label) {
-    if (run.status === 'succeeded') {
-        console.log(`${label} deploy succeeded.`);
-        return;
+export async function pollDeployment(client, deploymentId, opts = {}) {
+    const intervalMs = opts.intervalMs ?? POLL_INTERVAL_MS;
+    const deadline = Date.now() + (opts.timeoutMs ?? POLL_TIMEOUT_MS);
+    for (;;) {
+        const deployment = (await client.get(`/service-deployments/${deploymentId}`));
+        if (['ready', 'failed', 'superseded'].includes(deployment.status))
+            return deployment;
+        if (Date.now() > deadline)
+            throw new Error(`Deployment ${deploymentId} timed out`);
+        await new Promise((done) => setTimeout(done, intervalMs));
     }
-    if (run.failure_reason === 'no_backend_code') {
-        throw new Error('No backend code to deploy (backend/ missing).');
+}
+export async function deployService(client, dir, service, serviceId) {
+    console.log(`Building ${service.name}…`);
+    const bundle = await bundleService(dir, service);
+    const sourceDigest = sha256(bundle);
+    const configurationSpec = {
+        name: service.name,
+        type: service.type,
+        public: service.public ?? true,
+        bindings: service.bindings ?? {},
+    };
+    const deployment = (await client.postWithHeaders(`/environment-services/${serviceId}/deployments`, { bundleBase64: bundle.toString('base64'), sourceDigest, configurationSpec }, { 'Idempotency-Key': randomUUID() }));
+    const finished = await pollDeployment(client, deployment.id);
+    if (finished.status !== 'ready') {
+        throw new Error(`Deployment ${finished.id} finished with status ${finished.status}${finished.lastError ? `: ${finished.lastError}` : ''}`);
     }
-    throw new Error(`${label} deploy failed (${run.failure_reason ?? 'unknown'}):\n${run.output_tail ?? ''}`);
+    console.log(`Deployed ${service.name} (${finished.id}).`);
+    return finished;
 }
-export async function runDevDeploy(projectId, client, dir, services = []) {
+export async function runEnvironmentDeploy(projectId, environmentId, client, dir, selectedNames = []) {
     if (!existsSync(join(dir, 'backend'))) {
-        throw new Error('No backend/ in this directory. Run `newly pull <project-id>` first, ' +
-            'or cd into a pulled project.');
+        throw new Error('No backend/ in this directory. Run `newly pull <project-id>` first, or cd into a pulled project.');
     }
-    console.log('Packaging local backend…');
-    const snapshot = await createSnapshot(dir);
-    const kib = snapshot.length < 1024 ? '<1' : Math.round(snapshot.length / 1024).toString();
-    console.log(`Uploading snapshot (${kib} KiB) and deploying server-side…`);
-    const params = new URLSearchParams({ env: 'dev' });
-    for (const service of services)
-        params.append('services', service);
-    const { run_id } = await client.upload(`/newly_backend/deploy/${projectId}?${params}`, snapshot, 'application/gzip');
-    const run = await streamRun(client, run_id);
-    finishOrThrow(run, 'dev');
-}
-export async function runProdDeploy(projectId, client, gitSha = 'HEAD', services = []) {
-    const label = gitSha === 'HEAD' ? 'repo HEAD' : gitSha;
-    console.log(`Deploying prod from the canonical project code (${label})…`);
-    const { run_id } = await client.post(`/newly_backend/deploy/${projectId}`, {
-        env: 'prod',
-        git_sha: gitSha,
-        services,
-    });
-    const run = await streamRun(client, run_id);
-    finishOrThrow(run, 'prod');
-}
-export async function ensureBackendProvisioned(client, projectId, env, opts = {}) {
-    const print = opts.print ?? console.log;
-    const status = await client.get(`/newly_backend/status/${projectId}`);
-    if (status[env])
-        return;
-    print(`Provisioning ${env} backend…`);
-    if (env === 'dev') {
-        await client.post(`/newly_backend/provision_dev/${projectId}`, {
-            dev_region: opts.region ?? 'auto',
-        });
+    const manifestServices = readBackendServices(dir);
+    assertKnownServices(manifestServices, selectedNames);
+    const selected = selectedNames.length
+        ? manifestServices.filter((service) => selectedNames.includes(service.name))
+        : manifestServices;
+    const environment = (await client.get(`/environments/${environmentId}`));
+    if (environment.projectId !== projectId)
+        throw new Error('The selected environment belongs to another project.');
+    if (environment.status !== 'ready')
+        throw new Error(`Environment is ${environment.status}; wait until it is ready.`);
+    const serviceIds = new Map(environment.services.map((service) => [service.name, service.id]));
+    const undeclared = selected.filter((service) => !serviceIds.has(service.name));
+    if (undeclared.length) {
+        throw new Error(`Environment does not declare service(s): ${undeclared.map((service) => service.name).join(', ')}`);
     }
-    else {
-        await client.post(`/newly_backend/provision_prod/${projectId}`);
+    const deployments = [];
+    for (const service of selected) {
+        deployments.push(await deployService(client, dir, service, serviceIds.get(service.name)));
     }
-    print(`Provisioned ${env} backend.`);
+    return deployments;
 }
 export function registerDeploy(program) {
     program
         .command('deploy')
-        .description('Provision if needed, then deploy the backend server-side')
-        .option('--env <env>', 'dev or prod', 'dev')
-        .option('--region <region>', "Newly server region hint for first-time dev provisioning (defaults to 'auto')", 'auto')
+        .description('Deploy backend services to the selected environment')
+        .argument('[services...]', 'service names from backend/newly.services.json')
         .option('--project <id>', 'project id (defaults to the linked directory)')
-        .option('--service <names>', 'comma-separated service names from backend/newly.services.json')
-        .option('--git-sha <sha>', 'prod git revision to deploy from canonical project code', 'HEAD')
-        .option('--yes', 'skip the prod confirmation prompt', false)
-        .action(async (opts) => {
+        .action(async (services, opts) => {
         try {
-            if (opts.env !== 'dev' && opts.env !== 'prod')
-                throw new Error('--env must be dev or prod');
+            const dir = process.cwd();
             const creds = requireCredentials();
-            const projectId = resolveProject(process.cwd(), opts.project);
-            const client = new ApiClient(creds.apiUrl, creds.token);
-            const services = parseServiceFilter(opts.service);
-            assertKnownServices(readBackendServices(process.cwd()), services);
-            const stackInfo = await client.get(`/newly_backend/stack/${projectId}`);
-            if (!stackInfo.cli_deployable) {
-                throw new Error('This project does not support CLI deploys yet. Use the Newly web app to deploy it.');
-            }
-            if (opts.env === 'dev' && !existsSync(join(process.cwd(), 'backend'))) {
-                throw new Error('No backend/ in this directory. Run `newly pull <project-id>` first, ' +
-                    'or cd into a pulled project.');
-            }
-            await ensureBackendProvisioned(client, projectId, opts.env, {
-                region: opts.region,
-                print: console.log,
-            });
-            if (opts.env === 'prod') {
-                await runProdDeploy(projectId, client, opts.gitSha, services);
-            }
-            else {
-                await runDevDeploy(projectId, client, process.cwd(), services);
-            }
+            const projectId = resolveProject(dir, opts.project);
+            const environment = requireEnvironmentSelection(dir, projectId);
+            console.log(`Deploying to ${environment.name} (${environment.id})…`);
+            await runEnvironmentDeploy(projectId, environment.id, new ApiClient(creds.apiUrl, creds.token), dir, services);
         }
-        catch (e) {
-            console.error(e instanceof ApiError ? friendlyApiError(e) : String(e instanceof Error ? e.message : e));
+        catch (error) {
+            console.error(error instanceof ApiError ? friendlyApiError(error) : String(error instanceof Error ? error.message : error));
             process.exitCode = 1;
         }
     });

package/dist/commands/desktop.js

@@ -0,0 +1,55 @@
+import { execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+const DESKTOP_RUN_START_URL = 'http://127.0.0.1:4500/run/start';
+export function desktopRunUrl(project, mode, start = true, platform = 'ios') {
+    const url = new URL('newly://run');
+    url.searchParams.set('project', resolve(project));
+    url.searchParams.set('mode', mode);
+    url.searchParams.set('platform', platform);
+    url.searchParams.set('start', start ? '1' : '0');
+    url.searchParams.set('request', randomUUID());
+    return url.toString();
+}
+export async function startDesktopRun(project, mode, platform = 'ios', key = 'default', sessionId, fetchImpl = fetch) {
+    const response = await fetchImpl(DESKTOP_RUN_START_URL, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ cwd: resolve(project), key, mode, platform, ...(sessionId ? { sessionId } : {}) }),
+    });
+    if (response.ok)
+        return;
+    const detail = await response.text().catch(() => '');
+    throw new Error(`Newly Desktop could not start the simulator run (${response.status})${detail ? `: ${detail}` : ''}`);
+}
+export function openDesktopUrl(url, platform = process.platform) {
+    if (platform === 'darwin')
+        execFileSync('open', [url], { stdio: 'ignore' });
+    else if (platform === 'win32')
+        execFileSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
+    else
+        execFileSync('xdg-open', [url], { stdio: 'ignore' });
+}
+export function registerDesktop(program) {
+    const desktop = program.command('desktop').description('Control the Newly desktop app');
+    desktop
+        .command('run')
+        .alias('simulator')
+        .requiredOption('--project <path>', 'local Expo project directory')
+        .option('--mode <mode>', 'simulator mode: local or remote', 'local')
+        .option('--platform <platform>', 'simulator platform: ios or android', 'ios')
+        .option('--key <key>', 'run lane key in the desktop sidecar', 'default')
+        .option('--session-id <id>', 'control-plane session id for session-scoped remote simulator builds')
+        .option('--no-open', 'skip the newly:// opener and call the running sidecar directly')
+        .action(async (opts) => {
+        if (opts.mode !== 'local' && opts.mode !== 'remote')
+            throw new Error('--mode must be local or remote');
+        if (opts.platform !== 'ios' && opts.platform !== 'android')
+            throw new Error('--platform must be ios or android');
+        const url = desktopRunUrl(opts.project, opts.mode, false, opts.platform);
+        if (opts.open)
+            openDesktopUrl(url);
+        await startDesktopRun(opts.project, opts.mode, opts.platform, opts.key, opts.sessionId);
+        console.log(`${opts.open ? 'Opened Newly and started' : 'Started'} the ${opts.mode} ${opts.platform} simulator run for ${resolve(opts.project)}`);
+    });
+}

package/dist/commands/environment.js

@@ -0,0 +1,290 @@
+import { createInterface } from 'node:readline/promises';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { runEnvironmentDatabaseShell } from '../shellSession.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;
+        }
+    });
+}