runcloud 0.1.101 → 0.1.102

package/dist/commands/deploy.js

@@ -1,125 +1,154 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { build } from 'esbuild';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { ApiClient, ApiError, friendlyApiError } from '../api.js';
-import { requireCredentials, requireEnvironmentSelection, resolveProject } from '../config.js';
-import { assertKnownServices, readBackendServices } from '../services-manifest.js';
-const POLL_INTERVAL_MS = 2_000;
+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;
 const POLL_TIMEOUT_MS = 20 * 60 * 1000;
-function sha256(bytes) {
-    return createHash('sha256').update(bytes).digest('hex');
+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 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));
+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);
+                }
+            }
         }
     }
-    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'));
-    }
-    const entry = candidates.find(existsSync);
-    if (!entry) {
-        throw new Error(`Could not find an entry point for service ${service.name} under backend/${service.path}`);
+    catch (e) {
+        if (e instanceof ApiError && e.status === 404) {
+            return pollRun(client, runId);
+        }
+        if (started) {
+            return pollRun(client, runId);
+        }
+        throw e;
     }
-    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);
+    return pollRun(client, runId);
 }
-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));
+export function finishOrThrow(run, label) {
+    if (run.status === 'succeeded') {
+        console.log(`${label} deploy succeeded.`);
+        return;
     }
-}
-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}` : ''}`);
+    if (run.failure_reason === 'no_backend_code') {
+        throw new Error('No backend code to deploy (backend/ missing).');
     }
-    console.log(`Deployed ${service.name} (${finished.id}).`);
-    return finished;
+    throw new Error(`${label} deploy failed (${run.failure_reason ?? 'unknown'}):\n${run.output_tail ?? ''}`);
 }
-export async function runEnvironmentDeploy(projectId, environmentId, client, dir, selectedNames = []) {
+export async function runDevDeploy(projectId, client, dir, services = []) {
     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.');
     }
-    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(', ')}`);
+    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 deployments = [];
-    for (const service of selected) {
-        deployments.push(await deployService(client, dir, service, serviceIds.get(service.name)));
+    else {
+        await client.post(`/newly_backend/provision_prod/${projectId}`);
     }
-    return deployments;
+    print(`Provisioned ${env} backend.`);
 }
 export function registerDeploy(program) {
     program
         .command('deploy')
-        .description('Deploy backend services to the selected environment')
-        .argument('[services...]', 'service names from backend/newly.services.json')
+        .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')
         .option('--project <id>', 'project id (defaults to the linked directory)')
-        .action(async (services, opts) => {
+        .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) => {
         try {
-            const dir = process.cwd();
+            if (opts.env !== 'dev' && opts.env !== 'prod')
+                throw new Error('--env must be dev or prod');
             const creds = requireCredentials();
-            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);
+            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);
+            }
         }
-        catch (error) {
-            console.error(error instanceof ApiError ? friendlyApiError(error) : String(error instanceof Error ? error.message : error));
+        catch (e) {
+            console.error(e instanceof ApiError ? friendlyApiError(e) : String(e instanceof Error ? e.message : e));
             process.exitCode = 1;
         }
     });

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.101';
+export const CLI_VERSION = '0.1.102';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runcloud",
-  "version": "0.1.101",
+  "version": "0.1.102",
   "description": "Create and control run.cloud remote mobile simulators and cloud sandboxes",
   "license": "Apache-2.0",
   "keywords": [