runcloud 0.1.2

package/dist/api.js

@@ -0,0 +1,139 @@
+export class ApiError extends Error {
+    status;
+    detail;
+    constructor(status, detail) {
+        super(`API ${status}: ${detail}`);
+        this.status = status;
+        this.detail = detail;
+    }
+}
+export class ApiClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async request(method, path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok) {
+            let detail = await res.text();
+            try {
+                detail = JSON.parse(detail).detail ?? detail;
+            }
+            catch {
+            }
+            throw new ApiError(res.status, detail);
+        }
+        const contentType = res.headers.get('content-type') ?? '';
+        return contentType.includes('application/json') ? res.json() : res;
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    patch(path, body) {
+        return this.request('PATCH', path, body);
+    }
+    delete(path, body) {
+        return this.request('DELETE', path, body);
+    }
+    async upload(path, body, contentType) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'Content-Type': contentType,
+            },
+            body: body,
+        });
+        if (!res.ok) {
+            let detail = await res.text();
+            try {
+                detail = JSON.parse(detail).detail ?? detail;
+            }
+            catch {
+            }
+            throw new ApiError(res.status, detail);
+        }
+        const contentType_ = res.headers.get('content-type') ?? '';
+        return contentType_.includes('application/json') ? res.json() : res;
+    }
+    async uploadForm(path, form) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+            body: form,
+        });
+        if (!res.ok) {
+            let detail = await res.text();
+            try {
+                detail = JSON.parse(detail).detail ?? detail;
+            }
+            catch {
+            }
+            throw new ApiError(res.status, detail);
+        }
+        const contentType = res.headers.get('content-type') ?? '';
+        return contentType.includes('application/json') ? res.json() : res;
+    }
+    async getBinary(path) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${this.token}` },
+        });
+        if (!res.ok) {
+            const detail = await res.text().catch(() => '');
+            throw new ApiError(res.status, detail || res.statusText);
+        }
+        return Buffer.from(await res.arrayBuffer());
+    }
+    async *stream(path) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            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 {
+            }
+            throw new ApiError(res.status, detail || res.statusText);
+        }
+        const decoder = new TextDecoder();
+        for await (const chunk of res.body) {
+            yield decoder.decode(chunk, { stream: true });
+        }
+        const tail = decoder.decode();
+        if (tail)
+            yield tail;
+    }
+}
+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;
+}

package/dist/archive.js

@@ -0,0 +1,113 @@
+import { mkdirSync, readdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { create as tarCreate, extract as tarExtract, list as tarList } from 'tar';
+import { Buffer } from 'node:buffer';
+export const SNAPSHOT_EXCLUDE = new Set([
+    '.git',
+    'node_modules',
+    '.venv',
+    '.expo',
+    '.next',
+    '.turbo',
+    '.vercel',
+    '.cache',
+    'dist',
+    'build',
+    'web-build',
+    '.natively',
+    'android',
+    'ios',
+    '.local',
+    '.npm',
+    '.pnpm-store',
+    '.yarn',
+    '.bun',
+    '__pycache__',
+    'agent_activity',
+    'branches',
+    'secrets',
+]);
+export const SNAPSHOT_EXCLUDE_FILE_GLOBS = [
+    '.env',
+    '.env.*',
+    '.env*.local',
+    '*.pem',
+    '*.key',
+    '*.p8',
+    '*.p12',
+    '*.jks',
+    '*.mobileprovision',
+    '.DS_Store',
+    '*.orig.*',
+    '*.tsbuildinfo',
+];
+const FILE_GLOB_REGEXPS = SNAPSHOT_EXCLUDE_FILE_GLOBS.map((glob) => new RegExp(`^${glob.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*')}$`));
+function isExcluded(path) {
+    return path
+        .replace(/^\.\//, '')
+        .split('/')
+        .some((part) => SNAPSHOT_EXCLUDE.has(part));
+}
+function isExcludedFile(basename) {
+    return FILE_GLOB_REGEXPS.some((re) => re.test(basename));
+}
+function basenameOf(path) {
+    const parts = path.split('/');
+    return parts[parts.length - 1];
+}
+export async function createSnapshot(dir) {
+    const chunks = [];
+    const stream = tarCreate({
+        gzip: true,
+        cwd: dir,
+        filter: (p) => !isExcluded(p) && !isExcludedFile(basenameOf(p)),
+        portable: true,
+    }, ['.']);
+    for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+export async function extractSnapshot(data, dir) {
+    mkdirSync(dir, { recursive: true });
+    await new Promise((resolve, reject) => {
+        const stream = tarExtract({ cwd: dir });
+        stream.on('error', reject);
+        stream.on('finish', resolve);
+        stream.end(data);
+    });
+}
+export async function snapshotTopLevelEntries(data) {
+    const top = new Set();
+    for (const name of await listSnapshot(data)) {
+        const rel = name.replace(/^\.?\//, '');
+        const first = rel.split('/')[0];
+        if (first && first !== '.')
+            top.add(first);
+    }
+    return top;
+}
+export function pruneStaleTopLevel(dir, keep) {
+    const removed = [];
+    for (const entry of readdirSync(dir)) {
+        if (entry === '.newly')
+            continue;
+        if (keep.has(entry))
+            continue;
+        if (isExcluded(entry) || isExcludedFile(entry))
+            continue;
+        rmSync(join(dir, entry), { recursive: true, force: true });
+        removed.push(entry);
+    }
+    return removed;
+}
+export async function listSnapshot(data) {
+    const names = [];
+    await new Promise((resolve, reject) => {
+        const stream = tarList({ onentry: (e) => names.push(e.path) });
+        stream.on('error', reject);
+        stream.on('finish', resolve);
+        stream.end(data);
+    });
+    return names;
+}

package/dist/commands/build.js

@@ -0,0 +1,250 @@
+import { existsSync, statSync } from 'node:fs';
+import { basename, 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 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();
+}
+async function ensureRemoteSourceProject(client, sourceDir, explicitProject, log) {
+    if (explicitProject)
+        return explicitProject;
+    const linked = readProjectLink(sourceDir);
+    if (linked?.projectId)
+        return linked.projectId;
+    const name = basename(resolve(sourceDir)) || 'iOS 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;
+        }
+    }
+    return status;
+}
+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();
+}
+async function prepareServeSimBuildFromCli(session, launchUrl) {
+    if (typeof session.token !== 'string') {
+        throw new Error('Backend returned a serve-sim session without a token.');
+    }
+    const prepareUrl = serveSimPrepareUrl(session);
+    if (!prepareUrl) {
+        throw new Error('Backend returned a serve-sim session without a prepare target.');
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 20_000);
+    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}` : ''}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            throw new Error('serve-sim prepare timed out after 20000ms');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function runIosSimulatorBuild(client, projectId, opts = {}, log = console.log) {
+    let build;
+    const metroUrl = opts.metroUrl?.trim() || null;
+    if (opts.remoteSource) {
+        const sourceDir = opts.sourcePath ?? '.';
+        assertDirectory(sourceDir, 'iOS build source directory');
+        projectId = await ensureRemoteSourceProject(client, sourceDir, projectId, log);
+        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',
+        }));
+        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 (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;
+            await prepareServeSimBuildFromCli(session, metroUrl);
+            const url = typeof session.url === 'string' ? session.url : session.base_url;
+            log(`Cloud simulator prepared on ${typeof url === 'string' ? url : 'ready'}`);
+        }
+        else {
+            log('Simulator load requested.');
+        }
+    }
+}
+export function registerBuild(program) {
+    program
+        .command('build [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 an iOS 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')
+        .action(async (platform = 'ios', opts) => {
+        try {
+            if (platform !== 'ios' || !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);
+            await runIosSimulatorBuild(client, projectId, opts);
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/create.js

@@ -0,0 +1,60 @@
+import { existsSync } from 'node:fs';
+import { join } 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) {
+    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,
+    });
+    writeProjectLink(dir, {
+        projectId: project_id,
+        pulledSha: null,
+        pulledAt: new Date().toISOString(),
+    });
+    try {
+        const tar = await client.getBinary('/newly_backend/backend_template');
+        await extractSnapshot(tar, dir);
+    }
+    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 (status === 'provisioning') {
+        console.log(`Created backend project ${project_id} and scaffolded backend/ here. ` +
+            `Provisioning the dev backend… check with \`newly status\`. Edit, then \`newly deploy\`.`);
+    }
+    else {
+        console.log(`Created backend project ${project_id} and scaffolded backend/ here ` +
+            `(not provisioned — run \`newly deploy\` when ready).`);
+    }
+    return project_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')
+        .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(), {
+                name,
+                provision: opts.provision,
+            });
+        }
+        catch (e) {
+            console.error(e instanceof ApiError ? friendlyApiError(e) : String(e instanceof Error ? e.message : e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/creds.js

@@ -0,0 +1,103 @@
+import { readFileSync } from 'node:fs';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+const TEAM_BUNDLE_CMD = 'newly creds apple --team-id <TEAM_ID> --bundle-id <BUNDLE_ID>';
+const ASC_KEY_CMD = 'newly creds apple --asc-key <key.p8> --key-id <KEY_ID> --issuer-id <ISSUER_ID>';
+export function buildReadiness(s) {
+    const missing = [];
+    const remediations = [];
+    if (!s.team_id)
+        missing.push('team id');
+    if (!s.bundle_id)
+        missing.push('bundle id');
+    if (!s.team_id || !s.bundle_id)
+        remediations.push(TEAM_BUNDLE_CMD);
+    if (!s.asc_api_key?.has_private_key) {
+        missing.push('ASC API key');
+        remediations.push(ASC_KEY_CMD);
+    }
+    return { ready: missing.length === 0, missing, remediations };
+}
+export function renderAppleStatus(s) {
+    const r = buildReadiness(s);
+    const lines = [
+        `team id:     ${s.team_id ?? '— not set'}`,
+        `bundle id:   ${s.bundle_id ?? '— not set'}`,
+        `ASC API key: ${s.asc_api_key?.has_private_key ? 'configured' : '— not set'}`,
+    ];
+    if (r.ready) {
+        lines.push('', '✓ iOS build-ready.');
+    }
+    else {
+        lines.push('', `Missing: ${r.missing.join(', ')}. To fix:`);
+        for (const cmd of r.remediations)
+            lines.push(`  ${cmd}`);
+    }
+    return lines.join('\n');
+}
+export function planAppleCreds(opts) {
+    const setTeamInfo = Boolean(opts.teamId || opts.bundleId);
+    if (setTeamInfo && !(opts.teamId && opts.bundleId)) {
+        throw new Error('--team-id and --bundle-id must be provided together.');
+    }
+    const uploadAscKey = Boolean(opts.ascKey);
+    if (uploadAscKey && !opts.keyId) {
+        throw new Error('--asc-key requires --key-id.');
+    }
+    if (!setTeamInfo && !uploadAscKey) {
+        throw new Error('Nothing to do. Pass --team-id/--bundle-id and/or --asc-key. See `newly creds apple status`.');
+    }
+    return { setTeamInfo, uploadAscKey };
+}
+export async function runAppleCreds(opts, client, projectId, log = console.log) {
+    const plan = planAppleCreds(opts);
+    if (plan.setTeamInfo) {
+        await client.post(`/newly_backend/apple/team_info/${projectId}`, {
+            team_id: opts.teamId,
+            bundle_id: opts.bundleId,
+        });
+        log(`Set team id ${opts.teamId} and bundle id ${opts.bundleId}.`);
+    }
+    if (plan.uploadAscKey) {
+        const privateKeyBase64 = readFileSync(opts.ascKey).toString('base64');
+        await client.post(`/newly_backend/apple/asc_key/${projectId}`, {
+            key_id: opts.keyId,
+            issuer_id: opts.issuerId ?? '',
+            private_key_base64: privateKeyBase64,
+        });
+        log('Uploaded ASC API key.');
+    }
+}
+export function registerCreds(program) {
+    const creds = program.command('creds').description('Manage project credentials');
+    const apple = creds
+        .command('apple')
+        .argument('[action]', 'use "status" to show Apple credential readiness')
+        .description('Set Apple iOS build credentials (project owner only)')
+        .option('--team-id <id>', 'Apple Developer team ID')
+        .option('--bundle-id <id>', 'iOS bundle identifier')
+        .option('--asc-key <file>', 'path to an App Store Connect API key (.p8)')
+        .option('--key-id <id>', 'ASC API key ID (required with --asc-key)')
+        .option('--issuer-id <id>', 'ASC API issuer ID')
+        .option('--project <id>', 'project id (defaults to the linked directory)');
+    apple.action(async (action, opts) => {
+        try {
+            const creds = requireCredentials();
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const client = new ApiClient(creds.apiUrl, creds.token);
+            if (action === 'status') {
+                const status = await client.get(`/newly_backend/apple/status/${projectId}`);
+                console.log(renderAppleStatus(status));
+                return;
+            }
+            if (action) {
+                throw new Error(`Unknown creds apple action "${action}". Use "status" or pass credential options.`);
+            }
+            await runAppleCreds(opts, client, projectId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}