runcloud 0.1.132 → 0.1.134

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/email.js

@@ -1,86 +1,13 @@
-import { ApiClient, friendlyApiError } from '../api.js';
-import { requireCredentials, resolveProject } from '../config.js';
-import { assertDevOnly } from './misc.js';
-function makeClient(project) {
-    const creds = requireCredentials();
-    return {
-        client: new ApiClient(creds.apiUrl, creds.token),
-        projectId: resolveProject(process.cwd(), project),
-    };
-}
-export async function getEmailStatus(client, projectId, env) {
-    return await client.get(`/newly_backend/email/status?project_id=${encodeURIComponent(projectId)}&env=${env}`);
-}
-export function formatEmailStatus(status) {
-    const lines = [
-        `email: ${status.configured ? 'configured' : 'not configured'}`,
-        `from: ${status.from ?? '(not set)'}`,
-    ];
-    if (status.requires_deploy)
-        lines.push('requires deploy: yes');
-    if (status.notes)
-        lines.push(`notes: ${status.notes}`);
-    return lines.join('\n');
-}
-export async function sendTestEmail(client, opts) {
-    return await client.post('/newly_backend/email/test', {
-        project_id: opts.projectId,
-        env: opts.env,
-        to: opts.to,
-        from: opts.from,
-        subject: opts.subject,
-        text: opts.text,
-        html: opts.html,
-    });
-}
+export const EMAIL_RETIRED_MESSAGE = '`newly email` was retired: it never had a server to talk to. ' +
+    'There is no CLI replacement; send mail from your API service with your own provider.';
 export function registerEmail(program) {
-    const email = program.command('email').description('Manage Newly Email');
-    email
-        .command('status')
-        .description('Show Newly Email configuration for this backend')
-        .option('--env <env>', 'dev or prod', 'dev')
-        .option('--project <id>', 'project id')
-        .action(async (opts) => {
-        try {
-            assertDevOnly(opts.env, 'email status');
-            const { client, projectId } = makeClient(opts.project);
-            console.log(formatEmailStatus(await getEmailStatus(client, projectId, opts.env)));
-        }
-        catch (e) {
-            console.error(friendlyApiError(e));
-            process.exitCode = 1;
-        }
-    });
-    email
-        .command('test')
-        .description('Send a test email through the deployed API service')
-        .requiredOption('--to <email>', 'recipient email address')
-        .option('--from <email>', 'sender email address; defaults to the backend sender setting')
-        .option('--subject <subject>', 'email subject', 'Newly email test')
-        .option('--text <text>', 'plain-text body', 'This is a test email from your Newly backend.')
-        .option('--html <html>', 'optional HTML body')
-        .option('--env <env>', 'dev or prod', 'dev')
-        .option('--project <id>', 'project id')
-        .action(async (opts) => {
-        try {
-            assertDevOnly(opts.env, 'email test');
-            const { client, projectId } = makeClient(opts.project);
-            const result = await sendTestEmail(client, {
-                projectId,
-                env: opts.env,
-                to: opts.to,
-                from: opts.from,
-                subject: opts.subject,
-                text: opts.text,
-                html: opts.html,
-            });
-            console.log(result.message_id
-                ? `Email sent. message_id=${result.message_id}`
-                : 'Email sent.');
-        }
-        catch (e) {
-            console.error(friendlyApiError(e));
-            process.exitCode = 1;
-        }
+    program
+        .command('email')
+        .description('Retired: send mail from your API service instead')
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .action(() => {
+        console.error(EMAIL_RETIRED_MESSAGE);
+        process.exitCode = 1;
     });
 }

package/dist/commands/environment.js

@@ -1,12 +1,12 @@
 import { createInterface } from 'node:readline/promises';
 import { ApiClient, friendlyApiError } from '../api.js';
 import { runEnvironmentDatabaseShell } from '../shellSession.js';
-import { clearEnvironmentSelection, readEnvironmentSelection, controlPlaneUrl, requireCredentials, requireEnvironmentSelection, resolveProject, writeEnvironmentSelection, } from '../config.js';
+import { clearEnvironmentSelection, readEnvironmentSelection, requireCredentials, requireEnvironmentSelection, resolveProject, writeEnvironmentSelection, } from '../config.js';
 const POLL_INTERVAL_MS = 2_000;
 const POLL_TIMEOUT_MS = 10 * 60 * 1_000;
 function client() {
     const credentials = requireCredentials();
-    return new ApiClient(controlPlaneUrl(credentials), credentials.token);
+    return new ApiClient(credentials.apiUrl, credentials.token);
 }
 async function projectEnvironments(api, projectId) {
     const response = await api.get(`/projects/${encodeURIComponent(projectId)}/environments`);
@@ -248,7 +248,7 @@ export function registerEnvironment(program) {
             const projectId = resolveProject(process.cwd(), opts.project);
             const selected = requireEnvironmentSelection(process.cwd(), projectId);
             const credentials = requireCredentials();
-            const environment = await new ApiClient(controlPlaneUrl(credentials), credentials.token).get(`/environments/${encodeURIComponent(selected.id)}`);
+            const environment = await new ApiClient(credentials.apiUrl, credentials.token).get(`/environments/${encodeURIComponent(selected.id)}`);
             const resource = resolveNamedResource(environment.databases, value, 'database');
             if (resource.status !== 'ready')
                 throw new Error(`Database is not ready (${resource.status}).`);

package/dist/commands/login.js

@@ -49,9 +49,8 @@ export function openBrowser(url) {
     });
     child.unref();
 }
-export function commandApiUrls(apiUrl, authApiUrl) {
-    const same = normalizeApiUrl(apiUrl) === normalizeApiUrl(authApiUrl);
-    return { apiUrl, ...(same ? {} : { authApiUrl }) };
+export function commandApiUrl(isRunCloud, authApiUrl, offered) {
+    return isRunCloud && offered ? offered : authApiUrl;
 }
 export async function emailLogin(apiUrl, presetEmail, io) {
     const email = presetEmail?.trim()
@@ -135,7 +134,6 @@ export function whoamiReport(creds) {
     const rows = [
         ['Account', creds.account ?? 'not recorded (browser sign-in never sees an address)'],
         ['API', creds.apiUrl],
-        ...(creds.authApiUrl ? [['Issued by', creds.authApiUrl]] : []),
         ['Expires', expiresAtLabel(creds) ?? 'never'],
         ['Credential', credentialsDisplayPath()],
     ];
@@ -223,10 +221,8 @@ export function registerLogin(program) {
                 let method = methodFromFlags(opts);
                 const terminal = method === 'email' || !method ? acquirePromptIO() : null;
                 try {
-                    let providers = null;
                     if (!method && terminal) {
-                        providers = await fetchProviders(authApiUrl);
-                        const choices = loginChoices(providers);
+                        const choices = loginChoices(await fetchProviders(authApiUrl));
                         if (choices.length === 0) {
                             throw new Error(`${authApiUrl} has no sign-in methods enabled.`);
                         }
@@ -234,15 +230,14 @@ export function registerLogin(program) {
                     }
                     if (method === 'email') {
                         const preset = typeof opts.email === 'string' ? opts.email : undefined;
-                        providers ??= await fetchProviders(authApiUrl);
                         const { email, token } = await emailLogin(authApiUrl, preset, terminal?.io);
                         saveCredentials({
                             token,
+                            apiUrl: authApiUrl,
                             appUrl: opts.appUrl,
                             expiresAt: Number.MAX_SAFE_INTEGER,
                             revocable: true,
                             account: email,
-                            ...commandApiUrls(providers.cliApiUrl ?? authApiUrl, authApiUrl),
                         });
                         console.log(`\n  Signed in as ${email}`);
                         console.log(`  Credential saved to ${credentialsDisplayPath()}\n`);
@@ -274,11 +269,11 @@ export function registerLogin(program) {
             await verifyRunCloudCredential(authApiUrl, payload.token);
             saveCredentials({
                 token: payload.token,
+                apiUrl: commandApiUrl(isRunCloud, authApiUrl, payload.apiUrl),
                 appUrl: opts.appUrl,
                 expiresAt: Math.floor(Date.now() / 1000) + payload.expiresIn,
                 revocable: true,
                 ...(payload.account ? { account: payload.account } : {}),
-                ...commandApiUrls(payload.apiUrl, authApiUrl),
             });
             console.log(`Logged in${payload.account ? ` as ${payload.account}` : ''}. ` +
                 `Credentials saved to ${credentialsDisplayPath()}`);
@@ -313,7 +308,7 @@ export function registerLogin(program) {
         .action(async () => {
         const creds = loadCredentials();
         if (creds?.revocable) {
-            console.log(await revokeRunCloudCredential(creds.authApiUrl ?? creds.apiUrl, creds.token));
+            console.log(await revokeRunCloudCredential(creds.apiUrl, creds.token));
         }
         clearCredentials();
         console.log('Logged out.');

package/dist/commands/token.js

@@ -1,6 +1,6 @@
 import { acquirePromptIO, select, PromptAbortedError } from '../prompt.js';
 import { fetchProviders } from '../runCloudAuth.js';
-import { authApiUrlFor, commandApiUrls, emailLogin, loginChoices, methodFromFlags, openBrowser, verifyRunCloudCredential, } from './login.js';
+import { authApiUrlFor, commandApiUrl, emailLogin, loginChoices, methodFromFlags, openBrowser, verifyRunCloudCredential, } from './login.js';
 export function tokenReport(isRunCloud, minted) {
     const bin = isRunCloud ? 'runcloud' : 'newly';
     const tokenVar = isRunCloud ? 'RUN_CLOUD_API_TOKEN' : 'NEWLY_API_TOKEN';
@@ -49,10 +49,8 @@ export function registerToken(program) {
                 let method = methodFromFlags(opts);
                 const terminal = method === 'email' || !method ? acquirePromptIO() : null;
                 try {
-                    let providers = null;
                     if (!method && terminal) {
-                        providers = await fetchProviders(authApiUrl);
-                        const choices = loginChoices(providers);
+                        const choices = loginChoices(await fetchProviders(authApiUrl));
                         if (choices.length === 0) {
                             throw new Error(`${authApiUrl} has no sign-in methods enabled.`);
                         }
@@ -60,11 +58,9 @@ export function registerToken(program) {
                     }
                     if (method === 'email') {
                         const preset = typeof opts.email === 'string' ? opts.email : undefined;
-                        providers ??= await fetchProviders(authApiUrl);
                         const { email, token: minted } = await emailLogin(authApiUrl, preset, terminal?.io);
                         await verifyRunCloudCredential(authApiUrl, minted);
-                        const urls = commandApiUrls(providers.cliApiUrl ?? authApiUrl, authApiUrl);
-                        console.log(tokenReport(isRunCloud, { token: minted, apiUrl: urls.apiUrl, account: email }));
+                        console.log(tokenReport(isRunCloud, { token: minted, apiUrl: authApiUrl, account: email }));
                         return;
                     }
                 }
@@ -82,10 +78,9 @@ export function registerToken(program) {
                 openBrowser,
             });
             await verifyRunCloudCredential(authApiUrl, payload.token);
-            const urls = commandApiUrls(payload.apiUrl, authApiUrl);
             console.log(tokenReport(isRunCloud, {
                 token: payload.token,
-                apiUrl: urls.apiUrl,
+                apiUrl: commandApiUrl(isRunCloud, authApiUrl, payload.apiUrl),
                 ...(payload.account ? { account: payload.account } : {}),
             }));
         }

package/dist/config.js

@@ -36,9 +36,6 @@ export function loginCommandName() {
 export function normalizeApiUrl(url) {
     return url.replace(/\/+$/, '');
 }
-export function controlPlaneUrl(creds) {
-    return normalizeApiUrl(creds.authApiUrl ?? creds.apiUrl);
-}
 export function saveCredentials(creds) {
     mkdirSync(credentialsHome(), { recursive: true, mode: 0o700 });
     const normalized = { ...creds, apiUrl: normalizeApiUrl(creds.apiUrl) };
@@ -67,10 +64,10 @@ export function loadCredentials() {
     if (!existsSync(credentialsPath()))
         return null;
     try {
-        const creds = JSON.parse(readFileSync(credentialsPath(), 'utf8'));
+        const { authApiUrl, ...creds } = JSON.parse(readFileSync(credentialsPath(), 'utf8'));
         if (!creds.token || creds.expiresAt < Date.now() / 1000)
             return null;
-        return { ...creds, apiUrl: normalizeApiUrl(creds.apiUrl) };
+        return { ...creds, apiUrl: normalizeApiUrl(authApiUrl ?? creds.apiUrl) };
     }
     catch {
         return null;

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/runCloudAuth.js

@@ -41,13 +41,11 @@ export async function fetchProviders(apiUrl) {
     if (!response.ok)
         throw new AuthError(await readError(response), response.status);
     const payload = (await response.json());
-    const cliApiUrl = typeof payload.cliApiUrl === 'string' ? payload.cliApiUrl.trim() : '';
     return {
         emailOtp: payload.emailOtp === true,
         google: payload.google === true,
         github: payload.github === true,
         apple: payload.apple === true,
-        ...(cliApiUrl ? { cliApiUrl } : {}),
     };
 }
 export async function sendEmailCode(apiUrl, email) {

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = '0.1.132';
+export const CLI_VERSION = '0.1.134';

package/package.json

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