@saws/cli 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/commands/app/files.js

@@ -0,0 +1,40 @@
+export function getPackageName(specifier) {
+    const trimmed = specifier.trim();
+    const match = /^(?<name>@[^/\s]+\/[^@/\s]+|[^@/\s]+)(?:@[^\s]+)?$/.exec(trimmed);
+    const name = match?.groups?.name;
+    if (name == null) {
+        throw new Error("Application package must be an npm package name with an optional version or tag");
+    }
+    return name;
+}
+export function applicationWrapper(packageName) {
+    return `import { createSawsConfig } from "@saws/core";
+import config from "./config.ts";
+import * as application from ${JSON.stringify(packageName)};
+
+export * from "./config.ts";
+
+export default await createSawsConfig(application, config);
+`;
+}
+export function applicationConfig(packageName) {
+    return `import type { create } from ${JSON.stringify(packageName)};
+
+export default {
+  // Configure this application instance here.
+} satisfies Parameters<typeof create>[0];
+`;
+}
+export async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+import fs from "node:fs/promises";

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

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const createCommand: () => Command;

package/dist/commands/app/index.js

@@ -0,0 +1,22 @@
+import { Command } from "commander";
+import { deployAppCommand } from "./deploy.js";
+import { installAppCommand } from "./install.js";
+import { listAppsCommand } from "./list.js";
+import { updateAppCommand } from "./update.js";
+export const createCommand = () => new Command("app")
+    .description("manage packaged SAWS applications")
+    .addCommand(new Command("list").description("list installed SAWS applications").action(listAppsCommand))
+    .addCommand(new Command("install")
+    .description("install a packaged SAWS application")
+    .argument("<package>", "npm package name with an optional version or tag")
+    .requiredOption("--name <name>", "local name for this application instance")
+    .action(installAppCommand))
+    .addCommand(new Command("update")
+    .description("update an installed SAWS application to npm latest")
+    .argument("<name>", "installed application name")
+    .action(updateAppCommand))
+    .addCommand(new Command("deploy")
+    .description("deploy an installed SAWS application")
+    .argument("<name>", "installed application name")
+    .requiredOption("--stage <stage>", "stage to deploy")
+    .action(deployAppCommand));

package/dist/commands/app/install.d.ts

@@ -0,0 +1,4 @@
+export interface InstallAppOptions {
+    name: string;
+}
+export declare function installAppCommand(packageSpecifier: string, options: InstallAppOptions): Promise<void>;

package/dist/commands/app/install.js

@@ -0,0 +1,35 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { applicationConfig, applicationWrapper, getPackageName } from "./files.js";
+import { getAppDirectory } from "./paths.js";
+import { runProcess } from "./process.js";
+export async function installAppCommand(packageSpecifier, options) {
+    const packageName = getPackageName(packageSpecifier);
+    const appDirectory = getAppDirectory(options.name);
+    await fs.mkdir(path.dirname(appDirectory), { recursive: true });
+    try {
+        await fs.mkdir(appDirectory);
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw new Error(`Application "${options.name}" is already installed`);
+        }
+        throw error;
+    }
+    try {
+        await fs.writeFile(path.join(appDirectory, "package.json"), `${JSON.stringify({
+            name: "saws-installed-application",
+            private: true,
+            type: "module",
+        }, null, 2)}\n`);
+        await fs.writeFile(path.join(appDirectory, "config.ts"), applicationConfig(packageName));
+        await fs.writeFile(path.join(appDirectory, "saws.ts"), applicationWrapper(packageName));
+        await runProcess("npm", ["install", "--save-exact", "--no-fund", "--no-audit", packageSpecifier], appDirectory);
+    }
+    catch (error) {
+        await fs.rm(appDirectory, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+    console.log(`Installed ${packageSpecifier} as application "${options.name}"`);
+    console.log(`Configure it by editing ${path.join(appDirectory, "config.ts")}`);
+}

package/dist/commands/app/list.d.ts

@@ -0,0 +1 @@
+export declare function listAppsCommand(): Promise<void>;

package/dist/commands/app/list.js

@@ -0,0 +1,67 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathExists } from "./files.js";
+import { getInstalledApplicationPackage, getInstalledVersion } from "./metadata.js";
+import { getAppDirectory, getAppsDirectory } from "./paths.js";
+export async function listAppsCommand() {
+    const names = await getApplicationNames();
+    if (names.length === 0) {
+        console.log("No applications installed");
+        return;
+    }
+    const rows = await Promise.all(names.map(getApplicationRow));
+    printTable(rows);
+}
+async function getApplicationNames() {
+    let entries;
+    try {
+        entries = await fs.readdir(getAppsDirectory(), { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+async function getApplicationRow(name) {
+    const appDirectory = getAppDirectory(name);
+    let packageName = "unknown";
+    let version = "unknown";
+    try {
+        packageName = await getInstalledApplicationPackage(appDirectory, name);
+        version = await getInstalledVersion(appDirectory, packageName);
+    }
+    catch {
+        // Keep malformed or incomplete application directories visible in the list.
+    }
+    const [hasConfig, hasInput] = await Promise.all([
+        pathExists(path.join(appDirectory, "config.ts")),
+        pathExists(path.join(appDirectory, "input.ts")),
+    ]);
+    const config = hasConfig && hasInput
+        ? "conflict"
+        : hasConfig
+            ? "config.ts"
+            : hasInput
+                ? "input.ts (legacy)"
+                : "missing";
+    return { name, packageName, version, config };
+}
+function printTable(rows) {
+    const values = [
+        ["NAME", "PACKAGE", "VERSION", "CONFIG"],
+        ...rows.map((row) => [row.name, row.packageName, row.version, row.config]),
+    ];
+    const widths = values[0].map((_, column) => Math.max(...values.map((row) => row[column].length)));
+    console.log(values
+        .map((row) => row
+        .map((value, column) => value.padEnd(widths[column]))
+        .join("  ")
+        .trimEnd())
+        .join("\n"));
+}

package/dist/commands/app/metadata.d.ts

@@ -0,0 +1,2 @@
+export declare function getInstalledApplicationPackage(appDirectory: string, name: string): Promise<string>;
+export declare function getInstalledVersion(appDirectory: string, packageName: string): Promise<string>;

package/dist/commands/app/metadata.js

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { valid } from "semver";
+export async function getInstalledApplicationPackage(appDirectory, name) {
+    let packageJson;
+    try {
+        packageJson = JSON.parse(await fs.readFile(path.join(appDirectory, "package.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`Application "${name}" is not installed`);
+        }
+        throw new Error(`Could not read package metadata for application "${name}"`, { cause: error });
+    }
+    const dependencyNames = Object.keys(packageJson.dependencies ?? {});
+    if (dependencyNames.length !== 1) {
+        throw new Error(`Application "${name}" must have exactly one application package dependency`);
+    }
+    return dependencyNames[0];
+}
+export async function getInstalledVersion(appDirectory, packageName) {
+    const packageJson = JSON.parse(await fs.readFile(path.join(appDirectory, "node_modules", packageName, "package.json"), "utf8"));
+    if (packageJson.version == null || valid(packageJson.version) == null) {
+        throw new Error(`Installed ${packageName} does not have a valid semantic version`);
+    }
+    return packageJson.version;
+}

package/dist/commands/app/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function getAppsDirectory(): string;
+export declare function getAppDirectory(name: string): string;

package/dist/commands/app/paths.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+import { getSawsHome } from "@saws/core";
+export function getAppsDirectory() {
+    return path.join(getSawsHome(), "apps");
+}
+export function getAppDirectory(name) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+        throw new Error("Application name must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens");
+    }
+    return path.join(getAppsDirectory(), name);
+}

package/dist/commands/app/process.d.ts

@@ -0,0 +1,3 @@
+export declare function runProcess(command: string, args: string[], cwd: string): Promise<void>;
+export declare function getProcessOutput(command: string, args: string[], cwd: string): Promise<string>;
+export declare function runSaws(args: string[], cwd: string): Promise<void>;

package/dist/commands/app/process.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+export async function runProcess(command, args, cwd) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: "inherit",
+        });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (signal != null) {
+                reject(new Error(`${command} exited from signal ${signal}`));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`${command} exited with code ${code ?? "unknown"}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export async function getProcessOutput(command, args, cwd) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (signal != null) {
+                reject(new Error(`${command} exited from signal ${signal}`));
+                return;
+            }
+            if (code !== 0) {
+                const details = Buffer.concat(stderr).toString("utf8").trim();
+                reject(new Error(`${command} exited with code ${code ?? "unknown"}${details.length > 0 ? `: ${details}` : ""}`));
+                return;
+            }
+            resolve(Buffer.concat(stdout).toString("utf8"));
+        });
+    });
+}
+export async function runSaws(args, cwd) {
+    const cliPath = process.argv[1];
+    if (cliPath == null) {
+        throw new Error("Could not determine the SAWS CLI entry point");
+    }
+    await runProcess(process.execPath, [cliPath, ...args], cwd);
+}

package/dist/commands/app/update.d.ts

@@ -0,0 +1 @@
+export declare function updateAppCommand(name: string): Promise<void>;

package/dist/commands/app/update.js

@@ -0,0 +1,62 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { gt, prerelease, valid } from "semver";
+import { applicationWrapper, pathExists } from "./files.js";
+import { getInstalledApplicationPackage, getInstalledVersion } from "./metadata.js";
+import { getAppDirectory } from "./paths.js";
+import { getProcessOutput, runProcess } from "./process.js";
+export async function updateAppCommand(name) {
+    const appDirectory = getAppDirectory(name);
+    const packageName = await getInstalledApplicationPackage(appDirectory, name);
+    const installedVersion = await getInstalledVersion(appDirectory, packageName);
+    const migrated = await migrateLegacyConfig(appDirectory, packageName);
+    const npmTag = prerelease(installedVersion)?.[0] === "beta" ? "beta" : "latest";
+    const latestVersion = await getLatestVersion(appDirectory, packageName, npmTag);
+    if (!gt(latestVersion, installedVersion)) {
+        const status = gt(installedVersion, latestVersion)
+            ? `is newer than npm ${npmTag}`
+            : "is up to date";
+        console.log(`Application "${name}" ${status} (${installedVersion})${migrated ? "; migrated input.ts to config.ts" : ""}`);
+        return;
+    }
+    await runProcess("npm", ["install", "--save-exact", "--no-fund", "--no-audit", `${packageName}@${latestVersion}`], appDirectory);
+    await fs.writeFile(path.join(appDirectory, "saws.ts"), applicationWrapper(packageName));
+    console.log(`Updated application "${name}" from ${installedVersion} to ${latestVersion}${migrated ? " and migrated input.ts to config.ts" : ""}`);
+}
+async function getLatestVersion(appDirectory, packageName, npmTag) {
+    const output = await getProcessOutput("npm", ["view", `${packageName}@${npmTag}`, "version", "--json"], appDirectory);
+    const version = JSON.parse(output);
+    if (typeof version !== "string" || valid(version) == null) {
+        throw new Error(`npm ${npmTag} for ${packageName} is not a valid semantic version`);
+    }
+    return version;
+}
+async function migrateLegacyConfig(appDirectory, packageName) {
+    const inputPath = path.join(appDirectory, "input.ts");
+    const configPath = path.join(appDirectory, "config.ts");
+    const [hasInput, hasConfig] = await Promise.all([pathExists(inputPath), pathExists(configPath)]);
+    if (hasInput && hasConfig) {
+        throw new Error(`Application contains both input.ts and config.ts; remove one before updating so SAWS does not overwrite configuration`);
+    }
+    if (!hasInput && !hasConfig) {
+        throw new Error(`Application configuration is missing; expected config.ts or legacy input.ts`);
+    }
+    if (!hasInput) {
+        return false;
+    }
+    const wrapperPath = path.join(appDirectory, "saws.ts");
+    const pendingWrapperPath = path.join(appDirectory, ".saws.ts.update");
+    await fs.writeFile(pendingWrapperPath, applicationWrapper(packageName), { flag: "wx" });
+    try {
+        await fs.rename(inputPath, configPath);
+        await fs.rename(pendingWrapperPath, wrapperPath);
+    }
+    catch (error) {
+        if (await pathExists(configPath)) {
+            await fs.rename(configPath, inputPath).catch(() => undefined);
+        }
+        await fs.rm(pendingWrapperPath, { force: true });
+        throw error;
+    }
+    return true;
+}

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

@@ -1,8 +1,3 @@
-export interface DeployCommandOptions {
+export declare const deployCommand: (path: string, { stage }: {
     stage: string;
-    dryRun?: boolean;
-    rootDir?: string;
-    config?: string;
-}
-export declare function deployCommand(path: string | undefined, options: DeployCommandOptions): Promise<void>;
-//# sourceMappingURL=command.d.ts.map
+}) => Promise<void>;

package/dist/commands/deploy/command.js

@@ -1,21 +1,15 @@
-import { DeployContext, getSawsConfig } from "@saws/core";
-import { findConfiguredHosts } from "../../hosts.js";
-export async function deployCommand(path, options) {
-    if (options.stage == null || options.stage.length === 0) {
-        throw new Error("deploy requires --stage <stage>");
+// import { createCacheDir } from "@saws/utils/create-directories";
+import { getSawsConfig } from "@saws/core";
+export const deployCommand = async (path, { stage }) => {
+    if (stage == null || stage.length === 0) {
+        throw new Error("deploy requires --stage <string>");
     }
-    if (options.stage === "local") {
-        throw new Error("Can not deploy to local stage");
+    if (stage === "local") {
+        console.warn("Can not deploy to local stage");
+        process.exit();
     }
-    const serviceDefinition = await getSawsConfig(options.config ?? path);
-    const dryRun = options.dryRun ?? false;
-    for (const host of findConfiguredHosts(serviceDefinition)) {
-        await host.assertReady({ dryRun });
-    }
-    await serviceDefinition.deploy(new DeployContext({
-        stage: options.stage,
-        rootDir: options.rootDir ?? process.cwd(),
-        dryRun,
-        env: process.env,
-    }));
-}
+    process.env.STAGE = stage;
+    // await createCacheDir();
+    const serviceDefinition = await getSawsConfig(path);
+    await serviceDefinition.deploy(stage);
+};

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

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

package/dist/commands/deploy/index.js

@@ -1,9 +1,6 @@
 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")
-    .requiredOption("--stage <string>", "stage to deploy")
-    .option("--dry-run", "print remote commands instead of executing them")
-    .option("--root-dir <string>", "project root used for generated local files")
-    .option("--config <string>", "path to service definition")
     .action(deployCommand);

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

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

package/dist/commands/dev/command.js

@@ -1,63 +1,61 @@
-import { DevContext, ExitContext, getSawsConfig, } from "@saws/core";
+import { createCacheDir } from "@saws/core/utils/create-directories";
+import { onProcessExit } from "@saws/core/utils/on-exit";
+import { getSawsConfig } from "@saws/core";
 import { DevTui } from "./tui/dev-tui.js";
-const LOCAL_STAGE = "local";
-export async function devCommand(path, options) {
+export const devCommand = async (path) => {
     process.env.NODE_ENV = "development";
-    process.env.STAGE = LOCAL_STAGE;
-    const rootDir = options.rootDir ?? process.cwd();
-    const serviceDefinition = await getSawsConfig(options.config ?? path);
-    const tui = new DevTui(collectServices(serviceDefinition));
+    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;
-    if (useTui)
-        tui.start();
-    const shutdown = async () => {
+    const tui = new DevTui(services.flatMap((service) => [service.name, ...service.getOnDevLogTabs()]));
+    const shutdown = () => {
         try {
-            await serviceDefinition.exit(new ExitContext({ stage: LOCAL_STAGE, rootDir }));
+            serviceDefinition.exit();
         }
         finally {
             tui.stop();
-            process.exit();
         }
     };
-    process.once("SIGINT", shutdown);
-    process.once("SIGTERM", shutdown);
-    try {
-        await serviceDefinition.dev(new DevContext({
-            stage: LOCAL_STAGE,
-            rootDir,
-            dryRun: options.dryRun ?? false,
-            env: process.env,
-            logSink: useTui ? tui.logSink : undefined,
-        }));
-        // Service dev hooks start their processes without blocking so every
-        // dependency can come up. Keep the command alive until a signal invokes
-        // the shared shutdown path.
-        if (!options.dryRun) {
-            await new Promise(() => { });
-        }
+    onProcessExit(shutdown);
+    process.once("SIGTERM", () => {
+        shutdown();
+        process.exit();
+    });
+    if (useTui) {
+        serviceDefinition.setRuntimeLogSink(tui.logSink);
+        tui.start();
     }
-    catch (error) {
-        if (useTui) {
-            tui.writeSystemLog(error.stack ?? String(error), "stderr");
+    await serviceDefinition.dev();
+    if (useTui) {
+        for (const service of services) {
+            service.getStdOut()?.on("data", (chunk) => {
+                tui.logSink({
+                    serviceName: service.name,
+                    stream: "stdout",
+                    chunk: chunk.toString("utf8"),
+                    timestamp: new Date(),
+                });
+            });
+            service.getStdErr()?.on("data", (chunk) => {
+                tui.logSink({
+                    serviceName: service.name,
+                    stream: "stderr",
+                    chunk: chunk.toString("utf8"),
+                    timestamp: new Date(),
+                });
+            });
         }
-        throw error;
     }
-    finally {
-        tui.stop();
+    else {
+        for (const service of services) {
+            service.getStdOut()?.pipe(process.stdout);
+            service.getStdErr()?.pipe(process.stderr);
+        }
     }
-}
+};
 function collectServices(root) {
-    const services = [];
-    const seen = new Set();
-    const visit = (service) => {
-        if (seen.has(service))
-            return;
-        seen.add(service);
-        for (const dependency of service.dependencies) {
-            visit(dependency);
-        }
-        services.push(service.name);
-    };
-    visit(root);
-    return services;
+    return [...new Set(root.getAllDependencies())];
 }

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

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

package/dist/commands/dev/index.js

@@ -1,8 +1,3 @@
 import { Command } from "commander";
 import { devCommand } from "./command.js";
-export const createCommand = () => new Command("dev")
-    .argument("[string]", "path to service definition")
-    .option("--dry-run", "print local Docker commands instead of executing them")
-    .option("--root-dir <string>", "project root used for generated local files")
-    .option("--config <string>", "path to service definition")
-    .action(devCommand);
+export const createCommand = () => new Command("dev").argument("[string]", "path to service definition").action(devCommand);

package/dist/commands/dev/tui/dev-tui.d.ts

@@ -1,18 +1,33 @@
-import type { RuntimeLogSink } from "@saws/core";
+export interface RuntimeLogEntry {
+    serviceName: string;
+    stream: "stdout" | "stderr";
+    chunk: string;
+    timestamp: Date;
+}
+export type RuntimeLogSink = (entry: RuntimeLogEntry) => void;
 export declare class DevTui {
     readonly logSink: RuntimeLogSink;
     private readonly services;
     private readonly logs;
+    private readonly logScrollOffsets;
     private selectedIndex;
     private isStarted;
+    private isSelectionMode;
     private previousRawMode;
     private readonly maxLines;
     constructor(services: string[]);
     start(): void;
     stop(): void;
-    writeSystemLog(message: string, stream?: "stdout" | "stderr"): void;
     private handleKeypress;
+    private handleInput;
     private addLog;
     private render;
+    private enterSelectionMode;
+    private exitSelectionMode;
+    private getHelpText;
+    private getSelectedService;
+    private getBodyHeight;
+    private scrollSelectedLog;
+    private selectServiceAt;
+    private clampLogScrollOffset;
 }
-//# sourceMappingURL=dev-tui.d.ts.map