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

package/dist/commands/app/install.js

@@ -0,0 +1,41 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+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);
+    const inputPath = path.resolve(options.config);
+    const installedInputPath = path.join(appDirectory, "input.ts");
+    await fs.mkdir(appDirectory, { recursive: true });
+    if (inputPath !== installedInputPath) {
+        await fs.copyFile(inputPath, installedInputPath);
+    }
+    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, "saws.ts"), applicationWrapper(packageName));
+    await runProcess("npm", ["install", "--save-exact", "--no-fund", "--no-audit", packageSpecifier], appDirectory);
+    console.log(`Installed ${packageSpecifier} as application "${options.name}"`);
+}
+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;
+}
+function applicationWrapper(packageName) {
+    return `import { createSawsConfig } from "@saws/core";
+import input from "./input.ts";
+import * as application from ${JSON.stringify(packageName)};
+
+export * from "./input.ts";
+
+export default await createSawsConfig(application, input);
+`;
+}

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

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

package/dist/commands/app/paths.js

@@ -0,0 +1,8 @@
+import path from "node:path";
+import { getSawsHome } from "@saws/core";
+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(getSawsHome(), "apps", name);
+}

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

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

package/dist/commands/app/process.js

@@ -0,0 +1,28 @@
+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 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/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