runcloud 0.1.2 → 0.1.4

package/dist/commands/create.js

@@ -1,59 +1,135 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
 import { ApiClient, ApiError, friendlyApiError } from '../api.js';
-import { requireCredentials, writeProjectLink } from '../config.js';
-import { extractSnapshot } from '../archive.js';
-export async function runCreate(client, dir, opts) {
+import { 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 = {}) {
     if (existsSync(join(dir, 'backend'))) {
         throw new Error('A `backend/` directory already exists here. Run `newly create` in a directory without one.');
     }
-    const { project_id, status } = await client.post('/newly_backend/create_project', {
-        name: opts.name,
-        provision: opts.provision ?? true,
-    });
+    const name = projectName(dir, opts.name);
+    console.log(`Creating ${name} with production PostgreSQL…`);
+    const created = await client.post('/projects', { name });
     writeProjectLink(dir, {
-        projectId: project_id,
+        projectId: created.id,
         pulledSha: null,
         pulledAt: new Date().toISOString(),
     });
-    try {
-        const tar = await client.getBinary('/newly_backend/backend_template');
-        await extractSnapshot(tar, dir);
+    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'}`);
     }
-    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.`);
+    if (production.class !== 'production' || production.projectId !== created.id) {
+        throw new Error('The production bootstrap returned an environment for the wrong project.');
     }
-    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\`.`);
+    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.`);
     }
     else {
-        console.log(`Created backend project ${project_id} and scaffolded backend/ here ` +
-            `(not provisioned — run \`newly deploy\` when ready).`);
+        console.log(`Created ${name}; production database is ready. Deploy with: newly deploy`);
     }
-    return project_id;
+    return created.id;
 }
 export function registerCreate(program) {
     program
         .command('create')
-        .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')
+        .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')
         .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();
-            const client = new ApiClient(creds.apiUrl, creds.token);
-            await runCreate(client, process.cwd(), {
+            await runCreate(new ApiClient(creds.apiUrl, creds.token), process.cwd(), {
                 name,
-                provision: opts.provision,
+                deploy: opts.deploy,
             });
         }
-        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/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,46 @@
+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) {
+    const url = new URL('newly://run');
+    url.searchParams.set('project', resolve(project));
+    url.searchParams.set('mode', mode);
+    url.searchParams.set('start', start ? '1' : '0');
+    url.searchParams.set('request', randomUUID());
+    return url.toString();
+}
+export async function startDesktopRun(project, mode, fetchImpl = fetch) {
+    const response = await fetchImpl(DESKTOP_RUN_START_URL, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ cwd: resolve(project), key: 'default', mode }),
+    });
+    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')
+        .requiredOption('--project <path>', 'local Expo project directory')
+        .option('--mode <mode>', 'simulator mode: local or remote', 'local')
+        .action(async (opts) => {
+        if (opts.mode !== 'local' && opts.mode !== 'remote')
+            throw new Error('--mode must be local or remote');
+        const url = desktopRunUrl(opts.project, opts.mode, false);
+        openDesktopUrl(url);
+        await startDesktopRun(opts.project, opts.mode);
+        console.log(`Opened Newly and started the ${opts.mode} simulator run for ${resolve(opts.project)}`);
+    });
+}