@newly/cli 0.1.0 → 0.1.1

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

@@ -6,9 +6,15 @@ 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';
 const program = new Command('newly')
     .description('Develop, provision, and deploy Newly backends')
     .version('0.1.0');
@@ -18,7 +24,13 @@ 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);
 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/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,13 +1,14 @@
 {
   "name": "@newly/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Develop, provision, and deploy Newly backends from your terminal",
   "license": "UNLICENSED",
   "type": "module",
-  "bin": { "newly": "dist/index.js" },
+  "bin": { "newly": "dist/index.js", "newly-dev": "dist/newly-dev.js" },
   "files": ["dist"],
   "engines": { "node": ">=20" },
   "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc",
     "dev": "tsx src/index.ts",
     "lint": "eslint src",

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;
-        }
-    });
-}