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

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.map((service) => service.name));
+    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

package/dist/commands/dev/tui/dev-tui.js

@@ -1,26 +1,33 @@
 import readline from "node:readline";
 const CLEAR_SCREEN = "\x1b[2J";
+const CLEAR_LINE = "\x1b[2K";
 const CURSOR_HOME = "\x1b[H";
 const HIDE_CURSOR = "\x1b[?25l";
 const SHOW_CURSOR = "\x1b[?25h";
 const ENTER_ALT_SCREEN = "\x1b[?1049h";
 const EXIT_ALT_SCREEN = "\x1b[?1049l";
+const ENABLE_MOUSE = "\x1b[?1000h\x1b[?1006h";
+const DISABLE_MOUSE = "\x1b[?1000l\x1b[?1006l";
 const RESET = "\x1b[0m";
 const INVERSE = "\x1b[7m";
 const DIM = "\x1b[2m";
 const CYAN = "\x1b[36m";
+const WHEEL_SCROLL_LINES = 3;
 export class DevTui {
     logSink = (entry) => this.addLog(entry);
     services;
     logs = new Map();
+    logScrollOffsets = new Map();
     selectedIndex = 0;
     isStarted = false;
+    isSelectionMode = false;
     previousRawMode = false;
     maxLines = 2000;
     constructor(services) {
-        this.services = services.length === 0 ? ["system"] : services;
+        this.services = [...new Set(services)];
         for (const service of this.services) {
             this.logs.set(service, { lines: [], partial: "" });
+            this.logScrollOffsets.set(service, 0);
         }
     }
     start() {
@@ -30,10 +37,11 @@ export class DevTui {
         }
         this.isStarted = true;
         this.previousRawMode = process.stdin.isRaw;
-        process.stdout.write(`${ENTER_ALT_SCREEN}${HIDE_CURSOR}`);
+        process.stdout.write(`${ENTER_ALT_SCREEN}${HIDE_CURSOR}${ENABLE_MOUSE}`);
         readline.emitKeypressEvents(process.stdin);
         process.stdin.setRawMode(true);
         process.stdin.resume();
+        process.stdin.on("data", this.handleInput);
         process.stdin.on("keypress", this.handleKeypress);
         process.stdout.on("resize", this.render);
         this.render();
@@ -41,21 +49,29 @@ export class DevTui {
     stop() {
         if (!this.isStarted)
             return;
+        process.stdin.off("data", this.handleInput);
         process.stdin.off("keypress", this.handleKeypress);
         process.stdout.off("resize", this.render);
+        this.isSelectionMode = false;
         process.stdin.setRawMode(this.previousRawMode);
-        process.stdout.write(`${SHOW_CURSOR}${EXIT_ALT_SCREEN}${RESET}`);
+        process.stdout.write(`${DISABLE_MOUSE}${SHOW_CURSOR}${EXIT_ALT_SCREEN}${RESET}`);
         this.isStarted = false;
     }
-    writeSystemLog(message, stream = "stdout") {
-        this.addLog({
-            serviceName: "system",
-            stream,
-            chunk: message.endsWith("\n") ? message : `${message}\n`,
-            timestamp: new Date(),
-        });
-    }
     handleKeypress = (_input, key) => {
+        if (key.ctrl && key.name === "c") {
+            process.kill(process.pid, "SIGINT");
+            return;
+        }
+        if (this.isSelectionMode) {
+            if (key.name === "escape" || key.name === "c") {
+                this.exitSelectionMode();
+            }
+            return;
+        }
+        if (key.name === "c") {
+            this.enterSelectionMode();
+            return;
+        }
         if (key.name === "up" || key.name === "k") {
             this.selectedIndex = Math.max(0, this.selectedIndex - 1);
             this.render();
@@ -66,45 +82,86 @@ export class DevTui {
             this.render();
             return;
         }
-        if (key.ctrl && key.name === "c") {
-            process.kill(process.pid, "SIGINT");
+        if (key.name === "pageup" || key.name === "u") {
+            this.scrollSelectedLog(this.getBodyHeight());
+            return;
+        }
+        if (key.name === "pagedown" || key.name === "d") {
+            this.scrollSelectedLog(-this.getBodyHeight());
+            return;
+        }
+        if (key.name === "home" || key.name === "g") {
+            this.scrollSelectedLog(Number.POSITIVE_INFINITY);
+            return;
+        }
+        if (key.name === "end" || (key.shift && key.name === "g")) {
+            this.logScrollOffsets.set(this.getSelectedService(), 0);
+            this.render();
             return;
         }
         if (key.name === "q") {
             process.kill(process.pid, "SIGTERM");
         }
     };
+    handleInput = (chunk) => {
+        if (this.isSelectionMode)
+            return;
+        const input = chunk.toString();
+        for (const event of parseMouseEvents(input)) {
+            if (event.type === "wheel-up") {
+                this.scrollSelectedLog(WHEEL_SCROLL_LINES);
+                continue;
+            }
+            if (event.type === "wheel-down") {
+                this.scrollSelectedLog(-WHEEL_SCROLL_LINES);
+                continue;
+            }
+            if (event.type === "press") {
+                this.selectServiceAt(event.x, event.y);
+            }
+        }
+    };
     addLog(entry) {
-        const serviceName = this.logs.has(entry.serviceName) ? entry.serviceName : "system";
+        if (entry.serviceName === "system")
+            return;
+        const serviceName = entry.serviceName;
+        if (!this.logs.has(serviceName)) {
+            this.services.push(serviceName);
+            this.logs.set(serviceName, { lines: [], partial: "" });
+            this.logScrollOffsets.set(serviceName, 0);
+            this.selectedIndex = this.services.length - 1;
+        }
         const log = this.logs.get(serviceName) ?? { lines: [], partial: "" };
-        const pieces = `${log.partial}${entry.chunk}`.split(/\r?\n/);
+        const pieces = `${log.partial}${sanitizeLogChunk(entry.chunk)}`.split("\n");
         log.partial = pieces.pop() ?? "";
         for (const piece of pieces) {
-            log.lines.push(`${timestamp(entry.timestamp)} ${piece}`);
+            log.lines.push(`${timestamp(entry.timestamp)} ${entry.stream === "stderr" ? "[err] " : ""}${piece}`);
         }
         if (log.lines.length > this.maxLines) {
             log.lines.splice(0, log.lines.length - this.maxLines);
         }
         this.logs.set(serviceName, log);
+        this.clampLogScrollOffset(serviceName);
         this.render();
     }
-    render = () => {
-        if (!this.isStarted || !process.stdout.isTTY)
+    render = (force = false) => {
+        if (!this.isStarted || !process.stdout.isTTY || (this.isSelectionMode && !force))
             return;
         const width = process.stdout.columns ?? 80;
-        const height = process.stdout.rows ?? 24;
-        const navWidth = Math.min(30, Math.max(18, Math.floor(width * 0.28)));
+        const navWidth = getNavWidth(width);
         const logWidth = Math.max(10, width - navWidth - 1);
-        const bodyHeight = Math.max(1, height - 3);
-        const selectedService = this.services[this.selectedIndex] ?? "system";
+        const bodyHeight = this.getBodyHeight();
+        const selectedService = this.getSelectedService();
         const log = this.logs.get(selectedService) ?? { lines: [], partial: "" };
         const visibleLines = [...log.lines, log.partial].filter(Boolean);
-        const logLines = visibleLines
-            .flatMap((line) => wrapLine(line, logWidth))
-            .slice(-bodyHeight);
+        const wrappedLogLines = visibleLines.flatMap((line) => wrapLine(line, logWidth));
+        const logScrollOffset = this.clampLogScrollOffset(selectedService, wrappedLogLines.length);
+        const logEnd = Math.max(bodyHeight, wrappedLogLines.length - logScrollOffset);
+        const logStart = Math.max(0, logEnd - bodyHeight);
+        const logLines = wrappedLogLines.slice(logStart, logEnd);
         const rows = [];
-        rows.push(`${CYAN}SAWS dev${RESET}${DIM}  up/down select, q quit${RESET}`.padEnd(width));
-        rows.push(`${"Services".padEnd(navWidth)} ${`Logs: ${selectedService}`.padEnd(logWidth)}`);
+        rows.push(`${CYAN}SAWS dev${RESET}${DIM}  ${this.getHelpText()}${RESET}`.padEnd(width));
+        rows.push(`${"Services".padEnd(navWidth)} ${logHeading(selectedService, logScrollOffset).padEnd(logWidth)}`);
         for (let index = 0; index < bodyHeight; index += 1) {
             const service = this.services[index] ?? "";
             const isSelected = index === this.selectedIndex;
@@ -113,7 +170,124 @@ export class DevTui {
             const logLine = truncate(logLines[index] ?? "", logWidth).padEnd(logWidth);
             rows.push(`${isSelected ? `${INVERSE}${nav}${RESET}` : nav} ${logLine}`);
         }
-        process.stdout.write(`${CURSOR_HOME}${CLEAR_SCREEN}${rows.join("\n")}`);
+        process.stdout.write(renderRows(rows, width, process.stdout.rows ?? 24));
+    };
+    enterSelectionMode() {
+        this.isSelectionMode = true;
+        process.stdout.write(`${DISABLE_MOUSE}${SHOW_CURSOR}`);
+        this.render(true);
+    }
+    exitSelectionMode() {
+        this.isSelectionMode = false;
+        process.stdout.write(`${HIDE_CURSOR}${ENABLE_MOUSE}`);
+        this.render(true);
+    }
+    getHelpText() {
+        if (this.isSelectionMode)
+            return "select/copy text with terminal, esc resume";
+        return "up/down select, pgup/pgdn scroll, c copy/select, q quit";
+    }
+    getSelectedService() {
+        return this.services[this.selectedIndex] ?? "";
+    }
+    getBodyHeight() {
+        return Math.max(1, (process.stdout.rows ?? 24) - 3);
+    }
+    scrollSelectedLog(delta) {
+        const selectedService = this.getSelectedService();
+        const current = this.logScrollOffsets.get(selectedService) ?? 0;
+        this.logScrollOffsets.set(selectedService, current + delta);
+        this.render();
+    }
+    selectServiceAt(x, y) {
+        const navWidth = getNavWidth(process.stdout.columns ?? 80);
+        if (x > navWidth || y < 3)
+            return;
+        const serviceIndex = y - 3;
+        if (serviceIndex < 0 || serviceIndex >= this.services.length)
+            return;
+        this.selectedIndex = serviceIndex;
+        this.render();
+    }
+    clampLogScrollOffset(serviceName, wrappedLineCount) {
+        const width = process.stdout.columns ?? 80;
+        const navWidth = getNavWidth(width);
+        const logWidth = Math.max(10, width - navWidth - 1);
+        const log = this.logs.get(serviceName) ?? { lines: [], partial: "" };
+        const lineCount = wrappedLineCount ??
+            [...log.lines, log.partial].filter(Boolean).flatMap((line) => wrapLine(line, logWidth))
+                .length;
+        const maxOffset = Math.max(0, lineCount - this.getBodyHeight());
+        const nextOffset = Math.min(maxOffset, Math.max(0, this.logScrollOffsets.get(serviceName) ?? 0));
+        this.logScrollOffsets.set(serviceName, nextOffset);
+        return nextOffset;
+    }
+}
+function logHeading(serviceName, scrollOffset) {
+    if (scrollOffset === 0)
+        return `Logs: ${serviceName}`;
+    return `Logs: ${serviceName} (${scrollOffset} lines from bottom)`;
+}
+function renderRows(rows, width, height) {
+    const output = [CURSOR_HOME, CLEAR_SCREEN];
+    for (let index = 0; index < height; index += 1) {
+        output.push(cursorPosition(index + 1, 1));
+        output.push(CLEAR_LINE);
+        output.push(truncate(rows[index] ?? "", width).padEnd(width));
+    }
+    return output.join("");
+}
+function cursorPosition(row, column) {
+    return `\x1b[${row};${column}H`;
+}
+function getNavWidth(terminalWidth) {
+    return Math.min(30, Math.max(18, Math.floor(terminalWidth * 0.28)));
+}
+function parseMouseEvents(input) {
+    const events = [];
+    for (let index = 0; index < input.length; index += 1) {
+        if (input.charCodeAt(index) !== 27 || input[index + 1] !== "[" || input[index + 2] !== "<") {
+            continue;
+        }
+        const codeResult = readUnsignedNumber(input, index + 3);
+        if (codeResult == null || input[codeResult.nextIndex] !== ";")
+            continue;
+        const xResult = readUnsignedNumber(input, codeResult.nextIndex + 1);
+        if (xResult == null || input[xResult.nextIndex] !== ";")
+            continue;
+        const yResult = readUnsignedNumber(input, xResult.nextIndex + 1);
+        if (yResult == null)
+            continue;
+        const action = input[yResult.nextIndex];
+        index = yResult.nextIndex;
+        if (action !== "M")
+            continue;
+        if (codeResult.value >= 64 && codeResult.value <= 95) {
+            const wheelDirection = codeResult.value & 3;
+            if (wheelDirection === 0) {
+                events.push({ type: "wheel-up", x: xResult.value, y: yResult.value });
+            }
+            else if (wheelDirection === 1) {
+                events.push({ type: "wheel-down", x: xResult.value, y: yResult.value });
+            }
+            continue;
+        }
+        if ((codeResult.value & 3) === 0) {
+            events.push({ type: "press", x: xResult.value, y: yResult.value });
+        }
+    }
+    return events;
+}
+function readUnsignedNumber(value, startIndex) {
+    let index = startIndex;
+    while (index < value.length && value[index] >= "0" && value[index] <= "9") {
+        index += 1;
+    }
+    if (index === startIndex)
+        return null;
+    return {
+        value: Number(value.slice(startIndex, index)),
+        nextIndex: index,
     };
 }
 function timestamp(date) {
@@ -142,5 +316,65 @@ function truncate(value, width) {
     return `${value.slice(0, width - 3)}...`;
 }
 function visibleLength(value) {
-    return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+    return stripAnsiColor(value).length;
+}
+function sanitizeLogChunk(value) {
+    return stripAnsiControlSequences(value.replaceAll("\r\n", "\n").replaceAll("\r", "\n"));
+}
+function stripAnsiControlSequences(value) {
+    let stripped = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 27) {
+            index = skipEscapeSequence(value, index);
+            continue;
+        }
+        if ((code >= 0 && code < 9) || (code > 13 && code < 32) || code === 127) {
+            continue;
+        }
+        stripped += value[index];
+    }
+    return stripped;
+}
+function skipEscapeSequence(value, startIndex) {
+    const next = value[startIndex + 1];
+    if (next === "[") {
+        let index = startIndex + 2;
+        while (index < value.length) {
+            const code = value.charCodeAt(index);
+            if (code >= 64 && code <= 126)
+                return index;
+            index += 1;
+        }
+        return value.length - 1;
+    }
+    if (next === "]") {
+        let index = startIndex + 2;
+        while (index < value.length) {
+            if (value.charCodeAt(index) === 7)
+                return index;
+            if (value.charCodeAt(index) === 27 && value[index + 1] === "\\")
+                return index + 1;
+            index += 1;
+        }
+        return value.length - 1;
+    }
+    return Math.min(startIndex + 1, value.length - 1);
+}
+function stripAnsiColor(value) {
+    let stripped = "";
+    for (let index = 0; index < value.length; index += 1) {
+        if (value.charCodeAt(index) !== 27) {
+            stripped += value[index];
+            continue;
+        }
+        if (value[index + 1] !== "[") {
+            continue;
+        }
+        index += 2;
+        while (index < value.length && /[0-9;]/.test(value[index] ?? "")) {
+            index += 1;
+        }
+    }
+    return stripped;
 }

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

@@ -1,8 +1,8 @@
-import type { Host } from "@saws/host";
+import { Host } from "@saws/core";
 export interface ConfigureHostCommandOptions {
     config?: string;
     dryRun?: boolean;
+    user: string;
 }
 export declare function configureHostCommand(name: string | undefined, options: ConfigureHostCommandOptions): Promise<void>;
 export declare function selectHost(hosts: Host[], name?: string): Host;
-//# sourceMappingURL=command.d.ts.map