@newly/cli 0.1.0 → 0.1.2

package/dist/diagnose.js

@@ -0,0 +1,159 @@
+const DEFAULT_URLS = {
+    dev: {
+        apiOps: 'https://cp-api-ops-dev.newly.app',
+        worker: 'https://cp-worker-dev.newly.app',
+    },
+    prod: {
+        apiOps: 'https://cp-api-ops-prod.newly.app',
+        worker: 'https://cp-worker-prod.newly.app',
+    },
+};
+function stripSlash(url) {
+    return url.replace(/\/+$/, '');
+}
+export function resolveTargets(env) {
+    if (env !== 'dev' && env !== 'prod') {
+        throw new Error(`--env must be dev or prod (got "${env}")`);
+    }
+    const upper = env.toUpperCase();
+    const apiOps = process.env[`DIAGNOSE_CP_API_OPS_URL_${upper}`] ??
+        process.env.DIAGNOSE_CP_API_OPS_URL ??
+        DEFAULT_URLS[env].apiOps;
+    const worker = process.env[`DIAGNOSE_CP_WORKER_URL_${upper}`] ??
+        process.env.DIAGNOSE_CP_WORKER_URL ??
+        DEFAULT_URLS[env].worker;
+    return [
+        { service: 'cp-api', url: stripSlash(apiOps) },
+        { service: 'cp-worker', url: stripSlash(worker) },
+    ];
+}
+function extractAuthorization(headers) {
+    if (headers instanceof Headers) {
+        return headers.get('authorization') ?? undefined;
+    }
+    const h = headers;
+    return h?.Authorization ?? h?.authorization;
+}
+export async function resolveOpsAuthHeader(env = process.env) {
+    const audience = env.DIAGNOSE_OIDC_AUDIENCE ?? 'newly-diagnose-ops';
+    try {
+        const { GoogleAuth } = await import('google-auth-library');
+        const auth = new GoogleAuth();
+        const client = await auth.getIdTokenClient(audience);
+        const authz = extractAuthorization(await client.getRequestHeaders());
+        if (authz) {
+            return authz;
+        }
+    }
+    catch {
+    }
+    const token = env.DIAGNOSE_OPS_TOKEN;
+    if (token) {
+        return `Bearer ${token}`;
+    }
+    throw new Error('No ops credential available. Run `gcloud auth application-default login` (ADC/OIDC), ' +
+        'or export DIAGNOSE_OPS_TOKEN with the break-glass ops token.');
+}
+function truncate(value, max = 200) {
+    const trimmed = value.trim();
+    return trimmed.length > max ? `${trimmed.slice(0, max)}...` : trimmed;
+}
+export async function fetchDiagnose(target, authHeader) {
+    try {
+        const res = await fetch(`${target.url}/diagnose`, { headers: { Authorization: authHeader } });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return {
+                service: target.service,
+                error: `HTTP ${res.status}${body ? `: ${truncate(body)}` : ''}`,
+            };
+        }
+        return (await res.json());
+    }
+    catch (e) {
+        return { service: target.service, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function isDoc(result) {
+    return !('error' in result);
+}
+export function rollupVerdict(services) {
+    const names = Object.keys(services);
+    const down = names.filter((name) => !isDoc(services[name]));
+    if (down.length) {
+        return `DOWN - unreachable: ${down.join(', ')}`;
+    }
+    const degraded = [];
+    for (const name of names) {
+        const doc = services[name];
+        const bad = Object.entries(doc.health)
+            .filter(([, probe]) => !probe.ok)
+            .map(([probeName]) => probeName);
+        if (bad.length) {
+            degraded.push(`${name} (${bad.join(', ')})`);
+        }
+    }
+    if (degraded.length) {
+        return `DEGRADED - ${degraded.join('; ')}`;
+    }
+    return `OK - ${names.length} service(s) healthy`;
+}
+export async function fanoutDiagnose(env) {
+    const targets = resolveTargets(env);
+    const authHeader = await resolveOpsAuthHeader();
+    const results = await Promise.all(targets.map((target) => fetchDiagnose(target, authHeader)));
+    const services = {};
+    results.forEach((result, index) => {
+        services[targets[index].service] = result;
+    });
+    return { rollup: rollupVerdict(services), services };
+}
+export function renderRollup(result, session) {
+    const lines = [result.rollup];
+    if (session) {
+        lines.push(`session: ${session}`);
+    }
+    lines.push('');
+    for (const [name, service] of Object.entries(result.services)) {
+        if (!isDoc(service)) {
+            lines.push(`${name}: UNREACHABLE - ${service.error}`);
+            continue;
+        }
+        const sha = service.deploy.git_sha ?? '(sha unknown)';
+        const revision = service.deploy.revision ?? '(revision unknown)';
+        lines.push(`${name}: ${sha} @ ${revision} [env=${service.env}]`);
+        const badProbes = Object.entries(service.health)
+            .filter(([, probe]) => !probe.ok)
+            .map(([probeName, probe]) => `${probeName}${probe.detail ? ` (${probe.detail})` : ''}`);
+        lines.push(`  health: ${badProbes.length ? `DEGRADED - ${badProbes.join(', ')}` : 'all ok'}`);
+        for (const verdict of service.diagnosis) {
+            lines.push(`  - ${verdict}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function registerDiagnose(program) {
+    program
+        .command('diagnose')
+        .description('Fan out /diagnose across control-plane services and roll up a verdict (dev/ops only)')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--session <id>', 'annotate the rollup with a session id you are investigating')
+        .option('--json', 'emit the merged JSON document instead of the human rollup')
+        .action(async (opts) => {
+        try {
+            if (opts.env !== 'dev' && opts.env !== 'prod') {
+                throw new Error('--env must be dev or prod');
+            }
+            const result = await fanoutDiagnose(opts.env);
+            if (opts.json) {
+                console.log(JSON.stringify({ session: opts.session ?? null, ...result }, null, 2));
+                return;
+            }
+            console.log(renderRollup(result, opts.session));
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/index.js

@@ -6,9 +6,16 @@ import { registerLink } from './commands/link.js';
 import { registerCreate } from './commands/create.js';
 import { registerPull } from './commands/pull.js';
 import { registerDeploy } from './commands/deploy.js';
-import { registerUp } from './commands/up.js';
 import { registerMisc } from './commands/misc.js';
 import { registerStack } from './commands/stack.js';
+import { registerCreds } from './commands/creds.js';
+import { registerBuild } from './commands/build.js';
+import { registerServices } from './commands/services.js';
+import { registerEmail } from './commands/email.js';
+import { registerWebsite } from './commands/website.js';
+import { registerDomains } from './commands/domains.js';
+import { registerDns } from './commands/dns.js';
+import { registerDiagnose } from './diagnose.js';
 const program = new Command('newly')
     .description('Develop, provision, and deploy Newly backends')
     .version('0.1.0');
@@ -18,7 +25,14 @@ registerLink(program);
 registerCreate(program);
 registerPull(program);
 registerDeploy(program);
-registerUp(program);
 registerMisc(program);
 registerStack(program);
+registerCreds(program);
+registerBuild(program);
+registerServices(program);
+registerEmail(program);
+registerWebsite(program);
+registerDomains(program);
+registerDns(program);
+registerDiagnose(program);
 await program.parseAsync(process.argv);

package/dist/newly-dev.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+if (!process.env.NEWLY_HOME) {
+    process.env.NEWLY_HOME = process.env.NEWLY_DEV_HOME ?? join(homedir(), '.newly-dev');
+}
+if (!process.env.NEWLY_APP_URL && process.env.NEWLY_DEV_APP_URL) {
+    process.env.NEWLY_APP_URL = process.env.NEWLY_DEV_APP_URL;
+}
+await import('./index.js');

package/dist/run-cloud.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerLogin } from './commands/login.js';
+import { registerRunCloud } from './commands/run-cloud.js';
+const program = new Command('runcloud')
+    .description('Create and control remote iOS simulator sessions')
+    .version('0.1.0');
+registerLogin(program);
+registerRunCloud(program);
+await program.parseAsync(process.argv);

package/dist/services-manifest.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const DEFAULT_BACKEND_SERVICES = [
+    { name: 'api', path: 'api-service', type: 'worker', schema: 'api', secrets: 'api', public: true },
+    { name: 'auth', path: 'auth-service', type: 'worker', schema: 'auth', secrets: 'auth', public: true },
+];
+const SERVICE_NAME = /^[a-z][a-z0-9-]{0,31}$/;
+export function readBackendServices(dir) {
+    const manifestPath = join(dir, 'backend', 'newly.services.json');
+    if (!existsSync(manifestPath))
+        return DEFAULT_BACKEND_SERVICES;
+    const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    if (!Array.isArray(parsed.services) || parsed.services.length === 0) {
+        throw new Error('backend/newly.services.json must contain a non-empty services array');
+    }
+    return parsed.services.map((raw) => {
+        if (!raw || typeof raw !== 'object')
+            throw new Error('Invalid service entry in newly.services.json');
+        const entry = raw;
+        const name = String(entry.name ?? '');
+        const path = String(entry.path ?? '');
+        const type = String(entry.type ?? 'worker');
+        if (!SERVICE_NAME.test(name))
+            throw new Error(`Invalid service name in newly.services.json: ${name}`);
+        if (!path)
+            throw new Error(`Service ${name} is missing path`);
+        if (type !== 'worker')
+            throw new Error(`Service ${name} has unsupported type: ${type}`);
+        return {
+            name,
+            path,
+            type,
+            schema: entry.schema === undefined ? undefined : entry.schema === null ? null : String(entry.schema),
+            secrets: entry.secrets === undefined ? undefined : String(entry.secrets),
+            public: entry.public === undefined ? true : Boolean(entry.public),
+        };
+    });
+}
+export function parseServiceFilter(value) {
+    if (!value)
+        return [];
+    const names = value
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const name of names) {
+        if (!SERVICE_NAME.test(name))
+            throw new Error(`Invalid service name: ${name}`);
+    }
+    return names;
+}
+export function assertKnownServices(services, selected) {
+    if (selected.length === 0)
+        return;
+    const known = new Set(services.map((s) => s.name));
+    const unknown = selected.filter((s) => !known.has(s));
+    if (unknown.length)
+        throw new Error(`Unknown service(s): ${unknown.join(', ')}`);
+}
+export function serviceUrl(projectId, env, service) {
+    const suffix = env === 'prod' ? 'api.newlyapp.com' : 'api-dev.newlyapp.com';
+    return `https://${service}-${projectId}-${env}.${suffix}`;
+}

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@newly/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Develop, provision, and deploy Newly backends from your terminal",
   "license": "UNLICENSED",
   "type": "module",
-  "bin": { "newly": "dist/index.js" },
-  "files": ["dist"],
-  "engines": { "node": ">=20" },
+  "bin": {
+    "newly": "dist/index.js",
+    "newly-dev": "dist/newly-dev.js",
+    "runcloud": "dist/run-cloud.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc",
+    "build:run-cloud": "tsc && node dist/run-cloud.js --help >/dev/null",
     "dev": "tsx src/index.ts",
     "lint": "eslint src",
     "test": "vitest run",
@@ -16,6 +26,7 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
+    "google-auth-library": "^9.15.0",
     "tar": "^7.4.3"
   },
   "devDependencies": {

package/dist/commands/up.js

@@ -1,85 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { ApiClient, ApiError, friendlyApiError } from '../api.js';
-import { requireCredentials, resolveProject } from '../config.js';
-import { runDevDeploy, runProdDeploy } from './deploy.js';
-function defaultHasLocalBackend(dir) {
-    return existsSync(join(dir, 'backend', 'scripts', 'deploy.sh'));
-}
-export async function runUp(deps) {
-    const { client, projectId, env, region, cwd, print, hasLocalBackend = defaultHasLocalBackend, deployDev = runDevDeploy, deployProd = runProdDeploy, } = deps;
-    const stackInfo = await client.get(`/newly_backend/stack/${projectId}`);
-    if (!stackInfo.cli_deployable) {
-        throw new Error('This project is on the Specular stack (a single Node/drizzle backend), which `newly up` does not support. ' +
-            'Only newly-backend-stack projects (Python api-service + Node auth-service) are CLI-deployable.');
-    }
-    const status = await client.get(`/newly_backend/status/${projectId}`);
-    if (status[env]) {
-        print(`${env} backend already provisioned (status: ${status[env].status}).`);
-    }
-    else {
-        print(`Provisioning ${env} backend…`);
-        if (env === 'dev') {
-            await client.post(`/newly_backend/provision_dev/${projectId}`, {
-                dev_region: region,
-            });
-            print('Provisioned dev backend.');
-        }
-        else {
-            await client.post(`/newly_backend/provision_prod/${projectId}`);
-            print('Provisioned prod backend.');
-        }
-    }
-    if (env === 'dev') {
-        if (!hasLocalBackend(cwd)) {
-            print('Provisioned. No backend code in this directory — nothing to deploy yet.\n' +
-                'Run `newly pull ' + projectId + '` to get the project code, or develop on the ' +
-                'platform; the backend goes active on its first deploy.');
-            return;
-        }
-        await deployDev(projectId, client, cwd);
-    }
-    else {
-        await deployProd(projectId, client);
-    }
-    const finalStatus = await client.get(`/newly_backend/status/${projectId}`);
-    const s = finalStatus[env];
-    if (s) {
-        print(`\n${env} backend: ${s.status}`);
-        print(`  auth: ${s.auth_hostname}`);
-        print(`  api:  ${s.api_hostname}`);
-    }
-}
-export function registerUp(program) {
-    program
-        .command('up')
-        .description('Provision (if needed) and deploy the backend (dev only; prod ships via Promote in the web app)')
-        .option('--env <env>', 'dev (prod is not supported via the CLI yet)', 'dev')
-        .option('--region <region>', 'region for dev provisioning', 'us-central1')
-        .option('--project <id>', 'project id (defaults to the linked directory)')
-        .option('--yes', 'skip the prod confirmation prompt', false)
-        .action(async (opts) => {
-        try {
-            if (opts.env !== 'dev' && opts.env !== 'prod')
-                throw new Error('--env must be dev or prod');
-            if (opts.env === 'prod') {
-                throw new Error('Prod provisioning/deploys are not supported via the CLI yet — use Promote in the Newly web app.');
-            }
-            const creds = requireCredentials();
-            const projectId = resolveProject(process.cwd(), opts.project);
-            const client = new ApiClient(creds.apiUrl, creds.token);
-            await runUp({
-                client,
-                projectId,
-                env: opts.env,
-                region: opts.region,
-                cwd: process.cwd(),
-                print: console.log,
-            });
-        }
-        catch (e) {
-            console.error(e instanceof ApiError ? friendlyApiError(e) : String(e instanceof Error ? e.message : e));
-            process.exitCode = 1;
-        }
-    });
-}