@saws/cli 1.0.11 → 2.0.0-beta.11

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

@@ -0,0 +1,33 @@
+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;
+    private handleKeypress;
+    private handleInput;
+    private addLog;
+    private render;
+    private enterSelectionMode;
+    private exitSelectionMode;
+    private getHelpText;
+    private getSelectedService;
+    private getBodyHeight;
+    private scrollSelectedLog;
+    private selectServiceAt;
+    private clampLogScrollOffset;
+}

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

@@ -0,0 +1,380 @@
+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 = [...new Set(services)];
+        for (const service of this.services) {
+            this.logs.set(service, { lines: [], partial: "" });
+            this.logScrollOffsets.set(service, 0);
+        }
+    }
+    start() {
+        if (this.isStarted || !process.stdout.isTTY || !process.stdin.isTTY) {
+            this.isStarted = process.stdout.isTTY && process.stdin.isTTY;
+            return;
+        }
+        this.isStarted = true;
+        this.previousRawMode = process.stdin.isRaw;
+        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();
+    }
+    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(`${DISABLE_MOUSE}${SHOW_CURSOR}${EXIT_ALT_SCREEN}${RESET}`);
+        this.isStarted = false;
+    }
+    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();
+            return;
+        }
+        if (key.name === "down" || key.name === "j") {
+            this.selectedIndex = Math.min(this.services.length - 1, this.selectedIndex + 1);
+            this.render();
+            return;
+        }
+        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) {
+        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}${sanitizeLogChunk(entry.chunk)}`.split("\n");
+        log.partial = pieces.pop() ?? "";
+        for (const piece of pieces) {
+            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 = (force = false) => {
+        if (!this.isStarted || !process.stdout.isTTY || (this.isSelectionMode && !force))
+            return;
+        const width = process.stdout.columns ?? 80;
+        const navWidth = getNavWidth(width);
+        const logWidth = Math.max(10, width - navWidth - 1);
+        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 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}  ${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;
+            const serviceLabel = service === "" ? "" : ` ${service}`;
+            const nav = truncate(serviceLabel, navWidth).padEnd(navWidth);
+            const logLine = truncate(logLines[index] ?? "", logWidth).padEnd(logWidth);
+            rows.push(`${isSelected ? `${INVERSE}${nav}${RESET}` : nav} ${logLine}`);
+        }
+        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) {
+    return date.toLocaleTimeString(undefined, {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+}
+function wrapLine(line, width) {
+    const chunks = [];
+    let remaining = line;
+    while (visibleLength(remaining) > width) {
+        chunks.push(remaining.slice(0, width));
+        remaining = remaining.slice(width);
+    }
+    chunks.push(remaining);
+    return chunks;
+}
+function truncate(value, width) {
+    if (visibleLength(value) <= width)
+        return value;
+    if (width <= 3)
+        return value.slice(0, width);
+    return `${value.slice(0, width - 3)}...`;
+}
+function visibleLength(value) {
+    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

@@ -0,0 +1,9 @@
+import { Host } from "@saws/core";
+export interface ConfigureHostCommandOptions {
+    config?: string;
+    dryRun?: boolean;
+    global?: boolean;
+    user: string;
+}
+export declare function configureHostCommand(name: string | undefined, options: ConfigureHostCommandOptions): Promise<void>;
+export declare function selectHost(hosts: Host[], name?: string): Host;

package/dist/commands/host/command.js

@@ -0,0 +1,129 @@
+import { chmod, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ParameterNotFoundError, SecretsManager, ServiceDefinition, getGlobalHost, getGlobalHostSecretsManager, getSawsConfigModule, hostSshPublicKeyEnvName, } from "@saws/core";
+import { findConfiguredHosts } from "../../hosts.js";
+import { derivePublicKey, generatePrivateKey } from "./deployment-key.js";
+export async function configureHostCommand(name, options) {
+    if (options.global) {
+        if (options.config != null) {
+            throw new Error("host configure accepts only one of --global or --config <path>");
+        }
+        if (name == null) {
+            throw new Error("host configure --global requires a host name");
+        }
+        await configureSelectedHost(getGlobalHost(name), getGlobalHostSecretsManager(), options);
+        return;
+    }
+    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);
+    await configureSelectedHost(host, config.secrets, options);
+}
+async function configureSelectedHost(host, manager, options) {
+    validatePrivateKeyReference(host, manager);
+    if (options.dryRun) {
+        await host.configure({
+            bootstrapUser: options.user,
+            deploymentPublicKey: "[redacted deployment public key]",
+            dryRun: true,
+        });
+        return;
+    }
+    const { privateKey, created } = await getOrCreateDeploymentKey(manager, host);
+    const publicKey = await derivePublicKey(privateKey);
+    if (created) {
+        await manager.global.set(host.sshPrivateKey.name, privateKey);
+    }
+    await updatePublicKeyEnvironment(manager.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 hosts are configured");
+    }
+    const host = name == null
+        ? hosts.length === 1
+            ? hosts[0]
+            : undefined
+        : hosts.find((candidate) => candidate.name === name);
+    if (host != null)
+        return host;
+    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 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, "\\$&");
+}

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

@@ -0,0 +1,9 @@
+export interface CreateHostCommandOptions {
+    address: string;
+    user: string;
+    sshPort?: string;
+    exposure?: string;
+    platform?: string;
+    allowedTcpPort?: string[];
+}
+export declare function createHostCommand(name: string, options: CreateHostCommandOptions): Promise<void>;

package/dist/commands/host/create.js

@@ -0,0 +1,30 @@
+import { createGlobalHost } from "@saws/core";
+export async function createHostCommand(name, options) {
+    const host = await createGlobalHost({
+        name,
+        address: options.address,
+        user: options.user,
+        ...(options.sshPort == null ? {} : { sshPort: parsePort(options.sshPort, "SSH port") }),
+        ...(options.exposure == null ? {} : { exposure: parseExposure(options.exposure) }),
+        ...(options.platform == null ? {} : { platform: options.platform }),
+        ...(options.allowedTcpPort == null
+            ? {}
+            : {
+                allowedTcpPorts: options.allowedTcpPort.map((port) => parsePort(port, "Allowed TCP port")),
+            }),
+    });
+    console.log(`Created global host "${host.name}" at ${host.address}`);
+}
+function parsePort(value, label) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+        throw new Error(`${label} must be a valid TCP port`);
+    }
+    return port;
+}
+function parseExposure(value) {
+    if (value !== "tunnel" && value !== "public") {
+        throw new Error('Host exposure must be either "tunnel" or "public"');
+    }
+    return value;
+}

package/dist/commands/host/deployment-key.d.ts

@@ -0,0 +1,2 @@
+export declare function generatePrivateKey(): Promise<string>;
+export declare function derivePublicKey(privateKey: string): Promise<string>;

package/dist/commands/host/deployment-key.js

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+export 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");
+    });
+}
+export async function derivePublicKey(privateKey) {
+    return withTemporaryDirectory(async (directory) => {
+        const keyPath = path.join(directory, "id_private");
+        await writeFile(keyPath, privateKey, { mode: 0o600 });
+        let stdout;
+        try {
+            ({ stdout } = await execFileAsync("ssh-keygen", ["-y", "-P", "", "-f", keyPath]));
+        }
+        catch {
+            throw new Error("SSH private key is invalid or passphrase-protected; SAWS host keys must not require a passphrase");
+        }
+        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 });
+    }
+}
+const execFileAsync = promisify(execFile);

package/dist/commands/host/import-key.d.ts

@@ -0,0 +1,5 @@
+export interface ImportHostKeyCommandOptions {
+    file: string;
+    force?: boolean;
+}
+export declare function importHostKeyCommand(name: string, options: ImportHostKeyCommandOptions): Promise<void>;

package/dist/commands/host/import-key.js

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { ParameterNotFoundError, getGlobalHost, getGlobalHostSecretsManager } from "@saws/core";
+import { derivePublicKey } from "./deployment-key.js";
+export async function importHostKeyCommand(name, options) {
+    const host = getGlobalHost(name);
+    const keyPath = path.resolve(options.file);
+    let privateKey;
+    try {
+        privateKey = await readFile(keyPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new Error(`SSH private key file does not exist: ${keyPath}`);
+        }
+        throw error;
+    }
+    if (privateKey.trim().length === 0) {
+        throw new Error(`SSH private key file is empty: ${keyPath}`);
+    }
+    await derivePublicKey(privateKey);
+    const manager = getGlobalHostSecretsManager();
+    const secretName = host.sshPrivateKey.name;
+    if (!options.force && (await secretExists(manager, secretName))) {
+        throw new Error(`Global host "${host.name}" already has a deployment key; pass --force to replace it`);
+    }
+    await manager.global.set(secretName, privateKey);
+    console.log(`Imported deployment key for global host "${host.name}"`);
+}
+async function secretExists(manager, secretName) {
+    try {
+        await manager.global.get(secretName);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof ParameterNotFoundError)
+            return false;
+        throw error;
+    }
+}