runcloud 0.1.2 → 0.1.4

package/dist/api.js

@@ -7,6 +7,18 @@ export class ApiError extends Error {
         this.detail = detail;
     }
 }
+function parsedErrorDetail(body) {
+    try {
+        const detail = JSON.parse(body).detail;
+        if (typeof detail === 'string')
+            return detail;
+        if (detail !== undefined)
+            return JSON.stringify(detail);
+    }
+    catch {
+    }
+    return body;
+}
 export class ApiClient {
     baseUrl;
     token;
@@ -24,12 +36,7 @@ export class ApiClient {
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
         if (!res.ok) {
-            let detail = await res.text();
-            try {
-                detail = JSON.parse(detail).detail ?? detail;
-            }
-            catch {
-            }
+            const detail = parsedErrorDetail(await res.text());
             throw new ApiError(res.status, detail);
         }
         const contentType = res.headers.get('content-type') ?? '';
@@ -41,6 +48,23 @@ export class ApiClient {
     post(path, body) {
         return this.request('POST', path, body);
     }
+    async postWithHeaders(path, body, headers) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const detail = parsedErrorDetail(await res.text());
+            throw new ApiError(res.status, detail);
+        }
+        const contentType = res.headers.get('content-type') ?? '';
+        return contentType.includes('application/json') ? res.json() : res;
+    }
     patch(path, body) {
         return this.request('PATCH', path, body);
     }
@@ -57,12 +81,7 @@ export class ApiClient {
             body: body,
         });
         if (!res.ok) {
-            let detail = await res.text();
-            try {
-                detail = JSON.parse(detail).detail ?? detail;
-            }
-            catch {
-            }
+            const detail = parsedErrorDetail(await res.text());
             throw new ApiError(res.status, detail);
         }
         const contentType_ = res.headers.get('content-type') ?? '';
@@ -77,12 +96,7 @@ export class ApiClient {
             body: form,
         });
         if (!res.ok) {
-            let detail = await res.text();
-            try {
-                detail = JSON.parse(detail).detail ?? detail;
-            }
-            catch {
-            }
+            const detail = parsedErrorDetail(await res.text());
             throw new ApiError(res.status, detail);
         }
         const contentType = res.headers.get('content-type') ?? '';
@@ -105,12 +119,7 @@ export class ApiClient {
             headers: { Authorization: `Bearer ${this.token}`, Accept: 'text/event-stream' },
         });
         if (!res.ok) {
-            let detail = await res.text().catch(() => '');
-            try {
-                detail = JSON.parse(detail).detail ?? detail;
-            }
-            catch {
-            }
+            const detail = parsedErrorDetail(await res.text().catch(() => ''));
             throw new ApiError(res.status, detail || res.statusText);
         }
         const decoder = new TextDecoder();
@@ -122,18 +131,50 @@ export class ApiClient {
             yield tail;
     }
 }
+function rootCause(err) {
+    const cause = err?.cause;
+    if (cause && typeof cause === 'object' && Array.isArray(cause.errors)) {
+        return cause.errors[0] ?? cause;
+    }
+    return cause ?? err;
+}
+function networkError(err) {
+    const inner = rootCause(err);
+    const code = inner?.code;
+    if (!code)
+        return null;
+    const hints = {
+        ECONNREFUSED: 'the server refused the connection — is it running, and is the URL/port right?',
+        ENOTFOUND: 'the host could not be resolved (DNS) — check the URL',
+        EAI_AGAIN: 'temporary DNS failure — check your network connection',
+        ETIMEDOUT: 'the connection timed out — the server may be down or unreachable',
+        ECONNRESET: 'the connection was reset by the server',
+        CERT_HAS_EXPIRED: "the server's TLS certificate has expired",
+    };
+    const detail = inner instanceof Error ? inner.message : String(inner);
+    return `Could not reach the server (${code}): ${detail}${hints[code] ? ` — ${hints[code]}` : ''}`;
+}
+function detailSuffix(err) {
+    const stack = err instanceof Error && err.stack ? err.stack : String(err);
+    const cause = err?.cause;
+    return `\n${stack}${cause ? `\nCaused by: ${cause instanceof Error ? (cause.stack ?? cause.message) : String(cause)}` : ''}`;
+}
+function headline(err) {
+    if (err instanceof ApiError) {
+        if (err.status === 401)
+            return 'Session expired or invalid — run `newly login`.';
+        if (err.status === 403)
+            return err.detail ? `Forbidden: ${err.detail}` : 'Forbidden.';
+        if (err.status === 404)
+            return `Not found: ${err.detail}`;
+        if (err.status === 409)
+            return err.detail;
+        if (err.status === 503)
+            return 'The platform is at capacity right now — please try again in a few minutes.';
+        return err.message;
+    }
+    return networkError(err) ?? (err instanceof Error ? err.message : String(err));
+}
 export function friendlyApiError(err) {
-    if (!(err instanceof ApiError))
-        return String(err);
-    if (err.status === 401)
-        return 'Session expired or invalid — run `newly login`.';
-    if (err.status === 403)
-        return err.detail ? `Forbidden: ${err.detail}` : 'Forbidden.';
-    if (err.status === 404)
-        return `Not found: ${err.detail}`;
-    if (err.status === 409)
-        return err.detail;
-    if (err.status === 503)
-        return 'The platform is at capacity right now — please try again in a few minutes.';
-    return err.message;
+    return `${headline(err)}${detailSuffix(err)}`;
 }

package/dist/commands/build.js

@@ -1,5 +1,8 @@
-import { existsSync, statSync } from 'node:fs';
-import { basename, resolve } from 'node:path';
+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';
@@ -7,6 +10,49 @@ 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 {
@@ -22,13 +68,70 @@ function assertDirectory(path, label) {
 function archiveKib(size) {
     return size < 1024 ? '<1' : Math.round(size / 1024).toString();
 }
-async function ensureRemoteSourceProject(client, sourceDir, explicitProject, log) {
+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 name = basename(resolve(sourceDir)) || 'iOS simulator build';
+    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,
@@ -93,6 +196,22 @@ async function waitForBuild(client, buildId, log) {
     }
     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;
@@ -104,16 +223,28 @@ function serveSimPrepareUrl(session) {
     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);
-    if (!prepareUrl) {
+    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(), 20_000);
+    const timeout = setTimeout(() => controller.abort(), prepareTimeoutMs);
     try {
         const res = await fetch(prepareUrl, {
             method: 'POST',
@@ -131,10 +262,27 @@ async function prepareServeSimBuildFromCli(session, launchUrl) {
             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 20000ms');
+            throw new Error(`serve-sim prepare timed out after ${prepareTimeoutMs}ms`);
         }
         throw error;
     }
@@ -144,11 +292,19 @@ async function prepareServeSimBuildFromCli(session, launchUrl) {
 }
 export async function runIosSimulatorBuild(client, projectId, opts = {}, log = console.log) {
     let build;
-    const metroUrl = opts.metroUrl?.trim() || null;
+    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) {
-        const sourceDir = opts.sourcePath ?? '.';
         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...`);
@@ -158,6 +314,8 @@ export async function runIosSimulatorBuild(client, projectId, opts = {}, log = c
             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));
@@ -193,7 +351,7 @@ export async function runIosSimulatorBuild(client, projectId, opts = {}, log = c
             loaded = await load(opts.provider);
         }
         catch (e) {
-            if (opts.provider === 'serve-sim' && e instanceof ApiError && (e.status === 503 || e.status === 500)) {
+            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();
             }
@@ -206,10 +364,76 @@ export async function runIosSimulatorBuild(client, projectId, opts = {}, log = c
         }
         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.');
         }
@@ -221,15 +445,17 @@ export function registerBuild(program) {
         .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 an iOS simulator artifact', false)
+        .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' || !opts.simulator) {
+            if ((platform !== 'ios' && platform !== 'android') || !opts.simulator) {
                 console.log(buildPlaceholderMessage(platform));
                 return;
             }
@@ -240,7 +466,12 @@ export function registerBuild(program) {
             const projectId = opts.remoteSource
                 ? opts.project || readProjectLink(opts.sourcePath ?? '.')?.projectId
                 : resolveProject(process.cwd(), opts.project);
-            await runIosSimulatorBuild(client, projectId, opts);
+            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));