runcloud 0.1.100 → 0.1.102

package/dist/commands/create.js

@@ -1,135 +1,59 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { ApiClient, ApiError, friendlyApiError } from '../api.js';
-import { controlPlaneUrl, requireCredentials, writeEnvironmentSelection, writeProjectLink, } from '../config.js';
-import { runEnvironmentDeploy } from './deploy.js';
-const POLL_INTERVAL_MS = 2_000;
-const POLL_TIMEOUT_MS = 20 * 60 * 1_000;
-function projectName(dir, requested) {
-    const value = requested?.trim() || basename(resolve(dir));
-    if (value.length < 1 || value.length > 100) {
-        throw new Error('Project name must be between 1 and 100 characters.');
-    }
-    return value;
-}
-export function scaffoldV3Backend(dir, name) {
-    const serviceRoot = join(dir, 'backend', 'api-service');
-    mkdirSync(join(serviceRoot, 'src'), { recursive: true });
-    writeFileSync(join(dir, 'backend', 'newly.services.json'), `${JSON.stringify({
-        services: [{
-                name: 'api',
-                path: 'api-service',
-                type: 'worker',
-                public: true,
-                bindings: { DATABASE_URL: { database: 'app' } },
-            }],
-    }, null, 2)}\n`);
-    writeFileSync(join(serviceRoot, 'package.json'), `${JSON.stringify({
-        name: `@newly/${name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-|-$/g, '') || 'api'}`,
-        private: true,
-        type: 'module',
-    }, null, 2)}\n`);
-    writeFileSync(join(serviceRoot, 'src', 'index.ts'), `interface Env {
-  DATABASE_URL: string;
-  NEWLY_ENVIRONMENT_ID: string;
-  NEWLY_PROJECT_ID: string;
-  NEWLY_SERVICE_NAME: string;
-}
-
-function json(value: unknown, status = 200): Response {
-  return Response.json(value, { status });
-}
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const url = new URL(request.url);
-    if (url.pathname === "/health") {
-      return json({ ok: true, environmentId: env.NEWLY_ENVIRONMENT_ID });
-    }
-    if (url.pathname === "/") {
-      return json({
-        projectId: env.NEWLY_PROJECT_ID,
-        environmentId: env.NEWLY_ENVIRONMENT_ID,
-        service: env.NEWLY_SERVICE_NAME,
-        databaseConfigured: Boolean(env.DATABASE_URL),
-      });
-    }
-    return json({ error: "Not found" }, 404);
-  },
-};
-`);
-}
-async function waitForProduction(client, environmentId, runtime) {
-    const intervalMs = runtime.intervalMs ?? POLL_INTERVAL_MS;
-    const deadline = Date.now() + (runtime.timeoutMs ?? POLL_TIMEOUT_MS);
-    for (;;) {
-        const environment = await client.get(`/environments/${encodeURIComponent(environmentId)}`);
-        if (environment.status === 'ready' || environment.status === 'failed')
-            return environment;
-        if (Date.now() >= deadline) {
-            throw new Error(`Timed out provisioning production (${environment.stage}).`);
-        }
-        await new Promise((done) => setTimeout(done, intervalMs));
-    }
-}
-export async function runCreate(client, dir, opts, runtime = {}) {
+import { requireCredentials, writeProjectLink } from '../config.js';
+import { extractSnapshot } from '../archive.js';
+export async function runCreate(client, dir, opts) {
     if (existsSync(join(dir, 'backend'))) {
         throw new Error('A `backend/` directory already exists here. Run `newly create` in a directory without one.');
     }
-    const name = projectName(dir, opts.name);
-    console.log(`Creating ${name} with production PostgreSQL…`);
-    const created = await client.post('/projects', { name });
+    const { project_id, status } = await client.post('/newly_backend/create_project', {
+        name: opts.name,
+        provision: opts.provision ?? true,
+    });
     writeProjectLink(dir, {
-        projectId: created.id,
+        projectId: project_id,
         pulledSha: null,
         pulledAt: new Date().toISOString(),
     });
-    scaffoldV3Backend(dir, name);
-    console.log(`Production database ${created.productionDatabaseId} is provisioning…`);
-    const production = await waitForProduction(client, created.productionEnvironmentId, runtime);
-    if (production.status === 'failed') {
-        throw new Error(`Production provisioning failed at ${production.stage}: ${production.lastError ?? created.lastError ?? 'unknown error'}`);
+    try {
+        const tar = await client.getBinary('/newly_backend/backend_template');
+        await extractSnapshot(tar, dir);
     }
-    if (production.class !== 'production' || production.projectId !== created.id) {
-        throw new Error('The production bootstrap returned an environment for the wrong project.');
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Project ${project_id} was created and linked, but scaffolding the backend template failed: ${msg}. The project exists server-side.`);
     }
-    writeEnvironmentSelection(dir, {
-        id: production.id,
-        name: production.name,
-        projectId: created.id,
-    });
-    console.log(`Using production (${production.id}) in this workspace.`);
-    if (opts.deploy ?? true) {
-        console.log('Deploying the starter backend to production…');
-        await (runtime.deploy ?? runEnvironmentDeploy)(created.id, production.id, client, dir);
-        console.log(`Created ${name}; production database and backend are ready.`);
+    if (status === 'provisioning') {
+        console.log(`Created backend project ${project_id} and scaffolded backend/ here. ` +
+            `Provisioning the dev backend… check with \`newly status\`. Edit, then \`newly deploy\`.`);
     }
     else {
-        console.log(`Created ${name}; production database is ready. Deploy with: newly deploy`);
+        console.log(`Created backend project ${project_id} and scaffolded backend/ here ` +
+            `(not provisioned — run \`newly deploy\` when ready).`);
     }
-    return created.id;
+    return project_id;
 }
 export function registerCreate(program) {
     program
         .command('create')
-        .description('Create a v3 project with its production database and backend')
-        .argument('[name]', 'project name (defaults to the current directory name)')
-        .option('--no-deploy', 'create production without deploying the starter backend')
+        .description('Create a new backend-only Newly project here (scaffold + provision)')
+        .argument('[name]', 'project name (generated if omitted)')
+        .option('--no-provision', 'create without provisioning the backend')
         .action(async (name, opts) => {
         try {
             if (existsSync(join(process.cwd(), '.newly', 'project.json'))) {
                 throw new Error('This directory is already linked to a project. Use a fresh directory for `newly create`.');
             }
             const creds = requireCredentials();
-            await runCreate(new ApiClient(controlPlaneUrl(creds), creds.token), process.cwd(), {
+            const client = new ApiClient(creds.apiUrl, creds.token);
+            await runCreate(client, process.cwd(), {
                 name,
-                deploy: opts.deploy,
+                provision: opts.provision,
             });
         }
-        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/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.100';
+export const CLI_VERSION = '0.1.102';

package/package.json

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