runcloud 0.1.133 → 0.1.135

package/dist/commands/deploy.js

@@ -4,7 +4,8 @@ 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';
+import { assertKnownServices, parseServiceFilter, readBackendServices, } from '../services-manifest.js';
+import { buildDeployBundle, spawnRun, NEWLY_BACKEND_DEPLOY_BUNDLE_CONTENT_TYPE, NEWLY_BACKEND_DEPLOY_MODE_BUNDLE, } from '../deploy-bundle.js';
 const POLL_INTERVAL_MS = 5_000;
 const POLL_TIMEOUT_MS = 20 * 60 * 1000;
 export async function pollRun(client, runId, opts = {}) {
@@ -93,6 +94,32 @@ export async function runProdDeploy(projectId, client, gitSha = 'HEAD', services
     const run = await streamRun(client, run_id);
     finishOrThrow(run, 'prod');
 }
+export function isBundleDeployMode(stackInfo) {
+    return stackInfo.deploy_mode === NEWLY_BACKEND_DEPLOY_MODE_BUNDLE;
+}
+export async function runBundleDeploy(projectId, client, dir, env, allServices, selected = [], runCmd = spawnRun) {
+    const targets = selected.length ? allServices.filter((s) => selected.includes(s.name)) : allServices;
+    const bundleServices = targets.map((s) => ({
+        name: s.name,
+        path: s.path,
+        schema: s.schema ?? undefined,
+        secrets: s.secrets,
+    }));
+    const bundle = await buildDeployBundle({
+        projectDir: dir,
+        services: bundleServices,
+        run: runCmd,
+        log: (line) => console.log(line),
+    });
+    const kib = Math.max(1, Math.round(bundle.length / 1024));
+    console.log(`Uploading deploy bundle (${kib} KiB)…`);
+    const params = new URLSearchParams({ env });
+    for (const service of selected)
+        params.append('services', service);
+    const { run_id } = await client.upload(`/newly_backend/deploy/${projectId}?${params}`, bundle, NEWLY_BACKEND_DEPLOY_BUNDLE_CONTENT_TYPE);
+    const run = await streamRun(client, run_id);
+    finishOrThrow(run, env);
+}
 export async function ensureBackendProvisioned(client, projectId, env, opts = {}) {
     const print = opts.print ?? console.log;
     const status = await client.get(`/newly_backend/status/${projectId}`);
@@ -127,12 +154,14 @@ export function registerDeploy(program) {
             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}`);
+            const manifestServices = readBackendServices(process.cwd());
+            assertKnownServices(manifestServices, 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'))) {
+            const bundleMode = isBundleDeployMode(stackInfo);
+            if ((opts.env === 'dev' || bundleMode) && !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.');
             }
@@ -140,7 +169,12 @@ export function registerDeploy(program) {
                 region: opts.region,
                 print: console.log,
             });
-            if (opts.env === 'prod') {
+            if (bundleMode) {
+                if (opts.gitSha !== 'HEAD')
+                    console.log('Note: --git-sha is ignored; this project deploys the local backend code.');
+                await runBundleDeploy(projectId, client, process.cwd(), opts.env, manifestServices, services);
+            }
+            else if (opts.env === 'prod') {
                 await runProdDeploy(projectId, client, opts.gitSha, services);
             }
             else {

package/dist/commands/website.js

@@ -4,6 +4,7 @@ import { create as tarCreate } from 'tar';
 import { ApiClient, friendlyApiError } from '../api.js';
 import { createSnapshot } from '../archive.js';
 import { requireCredentials, resolveProject } from '../config.js';
+import { isBundleDeployMode } from './deploy.js';
 function makeClient(project) {
     const creds = requireCredentials();
     return {
@@ -12,6 +13,8 @@ function makeClient(project) {
     };
 }
 const BUILD_ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PUBLISH_POLL_INTERVAL_MS = 3_000;
+const PUBLISH_POLL_TIMEOUT_MS = 10 * 60 * 1000;
 export function renderDeployment(d) {
     const at = d.published_at ?? d.created_at ?? '';
     const suffix = d.error_message ? ` (${d.error_message})` : '';
@@ -100,8 +103,39 @@ export async function createStaticSiteArchive(dir) {
     }
     return Buffer.concat(chunks);
 }
-export async function runWebsitePublish(client, projectId, opts = {}, log = console.log) {
-    let result;
+function assertBundleModeExport(dir) {
+    if (!existsSync(`${resolve(dir)}/index.html`)) {
+        throw new Error(`No static export at ${dir}. Build it first, then run \`newly website publish ${dir}\`.`);
+    }
+}
+async function finishPublish(client, projectId, result, log, pollOpts = {}) {
+    if (result.deployment.status !== 'building') {
+        log(`Published ${result.deployment.id}`);
+        log(`URL: ${result.default_url}`);
+        return;
+    }
+    const intervalMs = pollOpts.intervalMs ?? PUBLISH_POLL_INTERVAL_MS;
+    const timeoutMs = pollOpts.timeoutMs ?? PUBLISH_POLL_TIMEOUT_MS;
+    log(`Publishing ${result.deployment.id}...`);
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const { deployments = [] } = (await client.get(`/projects/${projectId}/website/deployments`));
+        const match = deployments.find((d) => d.id === result.deployment.id);
+        if (match?.status === 'active') {
+            log(`Published ${match.id}`);
+            log(`URL: ${result.default_url}`);
+            return;
+        }
+        if (match?.status === 'failed') {
+            throw new Error(match.error_message ?? `Publish ${result.deployment.id} failed.`);
+        }
+        if (Date.now() > deadline) {
+            throw new Error(`Publish ${result.deployment.id} timed out after ${timeoutMs / 1000}s`);
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+}
+export async function runWebsitePublish(client, projectId, opts = {}, log = console.log, pollOpts = {}) {
     if (opts.remoteBuild) {
         const sourceDir = opts.localPath ?? '.';
         assertDirectory(sourceDir, 'Website source directory');
@@ -115,19 +149,33 @@ export async function runWebsitePublish(client, projectId, opts = {}, log = cons
             output_dir: opts.outputDir,
         }));
         form.set('source', new Blob([new Uint8Array(archive)], { type: 'application/gzip' }), 'source.tar.gz');
-        result = (await client.uploadForm(`/projects/${projectId}/website/build-upload`, form));
+        const result = (await client.uploadForm(`/projects/${projectId}/website/build-upload`, form));
+        log(`Published ${result.deployment.id}`);
+        log(`URL: ${result.default_url}`);
+        return;
     }
-    else if (opts.localPath) {
+    if (opts.localPath) {
         log('Packaging static site...');
         const archive = await createStaticSiteArchive(opts.localPath);
         log(`Uploading static site (${archiveKib(archive.length)} KiB)...`);
-        result = (await client.upload(`/projects/${projectId}/website/publish-upload`, archive, 'application/gzip'));
+        const result = (await client.upload(`/projects/${projectId}/website/publish-upload`, archive, 'application/gzip'));
+        await finishPublish(client, projectId, result, log, pollOpts);
+        return;
     }
-    else {
-        result = (await client.post(`/projects/${projectId}/website/publish`, {
-            source_path: opts.sourcePath ?? 'website/out',
-        }));
+    const stackInfo = (await client.get(`/newly_backend/stack/${projectId}`));
+    if (isBundleDeployMode(stackInfo)) {
+        const dir = opts.sourcePath ?? 'website/out';
+        assertBundleModeExport(dir);
+        log('Packaging static site...');
+        const archive = await createStaticSiteArchive(dir);
+        log(`Uploading static site (${archiveKib(archive.length)} KiB)...`);
+        const result = (await client.upload(`/projects/${projectId}/website/publish-upload`, archive, 'application/gzip'));
+        await finishPublish(client, projectId, result, log, pollOpts);
+        return;
     }
+    const result = (await client.post(`/projects/${projectId}/website/publish`, {
+        source_path: opts.sourcePath ?? 'website/out',
+    }));
     log(`Published ${result.deployment.id}`);
     log(`URL: ${result.default_url}`);
 }

package/dist/deploy-bundle.js

@@ -0,0 +1,148 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Buffer } from 'node:buffer';
+import { create as tarCreate } from 'tar';
+export const NEWLY_BACKEND_DEPLOY_BUNDLE_CONTENT_TYPE = 'application/vnd.newly.deploy-bundle+gzip';
+export const NEWLY_BACKEND_DEPLOY_MODE_BUNDLE = 'bundle';
+const MANIFEST_PATH = 'newly-deploy.json';
+const MAX_BUNDLE_BYTES = 25 * 1024 * 1024;
+const REPLACE_TOKEN = /REPLACE_[A-Z_]+/g;
+const OUTPUT_CAP_BYTES = 64 * 1024;
+export class DeployBuildError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DeployBuildError';
+    }
+}
+export async function buildDeployBundle(options) {
+    const { projectDir, services, run, log } = options;
+    const bunVersion = await run('bun', ['--version'], projectDir);
+    if (bunVersion.code !== 0) {
+        throw new DeployBuildError('newly deploy needs bun on your PATH (https://bun.sh)');
+    }
+    const bundleDir = mkdtempSync(join(tmpdir(), 'newly-deploy-bundle-'));
+    const servicesDir = join(bundleDir, 'services');
+    mkdirSync(servicesDir, { recursive: true });
+    try {
+        const manifestServices = [];
+        for (const service of services) {
+            manifestServices.push(await buildService(service, projectDir, servicesDir, run, log));
+        }
+        const gitSha = await resolveGitSha(run, projectDir);
+        const manifest = { version: 1, git_sha: gitSha, services: manifestServices };
+        writeFileSync(join(bundleDir, MANIFEST_PATH), JSON.stringify(manifest, null, 2));
+        const bundle = await tarBundle(bundleDir);
+        if (bundle.length > MAX_BUNDLE_BYTES) {
+            const mib = (bundle.length / (1024 * 1024)).toFixed(1);
+            throw new DeployBuildError(`Deploy bundle is too large (${mib} MiB, max 25 MiB).`);
+        }
+        return bundle;
+    }
+    finally {
+        rmSync(bundleDir, { recursive: true, force: true });
+    }
+}
+async function buildService(service, projectDir, servicesDir, run, log) {
+    const dir = join(projectDir, 'backend', service.path);
+    if (!existsSync(dir)) {
+        throw new DeployBuildError(`No backend code to deploy (backend/${service.path} missing)`);
+    }
+    const configPath = join(dir, 'wrangler.toml');
+    if (!existsSync(configPath)) {
+        throw new DeployBuildError(`No wrangler.toml in backend/${service.path}`);
+    }
+    log(`Building ${service.name} (bun install, wrangler bundle)…`);
+    const install = await run('bun', ['install'], dir);
+    if (install.code !== 0) {
+        throw new DeployBuildError(`bun install failed for ${service.name}:\n${install.output}`);
+    }
+    const originalConfig = readFileSync(configPath, 'utf8');
+    const script = await wranglerBundle(service, dir, originalConfig, run);
+    const serviceDir = join(servicesDir, service.name);
+    mkdirSync(serviceDir, { recursive: true });
+    writeFileSync(join(serviceDir, 'index.js'), script);
+    writeFileSync(join(serviceDir, 'wrangler.toml'), originalConfig);
+    const migrations = stageMigrations(dir, serviceDir, service.name);
+    return {
+        name: service.name,
+        schema: service.schema ?? null,
+        secrets: service.secrets ?? null,
+        script: `services/${service.name}/index.js`,
+        config: `services/${service.name}/wrangler.toml`,
+        migrations,
+    };
+}
+async function wranglerBundle(service, dir, originalConfig, run) {
+    const deployConfigName = 'wrangler.newly-deploy.toml';
+    const deployConfigPath = join(dir, deployConfigName);
+    const outDir = mkdtempSync(join(tmpdir(), 'newly-deploy-wrangler-'));
+    try {
+        writeFileSync(deployConfigPath, originalConfig.replace(REPLACE_TOKEN, 'newly-placeholder'));
+        const dryRun = await run('bunx', ['wrangler', 'deploy', '--dry-run', '--outdir', outDir, '--config', deployConfigName], dir);
+        if (dryRun.code !== 0) {
+            throw new DeployBuildError(`wrangler bundle failed for ${service.name}:\n${dryRun.output}`);
+        }
+        const jsFiles = readdirSync(outDir).filter((f) => f.endsWith('.js'));
+        if (jsFiles.length !== 1) {
+            throw new DeployBuildError(`wrangler produced ${jsFiles.length} script file(s) for ${service.name}, expected exactly one`);
+        }
+        return readFileSync(join(outDir, jsFiles[0]));
+    }
+    finally {
+        rmSync(deployConfigPath, { force: true });
+        rmSync(outDir, { recursive: true, force: true });
+    }
+}
+function stageMigrations(dir, serviceDir, name) {
+    const drizzleDir = join(dir, 'drizzle');
+    const journalPath = join(drizzleDir, 'meta', '_journal.json');
+    if (!existsSync(journalPath))
+        return null;
+    const outMetaDir = join(serviceDir, 'drizzle', 'meta');
+    mkdirSync(outMetaDir, { recursive: true });
+    writeFileSync(join(outMetaDir, '_journal.json'), readFileSync(journalPath));
+    for (const entry of readdirSync(drizzleDir)) {
+        if (entry.endsWith('.sql')) {
+            writeFileSync(join(serviceDir, 'drizzle', entry), readFileSync(join(drizzleDir, entry)));
+        }
+    }
+    return `services/${name}/drizzle`;
+}
+async function resolveGitSha(run, projectDir) {
+    const result = await run('git', ['rev-parse', 'HEAD'], projectDir);
+    if (result.code !== 0)
+        return null;
+    const sha = result.output.trim();
+    return sha || null;
+}
+async function tarBundle(bundleDir) {
+    const chunks = [];
+    const stream = tarCreate({ gzip: true, cwd: bundleDir, portable: true }, [MANIFEST_PATH, 'services']);
+    for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+export function spawnRun(command, args, cwd) {
+    const shell = process.platform === 'win32';
+    const argv = shell ? args.map((arg) => (/[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg)) : args;
+    return new Promise((resolve) => {
+        const child = spawn(command, argv, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell,
+        });
+        let output = '';
+        const append = (chunk) => {
+            output += chunk.toString('utf8');
+            if (output.length > OUTPUT_CAP_BYTES)
+                output = output.slice(-OUTPUT_CAP_BYTES);
+        };
+        child.stdout?.on('data', append);
+        child.stderr?.on('data', append);
+        child.on('error', (error) => resolve({ code: 127, output: error.message }));
+        child.on('close', (code) => resolve({ code: code ?? 1, output }));
+    });
+}

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.133';
+export const CLI_VERSION = '0.1.135';

package/package.json

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