@newly/cli 0.1.0 → 0.1.2

package/dist/commands/run-cloud.js

@@ -0,0 +1,272 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials } from '../config.js';
+const RUN_CLOUD_SKILL = `---
+name: run-cloud-ios-simulator
+description: Build, install, and inspect iOS apps with run.cloud remote simulator sessions.
+version: 0.1.0
+---
+
+# run.cloud iOS Simulator
+
+Use this skill when a user asks an agent to run, inspect, smoke test, or debug an iOS app in a remote simulator through run.cloud.
+
+## Requirements
+
+- The user must be authenticated with \`runcloud login\`.
+- The account must have run.cloud access and a positive run.cloud balance.
+- App artifacts should be simulator-compatible builds. Device App Store IPAs may fail to install on iOS Simulator.
+
+## Workflow
+
+1. Check access with \`runcloud account --json\`.
+2. Create a simulator with \`runcloud ios create --install ./build/MyApp.tar.gz --json\`.
+3. Save the returned session id and URL.
+4. Use \`runcloud ios open-url <url> --id <session-id>\` when a URL or deep link must be opened.
+5. Release the session with \`runcloud ios delete <session-id>\`.
+
+## Embedded Iframes
+
+- Use \`runcloud ios create --inactivity-timeout 60s --json\` when the embed should auto-close after user inactivity.
+- Omit \`--inactivity-timeout\` or pass \`none\` when the user needs a metered session without idle auto-close.
+- Iframes post \`ios-simulator:status\`, \`ios-simulator:auth-error\`, \`ios-simulator:session-ended\`, and \`ios-simulator:session-restart-requested\` to the parent window. Verify \`event.source\` before acting.
+- If \`ios-simulator:session-restart-requested\` arrives, create a fresh run.cloud session; do not reuse the ended iframe URL.
+
+## Rules
+
+- Prefer \`--json\` for parsed output.
+- Always release sessions you create unless the user asks to keep them open.
+- If installation fails, verify that the artifact is a simulator build before attempting code changes.
+- Do not assume a local tunnel is installed on the user's machine.
+- Do not expose iOS simulator tokens in logs or screenshots.
+`;
+function client() {
+    const creds = requireCredentials();
+    return new ApiClient(creds.apiUrl, creds.token);
+}
+function print(value, opts = {}) {
+    if (opts.json) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            console.log(formatRecord(item));
+        return;
+    }
+    console.log(formatRecord(value));
+}
+function formatRecord(value) {
+    if (!value || typeof value !== 'object')
+        return String(value);
+    const record = value;
+    return Object.entries(record)
+        .filter(([, v]) => v !== undefined && v !== null)
+        .map(([k, v]) => `${k}: ${typeof v === 'object' ? JSON.stringify(v) : String(v)}`)
+        .join('\n');
+}
+function parseLabels(labels) {
+    const out = {};
+    for (const raw of labels ?? []) {
+        const idx = raw.indexOf('=');
+        if (idx <= 0)
+            throw new Error(`Invalid --label ${raw}; expected key=value`);
+        out[raw.slice(0, idx)] = raw.slice(idx + 1);
+    }
+    return out;
+}
+function fileBlob(path) {
+    const resolved = resolve(path);
+    if (!existsSync(resolved))
+        throw new Error(`File does not exist: ${path}`);
+    if (!statSync(resolved).isFile())
+        throw new Error(`Not a file: ${path}`);
+    const data = readFileSync(resolved);
+    return {
+        blob: new Blob([new Uint8Array(data)], { type: 'application/octet-stream' }),
+        name: basename(resolved),
+    };
+}
+function skillBase(agent, scope) {
+    if (scope === 'project') {
+        if (agent === 'claude')
+            return join(process.cwd(), '.claude', 'skills');
+        if (agent === 'codex')
+            return join(process.cwd(), '.codex', 'skills');
+        if (agent === 'cursor')
+            return join(process.cwd(), '.agents', 'skills');
+    }
+    if (agent === 'claude')
+        return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'), 'skills');
+    if (agent === 'codex')
+        return join(process.env.CODEX_HOME ?? join(homedir(), '.codex'), 'skills');
+    if (agent === 'cursor')
+        return join(homedir(), '.agents', 'skills');
+    throw new Error(`Unsupported agent: ${agent}`);
+}
+function installSkill(opts) {
+    const agents = opts.agents?.length ? opts.agents : ['claude', 'codex', 'cursor'];
+    const scope = opts.scope ?? 'project';
+    const results = [];
+    for (const agent of agents) {
+        const target = join(skillBase(agent, scope), 'run-cloud-ios-simulator');
+        if (existsSync(target)) {
+            if (!opts.force)
+                throw new Error(`${target} already exists. Pass --force to overwrite.`);
+            rmSync(target, { recursive: true, force: true });
+        }
+        mkdirSync(target, { recursive: true });
+        writeFileSync(join(target, 'SKILL.md'), RUN_CLOUD_SKILL);
+        results.push({ agent, path: target, status: 'installed' });
+    }
+    return results;
+}
+async function pushAsset(path, opts = {}) {
+    const { blob, name } = fileBlob(path);
+    const form = new FormData();
+    form.set('file', blob, name);
+    if (opts.name)
+        form.set('name', opts.name);
+    return (await client().uploadForm('/run-cloud/assets', form));
+}
+async function action(fn) {
+    try {
+        await fn();
+    }
+    catch (err) {
+        console.error(friendlyApiError(err));
+        process.exitCode = 1;
+    }
+}
+export function registerRunCloud(program) {
+    program
+        .command('account')
+        .description('Show run.cloud entitlement and metered balance')
+        .option('--json', 'output JSON', false)
+        .action((opts) => action(async () => {
+        print(await client().get('/run-cloud/account'), opts);
+    }));
+    const ios = program.command('ios').description('Create, list, inspect, and delete iOS simulator sessions');
+    ios
+        .command('create')
+        .description('Create a remote iOS simulator session')
+        .option('--model <iphone|ipad>', 'simulator model', 'iphone')
+        .option('--region <region>', 'fleet region')
+        .option('--display-name <name>', 'human-readable name')
+        .option('--label <key=value>', 'label to attach to the session', (v, p) => [...p, v], [])
+        .option('--install <file>', 'local .ipa, .zip, .tar.gz, or simulator .app archive to upload and install', (v, p) => [...p, v], [])
+        .option('--install-asset <name-or-id>', 'previously uploaded asset to install', (v, p) => [...p, v], [])
+        .option('--inactivity-timeout <duration>', 'auto-close idle timeout, e.g. 60s, 3m, or none')
+        .option('--hard-timeout <duration>', 'maximum lifetime, e.g. 10m or 1h')
+        .option('--rm', 'release the session when this command exits', false)
+        .option('--json', 'output JSON', false)
+        .action((opts) => action(async () => {
+        const uploadedAssets = [];
+        for (const file of opts.install ?? [])
+            uploadedAssets.push(await pushAsset(file));
+        const installAssets = [
+            ...(opts.installAsset ?? []),
+            ...uploadedAssets
+                .map((asset) => asset.id)
+                .filter((id) => typeof id === 'string' && id.length > 0),
+        ];
+        const session = await client().post('/run-cloud/ios', {
+            model: opts.model,
+            region: opts.region,
+            displayName: opts.displayName,
+            labels: parseLabels(opts.label),
+            installAssets,
+            inactivityTimeout: opts.inactivityTimeout,
+            hardTimeout: opts.hardTimeout,
+            autoDelete: opts.rm,
+        });
+        print(session, opts);
+    }));
+    ios
+        .command('list')
+        .description('List active iOS simulator sessions')
+        .option('--all', 'include released sessions', false)
+        .option('--json', 'output JSON', false)
+        .action((opts) => action(async () => {
+        const qs = opts.all ? '?all=1' : '';
+        print(await client().get(`/run-cloud/ios${qs}`), opts);
+    }));
+    ios
+        .command('get')
+        .description('Show an iOS simulator session')
+        .argument('<id>')
+        .option('--json', 'output JSON', false)
+        .action((id, opts) => action(async () => {
+        print(await client().get(`/run-cloud/ios/${encodeURIComponent(id)}`), opts);
+    }));
+    ios
+        .command('delete')
+        .description('Release an iOS simulator session')
+        .argument('<id>')
+        .option('--json', 'output JSON', false)
+        .action((id, opts) => action(async () => {
+        print(await client().delete(`/run-cloud/ios/${encodeURIComponent(id)}`), opts);
+    }));
+    ios
+        .command('open-url')
+        .description('Open a URL or deep link in an iOS simulator session')
+        .argument('<url>')
+        .requiredOption('--id <id>', 'session id')
+        .option('--json', 'output JSON', false)
+        .action((url, opts) => action(async () => {
+        print(await client().post(`/run-cloud/ios/${encodeURIComponent(opts.id)}/open-url`, { url }), opts);
+    }));
+    const asset = program
+        .command('asset')
+        .alias('assets')
+        .description('Upload, list, inspect, and delete run.cloud assets');
+    asset
+        .command('push')
+        .description('Upload an app asset for simulator installation')
+        .argument('<file>')
+        .option('-n, --name <name>', 'asset name')
+        .option('--json', 'output JSON', false)
+        .action((file, opts) => action(async () => {
+        print(await pushAsset(file, opts), opts);
+    }));
+    asset
+        .command('list')
+        .description('List uploaded assets')
+        .option('--json', 'output JSON', false)
+        .action((opts) => action(async () => {
+        print(await client().get('/run-cloud/assets'), opts);
+    }));
+    asset
+        .command('pull')
+        .description('Download an asset')
+        .argument('<id>')
+        .option('-o, --output <path>', 'output path')
+        .action((id, opts) => action(async () => {
+        const body = await client().getBinary(`/run-cloud/assets/${encodeURIComponent(id)}/download`);
+        const output = opts.output ?? id;
+        writeFileSync(output, body);
+        console.log(output);
+    }));
+    asset
+        .command('delete')
+        .description('Delete an uploaded asset')
+        .argument('<id>')
+        .option('--json', 'output JSON', false)
+        .action((id, opts) => action(async () => {
+        print(await client().delete(`/run-cloud/assets/${encodeURIComponent(id)}`), opts);
+    }));
+    const skills = program.command('skills').description('Install run.cloud skills for AI coding agents');
+    skills
+        .command('install')
+        .description('Install the run.cloud iOS simulator skill')
+        .option('--agents <agent>', 'agent to install for: claude, codex, cursor', (v, p) => [...p, v], [])
+        .option('--scope <project|global>', 'install scope', 'project')
+        .option('--force', 'overwrite existing skill', false)
+        .option('--json', 'output JSON', false)
+        .action((opts) => action(async () => {
+        const scope = opts.scope === 'global' ? 'global' : 'project';
+        print(installSkill({ ...opts, scope }), opts);
+    }));
+}

package/dist/commands/services.js

@@ -0,0 +1,39 @@
+import { friendlyApiError } from '../api.js';
+import { readProjectLink, resolveProject } from '../config.js';
+import { readBackendServices, serviceUrl } from '../services-manifest.js';
+export function renderServices(services = readBackendServices(process.cwd()), opts = {}) {
+    const lines = ['name  type    path          public  url'];
+    for (const service of services) {
+        const isPublic = service.public !== false;
+        const url = opts.projectId && isPublic ? serviceUrl(opts.projectId, opts.env ?? 'dev', service.name) : '-';
+        lines.push([
+            service.name.padEnd(5),
+            service.type.padEnd(7),
+            service.path.padEnd(13),
+            String(isPublic).padEnd(7),
+            url,
+        ].join(' '));
+    }
+    return lines.join('\n');
+}
+export function registerServices(program) {
+    const services = program.command('services').description('Inspect backend services');
+    services
+        .command('list')
+        .description('List backend services from backend/newly.services.json')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--project <id>', 'project id (defaults to the linked directory when present)')
+        .action(async (opts) => {
+        try {
+            if (opts.env !== 'dev' && opts.env !== 'prod')
+                throw new Error('--env must be dev or prod');
+            const projectId = opts.project ?? readProjectLink(process.cwd())?.projectId;
+            const resolved = projectId ? resolveProject(process.cwd(), projectId) : undefined;
+            console.log(renderServices(readBackendServices(process.cwd()), { projectId: resolved, env: opts.env }));
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/stack.js

@@ -1,25 +1,27 @@
 import { ApiClient, friendlyApiError } from '../api.js';
 import { requireCredentials, resolveProject } from '../config.js';
+export async function getStack(client, projectId) {
+    return (await client.get(`/newly_backend/stack/${projectId}`));
+}
+export function formatStack(out) {
+    const stack = out.stack ?? 'unknown';
+    const cli = out.cli_deployable
+        ? '✓ CLI-deployable — Newly backend'
+        : '✗ not CLI-deployable — use the Newly web app to deploy this project.';
+    return `stack: ${stack}\n${cli}`;
+}
 export function registerStack(program) {
     program
         .command('stack')
-        .description('Show which backend stack a project uses (newly-backend or specular)')
+        .description('Show which backend type a project uses and whether it supports CLI deploys')
         .option('--project <id>', 'project id (defaults to the linked directory)')
         .action(async (opts) => {
         try {
             const creds = requireCredentials();
             const projectId = resolveProject(process.cwd(), opts.project);
             const client = new ApiClient(creds.apiUrl, creds.token);
-            const out = await client.get(`/newly_backend/stack/${projectId}`);
-            const stack = out.stack ?? 'unknown';
-            console.log(`stack: ${stack}`);
-            if (out.cli_deployable) {
-                console.log('✓ CLI-deployable — Python api-service + Node auth-service');
-            }
-            else {
-                console.log('✗ not CLI-deployable — this project is on the Specular stack ' +
-                    '(a single Node/drizzle backend). `newly deploy` supports only the newly-backend stack.');
-            }
+            const out = await getStack(client, projectId);
+            console.log(formatStack(out));
         }
         catch (e) {
             console.error(friendlyApiError(e));

package/dist/commands/status.js

@@ -22,23 +22,23 @@ function renderProvisioningStages(s) {
             complete: true,
         },
         {
-            label: 'Cloud environment assigned',
-            note: 'dedicated cloud environment allocated for your backend',
+            label: 'Newly server assigned',
+            note: 'Newly server workspace allocated for your backend',
             complete: s.cloud_env_assigned,
         },
         {
-            label: 'Infrastructure provisioned',
-            note: 'container registry, storage buckets, IAM roles set up',
-            complete: s.neon_ready,
+            label: 'Newly resources provisioned',
+            note: 'Newly storage and backend services provisioned',
+            complete: s.database_ready,
         },
         {
-            label: 'Database created',
-            note: 'Postgres database ready for your API service',
-            complete: s.neon_ready,
+            label: 'Newly DB created',
+            note: 'Newly DB ready for your backend',
+            complete: s.database_ready,
         },
         {
-            label: 'Environment secrets wired',
-            note: 'DB credentials, API keys and auth tokens encrypted and stored',
+            label: 'Backend configuration stored',
+            note: 'Newly DB credentials, API keys, and auth settings encrypted and stored',
             complete: s.secrets_wired,
         },
         {

package/dist/commands/website.js

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { create as tarCreate } from 'tar';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { createSnapshot } from '../archive.js';
+import { requireCredentials, resolveProject } from '../config.js';
+function makeClient(project) {
+    const creds = requireCredentials();
+    return {
+        client: new ApiClient(creds.apiUrl, creds.token),
+        projectId: resolveProject(process.cwd(), project),
+    };
+}
+const BUILD_ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function renderDeployment(d) {
+    const at = d.published_at ?? d.created_at ?? '';
+    const suffix = d.error_message ? ` (${d.error_message})` : '';
+    return `${d.id}  ${d.status}${at ? `  ${at}` : ''}${suffix}`;
+}
+function archiveKib(size) {
+    return size < 1024 ? '<1' : Math.round(size / 1024).toString();
+}
+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 collect(value, previous) {
+    return [...previous, value];
+}
+function parseBuildEnvPair(pair) {
+    const index = pair.indexOf('=');
+    if (index <= 0)
+        throw new Error(`Invalid --build-env "${pair}" (expected KEY=value).`);
+    const key = pair.slice(0, index).trim();
+    const value = pair.slice(index + 1);
+    if (!BUILD_ENV_KEY.test(key)) {
+        throw new Error(`Invalid build env var name "${key}".`);
+    }
+    return [key, value];
+}
+function unquoteEnvValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed
+            .slice(1, -1)
+            .replace(/\\n/g, '\n')
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+    if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+export function parseBuildEnvFile(path) {
+    const env = {};
+    const body = readFileSync(path, 'utf8');
+    for (const [index, rawLine] of body.split(/\r?\n/).entries()) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const equals = line.indexOf('=');
+        if (equals <= 0)
+            throw new Error(`Invalid env file line ${index + 1}: expected KEY=value.`);
+        const key = line.slice(0, equals).trim();
+        if (!BUILD_ENV_KEY.test(key))
+            throw new Error(`Invalid env file key "${key}".`);
+        env[key] = unquoteEnvValue(line.slice(equals + 1));
+    }
+    return env;
+}
+export function parseBuildEnv(pairs = [], envFile) {
+    const env = envFile ? parseBuildEnvFile(envFile) : {};
+    for (const pair of pairs) {
+        const [key, value] = parseBuildEnvPair(pair);
+        env[key] = value;
+    }
+    return env;
+}
+export async function createStaticSiteArchive(dir) {
+    const root = resolve(dir);
+    assertDirectory(root, 'Static site directory');
+    if (!existsSync(`${root}/index.html`)) {
+        throw new Error(`Static site directory must contain index.html at its root: ${root}`);
+    }
+    const chunks = [];
+    const stream = tarCreate({
+        gzip: true,
+        cwd: root,
+        portable: true,
+        filter: (path) => {
+            const name = basename(path);
+            return name !== '.DS_Store' && name !== '.env' && !name.startsWith('.env.');
+        },
+    }, ['.']);
+    for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+export async function runWebsitePublish(client, projectId, opts = {}, log = console.log) {
+    let result;
+    if (opts.remoteBuild) {
+        const sourceDir = opts.localPath ?? '.';
+        assertDirectory(sourceDir, 'Website source directory');
+        log('Packaging website source...');
+        const archive = await createSnapshot(sourceDir);
+        log(`Uploading source snapshot (${archiveKib(archive.length)} KiB) for remote build...`);
+        const form = new FormData();
+        form.set('request', JSON.stringify({
+            build_env: opts.buildEnv ?? {},
+            build_command: opts.buildCommand,
+            output_dir: opts.outputDir,
+        }));
+        form.set('source', new Blob([new Uint8Array(archive)], { type: 'application/gzip' }), 'source.tar.gz');
+        result = (await client.uploadForm(`/projects/${projectId}/website/build-upload`, form));
+    }
+    else if (opts.localPath) {
+        log('Packaging static site...');
+        const archive = await createStaticSiteArchive(opts.localPath);
+        log(`Uploading static site (${archiveKib(archive.length)} KiB)...`);
+        result = (await client.upload(`/projects/${projectId}/website/publish-upload`, archive, 'application/gzip'));
+    }
+    else {
+        result = (await client.post(`/projects/${projectId}/website/publish`, {
+            source_path: opts.sourcePath ?? 'website/out',
+        }));
+    }
+    log(`Published ${result.deployment.id}`);
+    log(`URL: ${result.default_url}`);
+}
+export async function runWebsiteDeployments(client, projectId, log = console.log) {
+    const result = (await client.get(`/projects/${projectId}/website/deployments`));
+    const deployments = result.deployments ?? [];
+    if (deployments.length === 0) {
+        log('No website deployments yet.');
+        return;
+    }
+    log(deployments.map(renderDeployment).join('\n'));
+}
+export async function runWebsiteRollback(client, projectId, deploymentId, log = console.log) {
+    const result = (await client.post(`/projects/${projectId}/website/rollback`, {
+        deployment_id: deploymentId,
+    }));
+    log(`Rolled back to ${result.deployment.id}`);
+}
+export function registerWebsite(program) {
+    const website = program.command('website').description('Publish and manage static website deployments');
+    website
+        .command('publish')
+        .description('Publish a static website directory to Cloudflare')
+        .argument('[path]', 'local static output directory to upload, for example ./dist')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--source-path <path>', 'committed static export path in project storage')
+        .option('--remote-build', 'upload source files and ask the backend to build dist remotely', false)
+        .option('--build-env <KEY=value>', 'build-time env var for --remote-build (repeatable)', collect, [])
+        .option('--build-env-file <path>', 'dotenv-style file of build-time env vars for --remote-build')
+        .option('--build-command <command>', 'build command for --remote-build')
+        .option('--output-dir <path>', 'static output directory produced by --remote-build')
+        .action(async (localPath, opts) => {
+        try {
+            if (localPath && opts.sourcePath) {
+                throw new Error('Pass either a local path or --source-path, not both.');
+            }
+            if (opts.remoteBuild && opts.sourcePath) {
+                throw new Error('--remote-build uploads local source and cannot be combined with --source-path.');
+            }
+            if (!opts.remoteBuild &&
+                (opts.buildEnv.length > 0 || opts.buildEnvFile || opts.buildCommand || opts.outputDir)) {
+                throw new Error('--build-env, --build-env-file, --build-command, and --output-dir require --remote-build.');
+            }
+            const { client, projectId } = makeClient(opts.project);
+            await runWebsitePublish(client, projectId, {
+                localPath,
+                sourcePath: opts.sourcePath,
+                remoteBuild: opts.remoteBuild,
+                buildEnv: parseBuildEnv(opts.buildEnv, opts.buildEnvFile),
+                buildCommand: opts.buildCommand,
+                outputDir: opts.outputDir,
+            });
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    website
+        .command('deployments')
+        .description('List website deployments')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runWebsiteDeployments(client, projectId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    website
+        .command('rollback')
+        .description('Rollback website domains to a previous deployment')
+        .argument('<deployment-id>')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .action(async (deploymentId, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runWebsiteRollback(client, projectId, deploymentId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/config.js

@@ -1,23 +1,49 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-function newlyHome() {
+import { basename, join } from 'node:path';
+function credentialsHome() {
+    if (process.env.RUN_CLOUD_HOME)
+        return process.env.RUN_CLOUD_HOME;
+    if (process.env.NEWLY_HOME)
+        return process.env.NEWLY_HOME;
+    const invoked = basename(process.argv[1] ?? '');
+    if (invoked === 'runcloud' || invoked === 'run-cloud.js')
+        return join(homedir(), '.run-cloud');
     return process.env.NEWLY_HOME ?? join(homedir(), '.newly');
 }
 function credentialsPath() {
-    return join(newlyHome(), 'credentials');
+    return join(credentialsHome(), 'credentials');
+}
+export function credentialsDisplayPath() {
+    const path = credentialsPath();
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+function loginCommandName() {
+    const invoked = basename(process.argv[1] ?? '');
+    return invoked === 'runcloud' || invoked === 'run-cloud.js' ? 'runcloud login' : 'newly login';
 }
 export function normalizeApiUrl(url) {
     const trimmed = url.replace(/\/+$/, '');
     return trimmed.endsWith('/api') ? trimmed : `${trimmed}/api`;
 }
 export function saveCredentials(creds) {
-    mkdirSync(newlyHome(), { recursive: true, mode: 0o700 });
+    mkdirSync(credentialsHome(), { recursive: true, mode: 0o700 });
     const normalized = { ...creds, apiUrl: normalizeApiUrl(creds.apiUrl) };
     writeFileSync(credentialsPath(), JSON.stringify(normalized, null, 2) + '\n', { mode: 0o600 });
     chmodSync(credentialsPath(), 0o600);
 }
 export function loadCredentials() {
+    const envToken = process.env.NEWLY_API_TOKEN ?? process.env.NEWLY_CLI_TOKEN;
+    const envApiUrl = process.env.NEWLY_API_URL ?? process.env.NEWLY_API_HOST ?? process.env.NEXT_PUBLIC_API_HOST;
+    if (envToken?.trim() && envApiUrl?.trim()) {
+        return {
+            token: envToken.trim(),
+            apiUrl: normalizeApiUrl(envApiUrl.trim()),
+            appUrl: process.env.NEWLY_APP_URL ?? 'https://newly.dev',
+            expiresAt: Number.MAX_SAFE_INTEGER,
+        };
+    }
     if (!existsSync(credentialsPath()))
         return null;
     try {
@@ -36,7 +62,7 @@ export function clearCredentials() {
 export function requireCredentials() {
     const creds = loadCredentials();
     if (!creds) {
-        throw new Error('Not logged in (or session expired). Run: newly login');
+        throw new Error(`Not logged in (or session expired). Run: ${loginCommandName()}`);
     }
     return creds;
 }