@saws/cli 2.0.0-beta.0 → 2.0.0-beta.3

package/dist/commands/host/command.js

@@ -1,14 +1,42 @@
-import { getSawsConfig } from "@saws/core";
+import { execFile } from "node:child_process";
+import { chmod, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { ParameterNotFoundError, SecretsManager, ServiceDefinition, getSawsConfigModule, hostSshPublicKeyEnvName, } from "@saws/core";
 import { findConfiguredHosts } from "../../hosts.js";
 export async function configureHostCommand(name, options) {
-    const root = await getSawsConfig(options.config);
-    const hosts = findConfiguredHosts(root);
-    const host = selectHost(hosts, name);
-    await host.configure({ dryRun: options.dryRun });
+    const config = await getSawsConfigModule(options.config);
+    if (!(config.secrets instanceof SecretsManager)) {
+        throw new Error('saws.ts must export a SecretsManager instance named "secrets"');
+    }
+    if (!(config.default instanceof ServiceDefinition)) {
+        throw new Error("saws.ts must default-export a ServiceDefinition");
+    }
+    const host = selectHost(findConfiguredHosts(config.default), name);
+    validatePrivateKeyReference(host, config.secrets);
+    if (options.dryRun) {
+        await host.configure({
+            bootstrapUser: options.user,
+            deploymentPublicKey: "[redacted deployment public key]",
+            dryRun: true,
+        });
+        return;
+    }
+    const { privateKey, created } = await getOrCreateDeploymentKey(config.secrets, host);
+    const publicKey = await derivePublicKey(privateKey);
+    if (created) {
+        await config.secrets.global.set(host.sshPrivateKey.name, privateKey);
+    }
+    await updatePublicKeyEnvironment(config.secrets.rootDir, hostSshPublicKeyEnvName(host.name), publicKey);
+    await host.configure({
+        bootstrapUser: options.user,
+        deploymentPublicKey: publicKey,
+    });
 }
 export function selectHost(hosts, name) {
     if (hosts.length === 0) {
-        throw new Error("No Docker hosts are configured");
+        throw new Error("No hosts are configured");
     }
     const host = name == null
         ? hosts.length === 1
@@ -17,8 +45,103 @@ export function selectHost(hosts, name) {
         : hosts.find((candidate) => candidate.name === name);
     if (host != null)
         return host;
-    const available = hosts.map((candidate) => candidate.name).sort().join(", ");
+    const available = hosts
+        .map((candidate) => candidate.name)
+        .sort()
+        .join(", ");
     throw new Error(name == null
         ? `Host name is required. Available hosts: ${available}`
         : `Host "${name}" was not found. Available hosts: ${available}`);
 }
+function validatePrivateKeyReference(host, manager) {
+    if (host.sshPrivateKey == null || host.sshPrivateKey.scope !== "global") {
+        throw new Error(`Host "${host.name}" must configure sshPrivateKey with secrets.global.reference(...)`);
+    }
+    if (!host.sshPrivateKey.isManagedBy(manager)) {
+        throw new Error(`Host "${host.name}" sshPrivateKey must use the SecretsManager exported as "secrets"`);
+    }
+}
+async function getOrCreateDeploymentKey(manager, host) {
+    try {
+        return {
+            privateKey: await manager.global.get(host.sshPrivateKey.name),
+            created: false,
+        };
+    }
+    catch (error) {
+        if (!(error instanceof ParameterNotFoundError))
+            throw error;
+    }
+    return {
+        privateKey: await generatePrivateKey(),
+        created: true,
+    };
+}
+async function generatePrivateKey() {
+    return withTemporaryDirectory(async (directory) => {
+        const keyPath = path.join(directory, "id_ed25519");
+        await execFileAsync("ssh-keygen", ["-q", "-t", "ed25519", "-N", "", "-f", keyPath]);
+        return readFile(keyPath, "utf8");
+    });
+}
+async function derivePublicKey(privateKey) {
+    return withTemporaryDirectory(async (directory) => {
+        const keyPath = path.join(directory, "id_ed25519");
+        await writeFile(keyPath, privateKey, { mode: 0o600 });
+        const { stdout } = await execFileAsync("ssh-keygen", ["-y", "-f", keyPath]);
+        const publicKey = stdout.trim();
+        if (publicKey.length === 0) {
+            throw new Error("Could not derive the deployment public key");
+        }
+        return publicKey;
+    });
+}
+async function withTemporaryDirectory(callback) {
+    const directory = await mkdtemp(path.join(tmpdir(), "saws-key-"));
+    try {
+        return await callback(directory);
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+async function updatePublicKeyEnvironment(rootDir, variableName, publicKey) {
+    const envPath = path.resolve(rootDir, ".env");
+    let contents = "";
+    try {
+        contents = await readFile(envPath, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const matcher = new RegExp(`^(?:export\\s+)?${escapeRegExp(variableName)}\\s*=`);
+    const lines = contents.split(/\r?\n/);
+    const replacement = `${variableName}=${publicKey}`;
+    let replaced = false;
+    const updated = lines.flatMap((line) => {
+        if (!matcher.test(line))
+            return [line];
+        if (replaced)
+            return [];
+        replaced = true;
+        return [replacement];
+    });
+    while (updated.at(-1) === "")
+        updated.pop();
+    if (!replaced)
+        updated.push(replacement);
+    const temporaryPath = `${envPath}.${process.pid}.tmp`;
+    try {
+        await writeFile(temporaryPath, `${updated.join("\n")}\n`, { mode: 0o600 });
+        await rename(temporaryPath, envPath);
+        await chmod(envPath, 0o600);
+    }
+    finally {
+        await rm(temporaryPath, { force: true });
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const execFileAsync = promisify(execFile);

package/dist/commands/host/index.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const createCommand: () => Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/host/index.js

@@ -3,8 +3,9 @@ import { configureHostCommand } from "./command.js";
 export const createCommand = () => new Command("host")
     .description("configure deployment hosts")
     .addCommand(new Command("configure")
-    .description("install Docker and apply the configured security policy")
+    .description("bootstrap a deployment user and apply host security policy")
     .argument("[name]", "host name; optional when exactly one host exists")
-    .option("--config <string>", "path to service definition")
-    .option("--dry-run", "print the remote configuration command")
+    .requiredOption("--user <bootstrap-user>", "existing SSH account used for initial configuration")
+    .option("--config <path>", "path to saws.ts")
+    .option("--dry-run", "describe configuration without making changes")
     .action(configureHostCommand));

package/dist/commands/init/command.d.ts

@@ -1,7 +1 @@
-export interface InitCommandOptions {
-    rootDir?: string;
-    config?: string;
-    dryRun?: boolean;
-}
-export declare function initCommand(serviceName: string, path: string | undefined, options: InitCommandOptions): Promise<void>;
-//# sourceMappingURL=command.d.ts.map
+export declare const initCommand: (serviceName?: string, configPath?: string) => Promise<void>;

package/dist/commands/init/command.js

@@ -1,15 +1,24 @@
-import { findServiceDefinition, getSawsConfig, InitContext, } from "@saws/core";
-export async function initCommand(serviceName, path, options) {
-    const rootDir = options.rootDir ?? process.cwd();
-    const rootService = await getSawsConfig(options.config ?? path);
-    const service = findServiceDefinition(rootService, serviceName);
-    await service.init(new InitContext({
-        stage: "local",
-        rootDir,
-        dryRun: options.dryRun ?? false,
-        env: process.env,
-        logSink: ({ stream, chunk }) => {
-            (stream === "stderr" ? process.stderr : process.stdout).write(chunk);
-        },
-    }));
-}
+import path from "node:path";
+import fs from "node:fs/promises";
+import { findServiceDefinition, getSawsConfig } from "@saws/core";
+import { installDependencies } from "@saws/core/utils/dependency-management";
+import { createFileIfNotExists } from "@saws/core/utils/create-file-if-not-exists";
+import { sawsTsTemplate } from "./templates/saws-ts.template.js";
+import { tsconfigJsonTemplate } from "./templates/tsconfig-json.template.js";
+import { gitignoreTemplate } from "./templates/gitignore.template.js";
+export const initCommand = async (serviceName, configPath) => {
+    if (serviceName != null) {
+        const serviceDefinition = await getSawsConfig(configPath);
+        await findServiceDefinition(serviceDefinition, serviceName).init();
+        return;
+    }
+    const name = path.parse(path.resolve(".")).name;
+    // not used for now
+    await installDependencies([]);
+    await installDependencies(["@saws/core", "typescript", "@tsconfig/node26"], {
+        development: true,
+    });
+    await fs.writeFile("./tsconfig.json", tsconfigJsonTemplate(), {});
+    await createFileIfNotExists("./saws.ts", sawsTsTemplate({ name }));
+    await createFileIfNotExists("./.gitignore", gitignoreTemplate());
+};

package/dist/commands/init/index.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const createCommand: () => Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/init/index.js

@@ -1,10 +1,6 @@
 import { Command } from "commander";
 import { initCommand } from "./command.js";
 export const createCommand = () => new Command("init")
-    .description("bootstrap one configured service and its dependencies")
-    .argument("<service>", "name of the service to initialize")
+    .argument("[service]", "name of the service to initialize")
     .argument("[config]", "path to service definition")
-    .option("--root-dir <string>", "project root used for generated files")
-    .option("--config <string>", "path to service definition")
-    .option("--dry-run", "allow service initializers to preview their changes")
     .action(initCommand);

package/dist/commands/init/templates/gitignore.template.d.ts

@@ -0,0 +1 @@
+export declare const gitignoreTemplate: () => string;

package/dist/commands/init/templates/gitignore.template.js

@@ -0,0 +1,4 @@
+export const gitignoreTemplate = () => `node_modules
+.saws/saws-*-local-output.json
+.saws/.secrets
+.DS_Store`;

package/dist/commands/init/templates/saws-ts.template.d.ts

@@ -0,0 +1,3 @@
+export declare const sawsTsTemplate: ({ name }: {
+    name: string;
+}) => string;

package/dist/commands/init/templates/saws-ts.template.js

@@ -0,0 +1,7 @@
+export const sawsTsTemplate = ({ name }) => `import { ServiceDefinition } from "@saws/core";
+
+export default new ServiceDefinition({
+  name: "${name}",
+  dependencies: [],
+});
+`;

package/dist/commands/init/templates/tsconfig-json.template.d.ts

@@ -0,0 +1 @@
+export declare const tsconfigJsonTemplate: () => string;

package/dist/commands/init/templates/tsconfig-json.template.js

@@ -0,0 +1,4 @@
+export const tsconfigJsonTemplate = () => /* json */ `{
+  "extends": "@tsconfig/node26/tsconfig.json",
+  "files": []
+}`;

package/dist/commands/secrets/command.d.ts

@@ -1,8 +1,8 @@
 export interface SecretsCommandOptions {
+    config?: string;
     stage?: string;
+    global?: boolean;
     set?: string;
     get?: boolean;
-    rootDir?: string;
 }
 export declare function secretsCommand(name: string, options: SecretsCommandOptions): Promise<void>;
-//# sourceMappingURL=command.d.ts.map

package/dist/commands/secrets/command.js

@@ -1,16 +1,28 @@
-import { SecretsManager } from "@saws/secrets";
+import { getSawsConfigModule, SecretsManager } from "@saws/core";
 export async function secretsCommand(name, options) {
-    const manager = new SecretsManager({
-        stage: options.stage ?? "local",
-        rootDir: options.rootDir ?? process.cwd(),
-    });
+    const value = options.set;
+    if (options.get && value != null) {
+        throw new Error("secrets accepts only one of --get or --set <value>");
+    }
+    if (!options.get && value == null) {
+        throw new Error("secrets requires either --get or --set <value>");
+    }
+    if (!options.global) {
+        process.env.STAGE = options.stage ?? "local";
+    }
+    const config = await getSawsConfigModule(options.config);
+    const manager = config.secrets;
+    if (!(manager instanceof SecretsManager)) {
+        throw new Error('saws.ts must export a SecretsManager instance named "secrets"');
+    }
+    const secrets = options.global ? manager.global : manager;
     if (options.get) {
-        console.log(await manager.get(name));
+        console.log(await secrets.get(name));
         return;
     }
-    if (options.set == null) {
-        throw new Error("secrets requires either --get or --set <value>");
+    if (value == null) {
+        throw new Error("secrets requires --set <value>");
     }
-    await manager.set(name, options.set);
+    await secrets.set(name, value);
     console.log("Set secret");
 }

package/dist/commands/secrets/index.d.ts

@@ -1,3 +1,2 @@
 import { Command } from "commander";
 export declare const createCommand: () => Command;
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/secrets/index.js

@@ -1,9 +1,11 @@
 import { Command } from "commander";
 import { secretsCommand } from "./command.js";
 export const createCommand = () => new Command("secrets")
-    .argument("<string>", "secret name")
-    .option("--stage <string>", "stage", "local")
-    .option("--set <string>", "set secret value")
-    .option("--get", "get secret value")
-    .option("--root-dir <string>", "project root used for local secrets")
+    .description("get or set encrypted project secrets")
+    .argument("<name>", "secret name")
+    .option("--stage <string>", "stage for a stage-scoped secret", "local")
+    .option("--global", "use the global secret scope")
+    .option("--set <string>", "set the secret value")
+    .option("--get", "get the secret value")
+    .option("--config <string>", "path to service definition")
     .action(secretsCommand);

package/dist/hosts.d.ts

@@ -1,4 +1,2 @@
-import { Host } from "@saws/host";
-import type { ServiceDefinition } from "@saws/core";
+import { Host, type ServiceDefinition } from "@saws/core";
 export declare function findConfiguredHosts(root: ServiceDefinition): Host[];
-//# sourceMappingURL=hosts.d.ts.map

package/dist/hosts.js

@@ -1,16 +1,17 @@
-import { Host } from "@saws/host";
+import { Host } from "@saws/core";
 export function findConfiguredHosts(root) {
     const hosts = new Set();
-    const visited = new Set();
-    const visit = (service) => {
-        if (visited.has(service))
+    const visited = new WeakSet();
+    const visit = (value) => {
+        if (value == null || typeof value !== "object" || visited.has(value))
             return;
-        visited.add(service);
-        const host = service.docker?.host;
-        if (host instanceof Host)
-            hosts.add(host);
-        for (const dependency of service.dependencies)
-            visit(dependency);
+        visited.add(value);
+        if (value instanceof Host) {
+            hosts.add(value);
+            return;
+        }
+        for (const child of Object.values(value))
+            visit(child);
     };
     visit(root);
     return [...hosts];

package/package.json

@@ -1,34 +1,17 @@
 {
   "name": "@saws/cli",
-  "version": "2.0.0-beta.0",
-  "description": "Command-line interface for SAWS",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shichongrui/saws.git",
-    "directory": "packages/cli"
-  },
-  "type": "module",
+  "version": "2.0.0-beta.3",
+  "description": "",
   "bin": {
-    "saws": "dist/bin/saws.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "prebuild": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
-    "build": "tsc -p tsconfig.json",
-    "postbuild": "chmod +x dist/bin/saws.js",
-    "test": "npm run build && node --test dist/commands/**/*.test.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "saws": "./dist/bin/saws.js"
   },
+  "type": "module",
   "dependencies": {
-    "@saws/core": "2.0.0-beta.0",
-    "@saws/host": "2.0.0-beta.0",
-    "@saws/secrets": "2.0.0-beta.0",
-    "commander": "^14.0.3"
+    "@saws/core": "2.0.0-beta.3",
+    "commander": "^15.0.0",
+    "find-package-json": "^1.2.0"
   },
   "devDependencies": {
-    "@types/node": "^20.11.19",
-    "typescript": "^5.3.3"
+    "@types/find-package-json": "^1.2.7"
   }
 }

package/src/bin/saws.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+process.on("uncaughtException", (e) => {
+  console.log(e);
+});
+
+import { default as finder } from "find-package-json";
+import { Command, program } from "commander";
+import { getSawsConfig, ServiceDefinition } from "@saws/core";
+
+import { createCommand as createDevCommand } from "../commands/dev/index.js";
+import { createCommand as createDeployCommand } from "../commands/deploy/index.js";
+// import { createCommand as createExecuteCommand } from "../commands/execute/index.js";
+import { createCommand as createInitCommand } from "../commands/init/index.js";
+import { createCommand as createHostCommand } from "../commands/host/index.js";
+import { createCommand as createSecretsCommand } from "../commands/secrets/index.js";
+
+const pkg = finder(import.meta.dirname).next().value;
+
+program
+  .name("saws")
+  .description("A tool for building apps quickly")
+  .version(pkg?.version ?? "0.0.0");
+
+program.addCommand(createDevCommand());
+program.addCommand(createDeployCommand());
+// program.addCommand(createExecuteCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createHostCommand());
+program.addCommand(createSecretsCommand());
+
+type ServiceConstructor = typeof ServiceDefinition & {
+  getCommands?: (services?: ServiceDefinition[]) => Command[];
+};
+
+const isInitCommand = process.argv[2] === "init";
+
+if (!isInitCommand) {
+  try {
+    const service = await getSawsConfig();
+
+    const servicesByClass = new Map<ServiceConstructor, ServiceDefinition[]>();
+    for (const serviceDefinition of service.getAllDependencies()) {
+      const serviceClass = serviceDefinition.constructor as ServiceConstructor;
+      servicesByClass.set(serviceClass, [
+        ...(servicesByClass.get(serviceClass) ?? []),
+        serviceDefinition,
+      ]);
+    }
+
+    for (const [serviceClass, services] of servicesByClass) {
+      serviceClass.getCommands?.(services)?.forEach((command) => program.addCommand(command));
+    }
+  } catch {
+    // Project commands are unavailable until a saws.ts file exists.
+  }
+}
+
+await program.parseAsync(process.argv);

package/src/commands/deploy/command.ts

@@ -0,0 +1,20 @@
+// import { createCacheDir } from "@saws/utils/create-directories";
+import { getSawsConfig } from "@saws/core";
+
+export const deployCommand = async (path: string, { stage }: { stage: string }) => {
+  if (stage == null || stage.length === 0) {
+    throw new Error("deploy requires --stage <string>");
+  }
+  if (stage === "local") {
+    console.warn("Can not deploy to local stage");
+    process.exit();
+  }
+
+  process.env.STAGE = stage;
+
+  // await createCacheDir();
+
+  const serviceDefinition = await getSawsConfig(path);
+
+  await serviceDefinition.deploy(stage);
+};

package/src/commands/deploy/index.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import { deployCommand } from "./command.js";
+
+export const createCommand = () =>
+  new Command("deploy")
+    .option("--stage <string>", "stage to deploy")
+    .argument("[string]", "path to service definition")
+    .action(deployCommand);

package/src/commands/dev/command.ts

@@ -0,0 +1,68 @@
+import { createCacheDir } from "@saws/core/utils/create-directories";
+import { onProcessExit } from "@saws/core/utils/on-exit";
+import { getSawsConfig, type ServiceDefinition } from "@saws/core";
+import { DevTui } from "./tui/dev-tui.js";
+
+export const devCommand = async (path: string) => {
+  process.env.NODE_ENV = "development";
+  process.env.STAGE = "local";
+  process.env.AWS_REGION = "us-west-2";
+
+  await createCacheDir();
+
+  const serviceDefinition = await getSawsConfig(path);
+  const services = collectServices(serviceDefinition);
+  const useTui = process.stdout.isTTY && process.stdin.isTTY;
+  const tui = new DevTui(services.map((service) => service.name));
+
+  const shutdown = () => {
+    try {
+      serviceDefinition.exit();
+    } finally {
+      tui.stop();
+    }
+  };
+
+  onProcessExit(shutdown);
+  process.once("SIGTERM", () => {
+    shutdown();
+    process.exit();
+  });
+
+  if (useTui) {
+    serviceDefinition.setRuntimeLogSink(tui.logSink);
+    tui.start();
+  }
+
+  await serviceDefinition.dev();
+
+  if (useTui) {
+    for (const service of services) {
+      service.getStdOut()?.on("data", (chunk: Buffer) => {
+        tui.logSink({
+          serviceName: service.name,
+          stream: "stdout",
+          chunk: chunk.toString("utf8"),
+          timestamp: new Date(),
+        });
+      });
+      service.getStdErr()?.on("data", (chunk: Buffer) => {
+        tui.logSink({
+          serviceName: service.name,
+          stream: "stderr",
+          chunk: chunk.toString("utf8"),
+          timestamp: new Date(),
+        });
+      });
+    }
+  } else {
+    for (const service of services) {
+      service.getStdOut()?.pipe(process.stdout);
+      service.getStdErr()?.pipe(process.stderr);
+    }
+  }
+};
+
+function collectServices(root: ServiceDefinition) {
+  return [...new Set(root.getAllDependencies())];
+}

package/src/commands/dev/index.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { devCommand } from "./command.js";
+
+export const createCommand = () =>
+  new Command("dev").argument("[string]", "path to service definition").action(devCommand);