runcloud 0.1.8 → 0.1.10

package/README.md

@@ -16,12 +16,15 @@ Installs the `runcloud` binary. Requires **Node ≥ 20**.
 ## Log in
 
 ```bash
-runcloud login          # authenticate in the browser; stores a token in ~/.run-cloud/credentials
-runcloud login --manual # paste the credential instead of using the browser callback
-runcloud logout         # delete the stored credential
+runcloud login   # sign in with email, Google, or GitHub; stores a token in ~/.run-cloud/credentials
+runcloud logout  # delete the stored credential
 runcloud account        # show your entitlement and metered balance
 ```
 
+Email signs you in without leaving the terminal. Google and GitHub open a browser and
+show a short code to confirm, so login works over SSH and on headless machines too —
+pick with `--email`, `--google`, or `--github` to skip the prompt.
+
 The token expires — re-run `runcloud login` when a command reports you're logged out.
 
 ## Remote simulators
@@ -83,6 +86,31 @@ runcloud sandbox key "$SANDBOX_ID" "ctrl+l"
 Treat a signed desktop URL as a secret. It grants temporary access to that
 desktop without asking the browser to send your CLI credential.
 
+### Persistence and a public hostname
+
+A sandbox pauses when idle by default. Turn persistence on with `--persistent`,
+and publish a guest port at a stable `<name>-box.run.cloud` hostname with
+`--expose`:
+
+```bash
+runcloud sandbox create --name my-project --persistent      # never pauses
+runcloud sandbox create --name my-project --expose 3000     # persistent + https://my-project-box.run.cloud
+runcloud sandbox expose <id> --port 8080                    # expose later, or move the published port
+runcloud sandbox get <id>                                   # inspect, including the hostname
+```
+
+Exposed sandboxes support SSH, file transfer, VS Code, and custom domains:
+
+```bash
+runcloud sandbox ssh my-project                  # shell over authenticated SSH (no public port 22)
+runcloud sandbox cp my-project ./f :/workspace/f # scp; prefix the remote path with :
+runcloud sandbox code my-project                 # VS Code Remote SSH
+runcloud sandbox domain add my-project app.example.com
+```
+
+`runcloud box …` from earlier releases keeps working as a deprecated alias for
+these commands.
+
 ### Snapshot warm-start
 
 Freeze a "repo + deps ready" sandbox, then fork a new one from it in a fraction of a second instead of re-cloning and re-installing:

package/dist/api.js

@@ -1,3 +1,4 @@
+import { loginCommandName } from './config.js';
 export class ApiError extends Error {
     status;
     detail;
@@ -165,7 +166,7 @@ function detailSuffix(err) {
 function headline(err) {
     if (err instanceof ApiError) {
         if (err.status === 401) {
-            const command = (process.argv[1] ?? '').includes('run-cloud') ? 'runcloud login' : 'newly login';
+            const command = loginCommandName();
             return `Session expired or invalid — run \`${command}\`.`;
         }
         if (err.status === 403)

package/dist/commands/boxAccess.js

@@ -5,6 +5,9 @@ import { join } from 'node:path';
 import WebSocket, { createWebSocketStream } from 'ws';
 import { ApiClient, friendlyApiError } from '../api.js';
 import { requireCredentials } from '../config.js';
+export function noteDeprecated(oldCommand, replacement) {
+    process.stderr.write(`runcloud: '${oldCommand}' is deprecated — use '${replacement}'\n`);
+}
 function api() {
     const credentials = requireCredentials();
     return new ApiClient(credentials.apiUrl, credentials.token);
@@ -13,10 +16,12 @@ async function resolveBox(client, reference) {
     const response = await client.get('/run-cloud/boxes');
     const boxes = (response?.items ?? []);
     const box = boxes.find((item) => item.id === reference ||
+        item.sandboxId === reference ||
         item.name === reference ||
         item.hostname === reference);
-    if (!box)
-        throw new Error(`Box not found: ${reference}`);
+    if (!box) {
+        throw new Error(`No exposed sandbox matches ${reference} — publish a hostname first: runcloud sandbox expose <id>`);
+    }
     return box;
 }
 function sshHome() {
@@ -75,7 +80,7 @@ function writeSshConfig(box, privateKey) {
         '  IdentitiesOnly yes',
         '  StrictHostKeyChecking accept-new',
         `  UserKnownHostsFile "${join(sshHome(), 'known_hosts')}"`,
-        `  ProxyCommand runcloud box proxy ${box.id}`,
+        `  ProxyCommand runcloud sandbox proxy ${box.id}`,
         end,
     ].join('\n');
     const pattern = new RegExp(`${start.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`, 'g');
@@ -114,19 +119,27 @@ function openUrl(url) {
         return exec('cmd', ['/c', 'start', '', url]);
     return exec('xdg-open', [url]);
 }
-export function registerBoxAccessCommands(box) {
-    box
+const REFERENCE_HELP = 'sandbox id, box id, name, or hostname';
+export function registerAccessCommands(parent, opts = {}) {
+    const note = (verb) => {
+        if (opts.deprecated)
+            noteDeprecated(`box ${verb}`, `sandbox ${verb}`);
+    };
+    parent
         .command('setup-ssh')
-        .description('Install a dedicated key and write this box to ~/.ssh/config')
-        .argument('<box>', 'box id, name, or hostname')
-        .action((reference) => action(async () => {
-        const configured = await setupSsh(reference);
-        console.log(`SSH configured: ssh ${configured.alias}`);
-    }));
-    box
+        .description('Install a dedicated key and write this host to ~/.ssh/config')
+        .argument('<sandbox>', REFERENCE_HELP)
+        .action((reference) => {
+        note('setup-ssh');
+        return action(async () => {
+            const configured = await setupSsh(reference);
+            console.log(`SSH configured: ssh ${configured.alias}`);
+        });
+    });
+    parent
         .command('proxy', { hidden: true })
         .description('Authenticated WebSocket transport used by SSH ProxyCommand')
-        .argument('<box>', 'box id, name, or hostname')
+        .argument('<sandbox>', REFERENCE_HELP)
         .action((reference) => action(async () => {
         const client = api();
         const resolved = await resolveBox(client, reference);
@@ -145,102 +158,127 @@ export function registerBoxAccessCommands(box) {
             socket.once('error', reject);
         });
     }));
-    box
+    parent
         .command('ssh')
-        .description('Open a shell in a box')
-        .argument('<box>', 'box id, name, or hostname')
+        .description('Open a shell in an exposed sandbox')
+        .argument('<sandbox>', REFERENCE_HELP)
         .argument('[command...]', 'optional remote command')
-        .action((reference, command) => action(async () => {
-        const configured = await setupSsh(reference);
-        const code = await exec('ssh', [configured.alias, ...command]);
-        if (code !== 0)
-            process.exitCode = code;
-    }));
-    box
+        .action((reference, command) => {
+        note('ssh');
+        return action(async () => {
+            const configured = await setupSsh(reference);
+            const code = await exec('ssh', [configured.alias, ...command]);
+            if (code !== 0)
+                process.exitCode = code;
+        });
+    });
+    parent
         .command('cp')
         .description('Copy files with scp; prefix the remote path with a colon')
-        .argument('<box>', 'box id, name, or hostname')
+        .argument('<sandbox>', REFERENCE_HELP)
         .argument('<source>', 'local path or :/remote/path')
         .argument('<destination>', 'local path or :/remote/path')
         .option('-r, --recursive', 'copy directories recursively', false)
-        .action((reference, source, destination, opts) => action(async () => {
-        if (source.startsWith(':') === destination.startsWith(':')) {
-            throw new Error('Exactly one path must be remote (prefix it with :)');
-        }
-        const configured = await setupSsh(reference);
-        const remote = (path) => path.startsWith(':') ? `${configured.alias}:${path.slice(1)}` : path;
-        const args = [
-            ...(opts.recursive ? ['-r'] : []),
-            '--',
-            remote(source),
-            remote(destination),
-        ];
-        const code = await exec('scp', args);
-        if (code !== 0)
-            process.exitCode = code;
-    }));
-    box
+        .action((reference, source, destination, cmdOpts) => {
+        note('cp');
+        return action(async () => {
+            if (source.startsWith(':') === destination.startsWith(':')) {
+                throw new Error('Exactly one path must be remote (prefix it with :)');
+            }
+            const configured = await setupSsh(reference);
+            const remote = (path) => path.startsWith(':') ? `${configured.alias}:${path.slice(1)}` : path;
+            const args = [
+                ...(cmdOpts.recursive ? ['-r'] : []),
+                '--',
+                remote(source),
+                remote(destination),
+            ];
+            const code = await exec('scp', args);
+            if (code !== 0)
+                process.exitCode = code;
+        });
+    });
+    parent
         .command('code')
-        .description('Open a box in VS Code Remote SSH')
-        .argument('<box>', 'box id, name, or hostname')
+        .description('Open an exposed sandbox in VS Code Remote SSH')
+        .argument('<sandbox>', REFERENCE_HELP)
         .argument('[path]', 'remote folder', '/workspace')
         .option('--no-open', 'print the VS Code URL without opening it')
-        .action((reference, path, opts) => action(async () => {
-        const configured = await setupSsh(reference);
-        const remotePath = path.startsWith('/') ? path : `/${path}`;
-        const url = `vscode://vscode-remote/ssh-remote+${encodeURIComponent(configured.alias)}` +
-            remotePath.split('/').map(encodeURIComponent).join('/');
-        if (opts.open === false)
-            console.log(url);
-        else
-            await openUrl(url);
-    }));
-    const domain = box.command('domain').description('Manage custom domains');
+        .action((reference, path, cmdOpts) => {
+        note('code');
+        return action(async () => {
+            const configured = await setupSsh(reference);
+            const remotePath = path.startsWith('/') ? path : `/${path}`;
+            const url = `vscode://vscode-remote/ssh-remote+${encodeURIComponent(configured.alias)}` +
+                remotePath.split('/').map(encodeURIComponent).join('/');
+            if (cmdOpts.open === false)
+                console.log(url);
+            else
+                await openUrl(url);
+        });
+    });
+    const domain = parent.command('domain').description('Manage custom domains');
+    const domainNote = (verb) => {
+        if (opts.deprecated)
+            noteDeprecated(`box domain ${verb}`, `sandbox domain ${verb}`);
+    };
     domain
         .command('add')
-        .argument('<box>', 'box id, name, or hostname')
+        .argument('<sandbox>', REFERENCE_HELP)
         .argument('<hostname>', 'custom hostname')
         .option('--json', 'output JSON', false)
-        .action((reference, hostname, opts) => action(async () => {
-        const client = api();
-        const resolved = await resolveBox(client, reference);
-        output(await client.post(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains`, {
-            hostname,
-        }), opts);
-    }));
+        .action((reference, hostname, cmdOpts) => {
+        domainNote('add');
+        return action(async () => {
+            const client = api();
+            const resolved = await resolveBox(client, reference);
+            output(await client.post(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains`, {
+                hostname,
+            }), cmdOpts);
+        });
+    });
     domain
         .command('list')
-        .argument('<box>', 'box id, name, or hostname')
+        .argument('<sandbox>', REFERENCE_HELP)
         .option('--json', 'output JSON', false)
-        .action((reference, opts) => action(async () => {
-        const client = api();
-        const resolved = await resolveBox(client, reference);
-        const response = await client.get(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains`);
-        const items = response?.items ?? [];
-        if (opts.json)
-            console.log(JSON.stringify(items, null, 2));
-        else
-            for (const item of items)
-                output(item, opts);
-    }));
+        .action((reference, cmdOpts) => {
+        domainNote('list');
+        return action(async () => {
+            const client = api();
+            const resolved = await resolveBox(client, reference);
+            const response = await client.get(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains`);
+            const items = response?.items ?? [];
+            if (cmdOpts.json)
+                console.log(JSON.stringify(items, null, 2));
+            else
+                for (const item of items)
+                    output(item, cmdOpts);
+        });
+    });
     domain
         .command('status')
-        .argument('<box>', 'box id, name, or hostname')
-        .argument('<domain-id>', 'domain id from `box domain list`')
+        .argument('<sandbox>', REFERENCE_HELP)
+        .argument('<domain-id>', 'domain id from `domain list`')
         .option('--json', 'output JSON', false)
-        .action((reference, domainId, opts) => action(async () => {
-        const client = api();
-        const resolved = await resolveBox(client, reference);
-        output(await client.post(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains/${encodeURIComponent(domainId)}/refresh`), opts);
-    }));
+        .action((reference, domainId, cmdOpts) => {
+        domainNote('status');
+        return action(async () => {
+            const client = api();
+            const resolved = await resolveBox(client, reference);
+            output(await client.post(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains/${encodeURIComponent(domainId)}/refresh`), cmdOpts);
+        });
+    });
     domain
         .command('rm')
-        .argument('<box>', 'box id, name, or hostname')
-        .argument('<domain-id>', 'domain id from `box domain list`')
-        .action((reference, domainId) => action(async () => {
-        const client = api();
-        const resolved = await resolveBox(client, reference);
-        await client.delete(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains/${encodeURIComponent(domainId)}`);
-        console.log(`removed custom domain ${domainId}`);
-    }));
+        .argument('<sandbox>', REFERENCE_HELP)
+        .argument('<domain-id>', 'domain id from `domain list`')
+        .action((reference, domainId) => {
+        domainNote('rm');
+        return action(async () => {
+            const client = api();
+            const resolved = await resolveBox(client, reference);
+            await client.delete(`/run-cloud/boxes/${encodeURIComponent(resolved.id)}/domains/${encodeURIComponent(domainId)}`);
+            console.log(`removed custom domain ${domainId}`);
+        });
+    });
 }

package/dist/commands/environment.js

@@ -1,6 +1,6 @@
 import { createInterface } from 'node:readline/promises';
 import { ApiClient, friendlyApiError } from '../api.js';
-import { runEnvironmentDatabaseShell } from '../environmentShell.js';
+import { runEnvironmentDatabaseShell } from '../shellSession.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;

package/dist/commands/login.js

@@ -1,9 +1,39 @@
 import http from 'node:http';
 import crypto from 'node:crypto';
+import { hostname } from 'node:os';
 import { spawn } from 'node:child_process';
 import { ApiClient, ApiError } from '../api.js';
 import { clearCredentials, credentialsDisplayPath, normalizeApiUrl, saveCredentials } from '../config.js';
+import { acquirePromptIO, ask, PromptAbortedError, select, } from '../prompt.js';
+import { AuthError, createApiKey, fetchProviders, isValidEmail, isValidOtp, normalizeOtp, sendEmailCode, verifyEmailCode, } from '../runCloudAuth.js';
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+export const DEFAULT_RUN_CLOUD_API_URL = 'https://api.run.cloud';
+export function loginChoices(providers) {
+    const choices = [];
+    if (providers.emailOtp) {
+        choices.push({ value: 'email', label: 'Email', hint: 'a code is sent to your inbox' });
+    }
+    if (providers.google) {
+        choices.push({ value: 'google', label: 'Google', hint: 'opens your browser' });
+    }
+    if (providers.github) {
+        choices.push({ value: 'github', label: 'GitHub', hint: 'opens your browser' });
+    }
+    return choices;
+}
+export function methodFromFlags(flags) {
+    const chosen = [];
+    if (flags.email)
+        chosen.push('email');
+    if (flags.google)
+        chosen.push('google');
+    if (flags.github)
+        chosen.push('github');
+    if (chosen.length > 1) {
+        throw new Error(`Pick one sign-in method: ${chosen.map((m) => `--${m}`).join(' and ')} conflict.`);
+    }
+    return chosen[0] ?? null;
+}
 export async function startCallbackServer(state, appOrigin, timeoutMs) {
     let resolvePayload;
     let rejectPayload;
@@ -84,7 +114,7 @@ export async function startCallbackServer(state, appOrigin, timeoutMs) {
         },
     };
 }
-function openBrowser(url) {
+export function openBrowser(url) {
     const [cmd, args] = process.platform === 'darwin'
         ? ['open', [url]]
         : process.platform === 'win32'
@@ -95,12 +125,54 @@ function openBrowser(url) {
     });
     child.unref();
 }
-export function cliAuthUrl(appUrl, port, state) {
+export function cliAuthUrl(appUrl, port, state, provider) {
     const url = new URL('/cli-auth', appUrl);
     url.searchParams.set('port', String(port));
     url.searchParams.set('state', state);
+    if (provider)
+        url.searchParams.set('provider', provider);
     return url.toString();
 }
+export async function emailLogin(apiUrl, presetEmail, io) {
+    const email = presetEmail?.trim()
+        ? presetEmail.trim()
+        : await ask('  Email: ', {
+            io,
+            validate: (value) => (isValidEmail(value) ? null : 'That does not look like an email address.'),
+        });
+    if (!isValidEmail(email))
+        throw new Error(`Not a valid email address: ${email}`);
+    await sendEmailCode(apiUrl, email);
+    console.log(`  Code sent to ${email}\n`);
+    let session = null;
+    for (let attempt = 1; attempt <= 3 && !session; attempt += 1) {
+        const code = await ask('  Code: ', {
+            io,
+            validate: (value) => (isValidOtp(value) ? null : 'Codes are six digits.'),
+        });
+        try {
+            session = await verifyEmailCode(apiUrl, email, normalizeOtp(code));
+        }
+        catch (e) {
+            const wrongCode = e instanceof AuthError && (e.status === 400 || e.status === 401);
+            if (!wrongCode || attempt === 3)
+                throw e;
+            console.log(`  ${e.message} — try again.\n`);
+        }
+    }
+    if (!session)
+        throw new Error('Could not verify the code.');
+    const token = await createApiKey(apiUrl, session.sessionToken, `runcloud CLI (${hostLabel()})`);
+    return { email, token };
+}
+function hostLabel() {
+    try {
+        return hostname() || 'cli';
+    }
+    catch {
+        return 'cli';
+    }
+}
 export function parseManualCredential(blob) {
     let parsed;
     try {
@@ -136,12 +208,18 @@ export function registerLogin(program) {
         : process.env.NEWLY_APP_URL ?? 'https://newly.app';
     program
         .command('login')
-        .description(`Log in with your ${isRunCloud ? 'run.cloud' : 'Newly'} account via the browser`)
+        .description(isRunCloud
+        ? 'Log in with your run.cloud account: email, Google, or GitHub'
+        : 'Log in with your Newly account via the browser')
         .option('--app-url <url>', 'product web app URL', defaultAppUrl)
-        .option('--manual', 'paste the credential from the browser instead of using the local callback', false)
+        .option('--manual', 'newly skin only: paste the credential from the browser instead of using the local callback', false)
         .option('--api-url <url>', 'explicit API URL (skips browser; use with --token)')
         .option('--token <token>', 'explicit credential token (skips browser; use with --api-url)')
         .option('--expires-in <seconds>', 'session lifetime when using --token (default 7 days)', (v) => Number(v), 604800)
+        .option('--email [address]', 'sign in with an emailed code, without a browser')
+        .option('--google', 'sign in with Google', false)
+        .option('--github', 'sign in with GitHub', false)
+        .option('--browser', 'skip the picker and use the browser handoff', false)
         .action(async (opts) => {
         try {
             const hasApiUrl = typeof opts.apiUrl === 'string' && opts.apiUrl.length > 0;
@@ -154,7 +232,7 @@ export function registerLogin(program) {
             }
             if (hasToken) {
                 const apiUrl = isRunCloud
-                    ? opts.apiUrl ?? process.env.RUN_CLOUD_API_URL ?? 'https://api.newly.app'
+                    ? opts.apiUrl ?? process.env.RUN_CLOUD_API_URL ?? 'https://api.run.cloud'
                     : opts.apiUrl;
                 try {
                     new URL(apiUrl);
@@ -173,19 +251,12 @@ export function registerLogin(program) {
                 console.log(`Logged in headlessly. Credentials written for API ${apiUrl}.`);
                 return;
             }
-            if (opts.manual) {
-                if (isRunCloud) {
-                    const manualUrl = `${opts.appUrl.replace(/\/$/, '')}/cli-auth?manual=1`;
-                    console.log(`Opening your browser to authorize the CLI…\n  ${manualUrl}\n`);
-                    openBrowser(manualUrl);
-                }
+            if (opts.manual && !isRunCloud) {
                 const { createInterface } = await import('node:readline/promises');
                 const rl = createInterface({ input: process.stdin, output: process.stdout });
                 const blob = await rl.question('Paste the credential from the browser: ');
                 rl.close();
                 const parsed = parseManualCredential(blob);
-                if (isRunCloud)
-                    await verifyRunCloudCredential(parsed.apiUrl, parsed.token);
                 saveCredentials({
                     token: parsed.token,
                     apiUrl: parsed.apiUrl,
@@ -195,10 +266,69 @@ export function registerLogin(program) {
                 console.log('Logged in.');
                 return;
             }
+            let socialProvider;
+            if (isRunCloud && !opts.browser) {
+                const authApiUrl = opts.apiUrl ?? process.env.RUN_CLOUD_API_URL ?? DEFAULT_RUN_CLOUD_API_URL;
+                let method = methodFromFlags(opts);
+                const terminal = method === 'email' || !method ? acquirePromptIO() : null;
+                try {
+                    if (!method && terminal) {
+                        const providers = await fetchProviders(authApiUrl);
+                        const choices = loginChoices(providers);
+                        if (choices.length === 0) {
+                            throw new Error(`${authApiUrl} has no sign-in methods enabled.`);
+                        }
+                        method = await select('  How do you want to sign in?', choices, terminal.io);
+                    }
+                    if (method === 'email') {
+                        const preset = typeof opts.email === 'string' ? opts.email : undefined;
+                        const { email, token } = await emailLogin(authApiUrl, preset, terminal?.io);
+                        saveCredentials({
+                            token,
+                            apiUrl: authApiUrl,
+                            appUrl: opts.appUrl,
+                            expiresAt: Number.MAX_SAFE_INTEGER,
+                        });
+                        console.log(`\n  Signed in as ${email}`);
+                        console.log(`  Credential saved to ${credentialsDisplayPath()}\n`);
+                        console.log('  Try:');
+                        console.log('    runcloud ios create --open');
+                        console.log('    runcloud sandbox run "echo hello"');
+                        return;
+                    }
+                }
+                finally {
+                    terminal?.close();
+                }
+                if (method === 'google' || method === 'github')
+                    socialProvider = method;
+            }
+            if (isRunCloud) {
+                if (opts.manual) {
+                    console.log('Note: --manual is no longer needed for run.cloud — `runcloud login` works over SSH and headless via device flow.');
+                }
+                const apiUrl = opts.apiUrl ?? process.env.RUN_CLOUD_API_URL ?? DEFAULT_RUN_CLOUD_API_URL;
+                const { runDeviceLogin } = await import('../deviceLogin.js');
+                const payload = await runDeviceLogin({
+                    apiUrl,
+                    appUrl: opts.appUrl,
+                    provider: socialProvider,
+                    openBrowser,
+                });
+                await verifyRunCloudCredential(payload.apiUrl, payload.token);
+                saveCredentials({
+                    token: payload.token,
+                    apiUrl: payload.apiUrl,
+                    appUrl: opts.appUrl,
+                    expiresAt: Math.floor(Date.now() / 1000) + payload.expiresIn,
+                });
+                console.log(`Logged in. Credentials saved to ${credentialsDisplayPath()}`);
+                return;
+            }
             const state = crypto.randomBytes(16).toString('hex');
             const appOrigin = new URL(opts.appUrl).origin;
             const { port, waitForToken, close } = await startCallbackServer(state, appOrigin, LOGIN_TIMEOUT_MS);
-            const loginUrl = cliAuthUrl(opts.appUrl, port, state);
+            const loginUrl = cliAuthUrl(opts.appUrl, port, state, socialProvider);
             console.log(`Opening your browser to authorize the CLI…\n  ${loginUrl}\n`);
             console.log("If the browser doesn't open, paste the URL above into it manually.");
             openBrowser(loginUrl);
@@ -219,6 +349,11 @@ export function registerLogin(program) {
             }
         }
         catch (e) {
+            if (e instanceof PromptAbortedError) {
+                console.log('Cancelled.');
+                process.exitCode = 130;
+                return;
+            }
             console.error(e instanceof Error ? e.message : String(e));
             process.exitCode = 1;
         }

package/dist/commands/run-cloud.js

@@ -18,7 +18,7 @@ Use this skill when a user asks an agent to create, inspect, smoke test, debug,
 
 ## Requirements
 
-- Read SDK credentials from \`RUN_CLOUD_API_KEY\`. Never print it, commit it, or write it into a skill file. The SDK uses \`RUN_CLOUD_API_URL\` when set and otherwise defaults to \`https://api.newly.app\`.
+- Read SDK credentials from \`RUN_CLOUD_API_KEY\`. Never print it, commit it, or write it into a skill file. The SDK uses \`RUN_CLOUD_API_URL\` when set and otherwise defaults to \`https://api.run.cloud\`.
 - Authenticate the CLI with either a saved \`runcloud login\` credential or \`RUN_CLOUD_API_KEY\` together with \`RUN_CLOUD_API_URL\`. Do not require both a saved login and an API key.
 - The TypeScript SDK requires Node.js 20 or newer.
 - The account must have run.cloud access, available capacity, and organization credit.
@@ -76,7 +76,7 @@ Or authenticate non-interactively with both required environment variables:
 
 \`\`\`bash
 export RUN_CLOUD_API_KEY="rc_live_..."
-export RUN_CLOUD_API_URL="https://api.newly.app"
+export RUN_CLOUD_API_URL="https://api.run.cloud"
 \`\`\`
 
 Then inspect the account: