@newly/cli 0.1.1 → 0.1.27

package/dist/commands/build.js

@@ -1,12 +1,498 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { ApiClient, ApiError } from '../api.js';
+import { createSnapshot } from '../archive.js';
+import { readProjectLink, requireCredentials, resolveProject, writeProjectLink } from '../config.js';
 export function buildPlaceholderMessage(platform) {
     return (`In-house ${platform} builds are coming in an upcoming release.\n` +
         'Set up iOS signing first with `newly creds apple` (check readiness with `newly creds apple status`).');
 }
+function serveSimDevice(session) {
+    if (typeof session.install_url !== 'string')
+        throw new Error('Backend returned a serve-sim session without a device.');
+    const device = new URL(session.install_url).searchParams.get('device');
+    if (!device)
+        throw new Error('Backend returned a serve-sim session without a device.');
+    return device;
+}
+async function connectLocalMetroTunnel(session, localPort, sidecarUrl, platform = 'ios') {
+    if (typeof session.base_url !== 'string' || typeof session.token !== 'string') {
+        throw new Error('Backend returned an incomplete serve-sim session for local Metro.');
+    }
+    const device = serveSimDevice(session);
+    const username = `desktop_${randomBytes(12).toString('hex')}`;
+    const password = randomBytes(32).toString('base64url');
+    const allocation = await fetch(`${session.base_url.replace(/\/+$/, '')}/api/integration/tunnel?device=${encodeURIComponent(device)}`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${session.token}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username, password, localService: 'metro', localHost: 'localhost', localPort }),
+        signal: AbortSignal.timeout(15_000),
+    });
+    const tunnel = (await allocation.json().catch(() => ({})));
+    if (!allocation.ok)
+        throw new Error(typeof tunnel.error === 'string' ? tunnel.error : `serve-sim tunnel allocation failed (${allocation.status})`);
+    if (typeof tunnel.port !== 'number' || typeof tunnel.serverUrl !== 'string' || typeof tunnel.fingerprint !== 'string') {
+        throw new Error('serve-sim returned an incomplete tunnel allocation.');
+    }
+    const sessionId = `${device}:${tunnel.port}`;
+    const connected = await fetch(`${sidecarUrl.replace(/\/+$/, '')}/run-cloud/tunnel`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            sessionId, serverUrl: tunnel.serverUrl, fingerprint: tunnel.fingerprint,
+            username, password, remotePort: tunnel.port, localHost: 'localhost', localPort, localService: 'metro',
+        }),
+        signal: AbortSignal.timeout(20_000),
+    });
+    const status = (await connected.json().catch(() => ({})));
+    if (!connected.ok || status.tunnel?.state !== 'connected') {
+        throw new Error(typeof status.error === 'string' ? status.error : 'Newly Desktop could not connect the local Metro tunnel.');
+    }
+    return `http://127.0.0.1:${tunnel.port}/.expo/.virtual-metro-entry.bundle?platform=${platform}&dev=true&minify=false`;
+}
+function makeClient() {
+    const creds = requireCredentials();
+    return {
+        client: new ApiClient(creds.apiUrl, creds.token),
+    };
+}
+function assertDirectory(path, label) {
+    if (!existsSync(path))
+        throw new Error(`${label} does not exist: ${path}`);
+    if (!statSync(path).isDirectory())
+        throw new Error(`${label} is not a directory: ${path}`);
+}
+function archiveKib(size) {
+    return size < 1024 ? '<1' : Math.round(size / 1024).toString();
+}
+function nativeFingerprint(sourceDir) {
+    try {
+        const output = execFileSync(process.execPath, [
+            '-e',
+            "require('@expo/fingerprint').createFingerprintAsync(process.cwd()).then(f => process.stdout.write(f.hash)).catch(() => process.exit(1))",
+        ], { cwd: sourceDir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 120_000 });
+        const expoFingerprint = output.toString().trim();
+        if (!expoFingerprint)
+            return null;
+        return createHash('sha256')
+            .update(`newly-remote-ios-development-client-v4:${expoFingerprint}`)
+            .digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+function androidPackageName(sourceDir) {
+    try {
+        const appJson = JSON.parse(readFileSync(resolve(sourceDir, 'app.json'), 'utf8'));
+        const configured = appJson.expo?.android?.package;
+        if (typeof configured === 'string' && configured.trim())
+            return configured.trim();
+        const slug = typeof appJson.expo?.slug === 'string' ? appJson.expo.slug : basename(resolve(sourceDir));
+        const suffix = slug.toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '') || 'app';
+        return `com.newly.${suffix}`;
+    }
+    catch {
+        const suffix = basename(resolve(sourceDir)).toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '') || 'app';
+        return `com.newly.${suffix}`;
+    }
+}
+function createZipSnapshot(sourceDir) {
+    const tempDir = mkdtempSync(join(tmpdir(), 'newly-android-build-'));
+    const zipPath = join(tempDir, 'source.zip');
+    try {
+        execFileSync('zip', [
+            '-qr',
+            zipPath,
+            '.',
+            '-x',
+            'node_modules/*',
+            '.git/*',
+            '.expo/*',
+            '.next/*',
+            'dist/*',
+            'build/*',
+            'android/app/build/*',
+            'ios/build/*',
+        ], { cwd: sourceDir, stdio: ['ignore', 'ignore', 'pipe'], timeout: 120_000 });
+        return readFileSync(zipPath);
+    }
+    finally {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+async function ensureRemoteSourceProject(client, sourceDir, explicitProject, log, platform = 'ios') {
+    if (explicitProject)
+        return explicitProject;
+    const linked = readProjectLink(sourceDir);
+    if (linked?.projectId)
+        return linked.projectId;
+    const label = platform === 'android' ? 'Android' : 'iOS';
+    const name = basename(resolve(sourceDir)) || `${label} simulator build`;
+    log('No Newly project link found; creating a build-only project for this local source...');
+    const created = (await client.post('/newly_backend/create_project', {
+        name,
+        provision: false,
+    }));
+    const projectId = typeof created.project_id === 'string' ? created.project_id : '';
+    if (!projectId)
+        throw new Error('Backend did not return project_id for build-only project.');
+    writeProjectLink(sourceDir, {
+        projectId,
+        pulledSha: null,
+        pulledAt: new Date().toISOString(),
+    });
+    log(`Linked local source to Newly project ${projectId} for remote simulator builds.`);
+    return projectId;
+}
+function parseSseData(frame) {
+    const out = [];
+    for (const part of frame.split(/\n\n+/)) {
+        const data = part
+            .split(/\n/)
+            .filter((line) => line.startsWith('data:'))
+            .map((line) => line.slice(5).trimStart())
+            .join('\n');
+        if (!data)
+            continue;
+        try {
+            out.push(JSON.parse(data));
+        }
+        catch {
+        }
+    }
+    return out;
+}
+async function waitForBuild(client, buildId, log) {
+    let status = 'queued';
+    const answeredPrompts = new Set();
+    for await (const chunk of client.stream(`/builds/${buildId}/stream`)) {
+        for (const event of parseSseData(chunk)) {
+            const promptId = typeof event.id === 'string' ? event.id : '';
+            if (promptId === 'jenkins-fallback-choice' && !answeredPrompts.has(promptId)) {
+                answeredPrompts.add(promptId);
+                if (typeof event.message === 'string')
+                    log(event.message);
+                log('Default build system failed; leaving this remote simulator build failed.');
+                await client.post(`/builds/${buildId}/respond`, {
+                    promptId,
+                    value: 'keep_failed',
+                });
+                status = 'failed';
+                continue;
+            }
+            if (Array.isArray(event.new_logs)) {
+                for (const line of event.new_logs)
+                    log(String(line));
+            }
+            if (typeof event.message === 'string')
+                log(event.message);
+            if (typeof event.status === 'string')
+                status = event.status;
+        }
+    }
+    if (status !== 'completed' && status !== 'failed' && status !== 'cancelled') {
+        const deadline = Date.now() + 60 * 60 * 1000;
+        let lastLoggedStatus = status;
+        while (Date.now() < deadline) {
+            const build = (await client.get(`/builds/${buildId}`));
+            const current = typeof build.status === 'string' ? build.status : status;
+            if (current !== lastLoggedStatus) {
+                log(`Build ${buildId} ${current}`);
+                lastLoggedStatus = current;
+            }
+            status = current;
+            if (status === 'completed' || status === 'failed' || status === 'cancelled')
+                return status;
+            await new Promise((resolve) => setTimeout(resolve, 5_000));
+        }
+        throw new Error(`iOS simulator build ${buildId} timed out`);
+    }
+    return status;
+}
+async function waitForAndroidApkBuild(client, buildId, log) {
+    const deadline = Date.now() + 60 * 60 * 1000;
+    let lastStatus = '';
+    while (Date.now() < deadline) {
+        const status = (await client.get(`/apk-builder/build-health/${buildId}`));
+        const current = typeof status.status === 'string' ? status.status : 'unknown';
+        if (current !== lastStatus) {
+            log(`Android build ${buildId} ${current}`);
+            lastStatus = current;
+        }
+        if (current === 'completed' || current === 'error')
+            return current;
+        await new Promise((resolve) => setTimeout(resolve, 5_000));
+    }
+    throw new Error(`Android simulator build ${buildId} timed out`);
+}
+function serveSimPrepareUrl(session) {
+    if (typeof session.base_url !== 'string' || typeof session.install_url !== 'string')
+        return null;
+    const installUrl = new URL(session.install_url);
+    const prepareUrl = new URL(`${session.base_url.replace(/\/+$/, '')}/api/integration/prepare`);
+    const device = installUrl.searchParams.get('device');
+    if (device)
+        prepareUrl.searchParams.set('device', device);
+    prepareUrl.searchParams.set('async', '1');
+    return prepareUrl.toString();
+}
+function serveSimSessionUrl(session) {
+    if (typeof session.base_url !== 'string' || typeof session.install_url !== 'string')
+        return null;
+    const installUrl = new URL(session.install_url);
+    const sessionUrl = new URL(`${session.base_url.replace(/\/+$/, '')}/api/integration/session`);
+    const device = installUrl.searchParams.get('device');
+    if (device)
+        sessionUrl.searchParams.set('device', device);
+    return sessionUrl.toString();
+}
+async function prepareServeSimBuildFromCli(session, launchUrl) {
+    const prepareTimeoutMs = 300_000;
+    if (typeof session.token !== 'string') {
+        throw new Error('Backend returned a serve-sim session without a token.');
+    }
+    const prepareUrl = serveSimPrepareUrl(session);
+    const sessionUrl = serveSimSessionUrl(session);
+    if (!prepareUrl || !sessionUrl) {
+        throw new Error('Backend returned a serve-sim session without a prepare target.');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), prepareTimeoutMs);
+    try {
+        const res = await fetch(prepareUrl, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                artifactUrl: typeof session.artifact_url === 'string' ? session.artifact_url : undefined,
+                launchUrl,
+            }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`serve-sim prepare failed: HTTP ${res.status}${body ? ` ${body}` : ''}`);
+        }
+        const deadline = Date.now() + prepareTimeoutMs;
+        while (Date.now() < deadline) {
+            const statusRes = await fetch(sessionUrl, {
+                headers: { Authorization: `Bearer ${session.token}` },
+                signal: controller.signal,
+            });
+            const statusBody = await statusRes.json().catch(() => ({}));
+            if (!statusRes.ok) {
+                throw new Error(`serve-sim session failed: HTTP ${statusRes.status}${statusBody.error ? ` ${statusBody.error}` : ''}`);
+            }
+            if (statusBody.lastPoolError)
+                throw new Error(`serve-sim prepare failed: ${statusBody.lastPoolError}`);
+            if (statusBody.phase === 'ready')
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 2_000));
+        }
+        throw new Error(`serve-sim prepare timed out after ${prepareTimeoutMs}ms`);
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            throw new Error(`serve-sim prepare timed out after ${prepareTimeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function runIosSimulatorBuild(client, projectId, opts = {}, log = console.log) {
+    let build;
+    let metroUrl = opts.metroUrl?.trim() || null;
+    const sourceDir = opts.sourcePath ?? '.';
+    const localMetroPort = opts.localMetroPort == null ? null : Number(opts.localMetroPort);
+    if (localMetroPort !== null && (!Number.isInteger(localMetroPort) || localMetroPort < 1 || localMetroPort > 65535)) {
+        throw new Error('--local-metro-port must be a valid TCP port.');
+    }
+    if (localMetroPort !== null && metroUrl)
+        throw new Error('--local-metro-port cannot be combined with --metro-url.');
+    if (opts.remoteSource) {
+        assertDirectory(sourceDir, 'iOS build source directory');
+        projectId = await ensureRemoteSourceProject(client, sourceDir, projectId, log);
+        const fingerprint = nativeFingerprint(sourceDir);
+        log(fingerprint ? `Native fingerprint: ${fingerprint.slice(0, 12)}…` : 'Native fingerprint unavailable; a native build may be required.');
+        log('Packaging iOS source...');
+        const archive = await createSnapshot(sourceDir);
+        log(`Uploading source snapshot (${archiveKib(archive.length)} KiB) for remote iOS simulator build...`);
+        const form = new FormData();
+        form.set('request', JSON.stringify({
+            project_id: projectId,
+            platform: 'ios',
+            mode: 'automatic',
+            build_profile: 'development-simulator',
+            bundle_url: localMetroPort === null ? metroUrl : undefined,
+            native_fingerprint: fingerprint,
+        }));
+        form.set('source', new Blob([new Uint8Array(archive)], { type: 'application/gzip' }), 'source.tar.gz');
+        build = (await client.uploadForm('/builds/source-upload', form));
+    }
+    else {
+        projectId = resolveProject(process.cwd(), projectId);
+        build = (await client.post('/builds', {
+            projectId,
+            platform: 'ios',
+            mode: 'automatic',
+            buildProfile: 'development-simulator',
+        }));
+    }
+    log(`Build ${build.id} queued (${build.status})`);
+    if (opts.wait) {
+        const status = await waitForBuild(client, build.id, log);
+        log(`Build ${build.id} ${status}`);
+        if (status !== 'completed')
+            throw new Error(`iOS simulator build ${status}`);
+    }
+    if (opts.loadToSimulator) {
+        const load = (provider) => {
+            const params = new URLSearchParams();
+            if (provider)
+                params.set('provider', provider);
+            if (provider === 'serve-sim' && metroUrl)
+                params.set('expo_url', metroUrl);
+            const qs = params.size ? `?${params.toString()}` : '';
+            return client.post(`/builds/${build.id}/load-to-simulator${qs}`, {});
+        };
+        let loaded;
+        try {
+            loaded = await load(opts.provider);
+        }
+        catch (e) {
+            if (localMetroPort === null && opts.provider === 'serve-sim' && e instanceof ApiError && (e.status === 503 || e.status === 500)) {
+                log('Cloud iOS simulator unavailable; falling back to Appetize...');
+                loaded = await load();
+            }
+            else {
+                throw e;
+            }
+        }
+        if (typeof loaded.appetize_public_key === 'string') {
+            log(`Appetize iOS key: ${loaded.appetize_public_key}`);
+        }
+        else if (loaded.serve_sim && typeof loaded.serve_sim === 'object') {
+            const session = loaded.serve_sim;
+            const url = typeof session.url === 'string' ? session.url : session.base_url;
+            if (typeof url === 'string')
+                log(`Cloud simulator URL: ${url}`);
+            if (localMetroPort !== null) {
+                log(`Connecting local Metro on 127.0.0.1:${localMetroPort} to the remote simulator...`);
+                metroUrl = await connectLocalMetroTunnel(session, localMetroPort, opts.sidecarUrl ?? 'http://127.0.0.1:4500');
+                log('Local Metro tunnel connected.');
+            }
+            await prepareServeSimBuildFromCli(session, metroUrl);
+            log(`Cloud simulator prepared on ${typeof url === 'string' ? url : 'ready'}`);
+        }
+        else {
+            log('Simulator load requested.');
+        }
+    }
+}
+export async function runAndroidSimulatorBuild(client, projectId, opts = {}, log = console.log) {
+    let metroUrl = opts.metroUrl?.trim() || null;
+    const sourceDir = opts.sourcePath ?? '.';
+    const localMetroPort = opts.localMetroPort == null ? null : Number(opts.localMetroPort);
+    if (localMetroPort !== null && (!Number.isInteger(localMetroPort) || localMetroPort < 1 || localMetroPort > 65535)) {
+        throw new Error('--local-metro-port must be a valid TCP port.');
+    }
+    if (localMetroPort !== null && metroUrl)
+        throw new Error('--local-metro-port cannot be combined with --metro-url.');
+    if (!opts.remoteSource) {
+        throw new Error('Android simulator builds currently require --remote-source.');
+    }
+    assertDirectory(sourceDir, 'Android build source directory');
+    projectId = await ensureRemoteSourceProject(client, sourceDir, projectId, log, 'android');
+    log('Packaging Android source...');
+    const archive = createZipSnapshot(sourceDir);
+    log(`Uploading source snapshot (${archiveKib(archive.length)} KiB) for remote Android simulator build...`);
+    const form = new FormData();
+    form.set('file', new Blob([new Uint8Array(archive)], { type: 'application/zip' }), 'source.zip');
+    form.set('bundle_identifier', androidPackageName(sourceDir));
+    form.set('project_type', 'expo');
+    form.set('project_id', projectId);
+    const uploaded = (await client.uploadForm('/apk-builder/upload', form));
+    const buildId = typeof uploaded.build_id === 'string' ? uploaded.build_id : '';
+    if (!buildId)
+        throw new Error('Backend did not return an Android build id.');
+    log(`Build ${buildId} uploaded (${String(uploaded.status ?? 'uploaded')})`);
+    await client.post('/apk-builder/start-build', { build_id: buildId });
+    log(`Build ${buildId} queued (processing)`);
+    if (opts.wait || opts.loadToSimulator) {
+        const status = await waitForAndroidApkBuild(client, buildId, log);
+        if (status !== 'completed')
+            throw new Error(`Android simulator build ${status}`);
+    }
+    if (opts.loadToSimulator) {
+        const provider = opts.provider || 'serve-sim';
+        const params = new URLSearchParams({ provider });
+        const loaded = (await client.post(`/projects/${projectId}/builds/${buildId}/load-to-simulator?${params.toString()}`, {}));
+        if (loaded.serve_sim && typeof loaded.serve_sim === 'object') {
+            const session = loaded.serve_sim;
+            const url = typeof session.url === 'string' ? session.url : session.base_url;
+            if (typeof url === 'string')
+                log(`Cloud simulator URL: ${url}`);
+            if (localMetroPort !== null) {
+                log(`Connecting local Metro on 127.0.0.1:${localMetroPort} to the remote Android emulator...`);
+                metroUrl = await connectLocalMetroTunnel(session, localMetroPort, opts.sidecarUrl ?? 'http://127.0.0.1:4500', 'android');
+                log('Local Metro tunnel connected.');
+            }
+            await prepareServeSimBuildFromCli(session, metroUrl);
+            log(`Cloud simulator prepared on ${typeof url === 'string' ? url : 'ready'}`);
+        }
+        else if (typeof loaded.appetize_public_key === 'string') {
+            log(`Appetize Android key: ${loaded.appetize_public_key}`);
+        }
+        else {
+            log('Simulator load requested.');
+        }
+    }
+}
 export function registerBuild(program) {
     program
         .command('build [platform]')
-        .description('Build the mobile app (coming soon)')
-        .action((platform = 'ios') => {
-        console.log(buildPlaceholderMessage(platform));
+        .description('Build the mobile app')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--source-path <path>', 'local source directory to upload for --remote-source', '.')
+        .option('--simulator', 'build a simulator artifact', false)
+        .option('--remote-source', 'upload local source files and build in Newly cloud', false)
+        .option('--wait', 'stream logs until the build finishes', false)
+        .option('--load-to-simulator', 'load a completed simulator build into a cloud simulator', false)
+        .option('--provider <provider>', 'simulator provider for --load-to-simulator (serve-sim or appetize)')
+        .option('--metro-url <url>', 'reachable Metro bundle URL for remote simulator source builds')
+        .option('--local-metro-port <port>', 'connect local Metro through the bundled authenticated tunnel')
+        .option('--sidecar-url <url>', 'Newly Desktop sidecar URL for --local-metro-port', 'http://127.0.0.1:4500')
+        .action(async (platform = 'ios', opts) => {
+        try {
+            if ((platform !== 'ios' && platform !== 'android') || !opts.simulator) {
+                console.log(buildPlaceholderMessage(platform));
+                return;
+            }
+            if (opts.provider && !opts.loadToSimulator) {
+                throw new Error('--provider requires --load-to-simulator.');
+            }
+            const { client } = makeClient();
+            const projectId = opts.remoteSource
+                ? opts.project || readProjectLink(opts.sourcePath ?? '.')?.projectId
+                : resolveProject(process.cwd(), opts.project);
+            if (platform === 'android') {
+                await runAndroidSimulatorBuild(client, projectId, opts);
+            }
+            else {
+                await runIosSimulatorBuild(client, projectId, opts);
+            }
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exitCode = 1;
+        }
     });
 }

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;
         }
     });