aws-runtime-bridge 1.3.2 → 1.3.5

package/README.md

@@ -23,7 +23,7 @@ npm install -g .
 
 ## 启动
 
-首次运行 `awsb` / `aws-bridge` 时，如果不存在 `~/.aws-bridge/config.json`，CLI 会进入交互式配置引导；也可以在提示中选择跳过。跳过时仍会创建配置文件并自动生成随机 `connectionKey`，终端会输出该密钥，请保存后在 server/面板连接此 Bridge 时使用。非交互环境（如 systemd、CI、Docker 后台启动）不会阻塞等待输入，也会自动生成 `connectionKey` 并跳过引导。
+首次运行 `awsb` / `aws-bridge` 时，如果不存在 `~/.aws-bridge/config.json`，CLI 会进入交互式配置引导；也可以在提示中选择跳过。跳过时仍会创建配置文件并自动生成随机 `connectionKey`，终端会输出该密钥，请保存后在 server/面板连接此 Bridge 时使用。非交互环境（如 systemd、CI、Docker 后台启动）不会阻塞等待输入，也会自动生成随机 `connectionKey` 并跳过引导。
 
 引导会生成类似下面的配置：
 
@@ -63,6 +63,22 @@ AWS_CLIENT_AGENT_MCP_ARGS='[]' \
 aws-bridge
 ```
 
+## systemd 服务管理
+
+Linux systemd 环境中可使用 CLI 安装或卸载 `awsb.service`。安装命令会写入 systemd unit、执行 `systemctl daemon-reload`、启用开机自启，并在服务尚未运行时立即启动：
+
+```bash
+sudo awsb service install
+```
+
+卸载命令会在服务运行时先停止服务，禁用开机自启，删除 unit 文件，并重新执行 `systemctl daemon-reload`：
+
+```bash
+sudo awsb service uninstall
+```
+
+`service` 命令仅支持 Linux systemd；在其他平台会直接返回清晰错误。生成的 unit 会设置 `AWS_BRIDGE_SKIP_SETUP=true`，避免后台服务启动时阻塞在交互式配置引导。
+
 ## 关键环境变量
 
 | 变量名 | 说明 | 默认值 |

package/dist/services/cli-commands.d.ts

@@ -14,7 +14,14 @@ export interface CliCommandOptions {
     stderr?: (message: string) => void;
     runCommand?: (command: string, args: string[]) => CommandRunResult;
     configure?: () => Promise<StartupConfigWizardResult>;
+    platform?: NodeJS.Platform;
+    serviceUnitPath?: string;
+    executablePath?: string;
 }
 export declare function readPackageVersion(packageRoot?: string): string;
+/**
+ * 生成 systemd unit 内容，主流程是用当前 Node 可执行文件启动当前 CLI 入口。
+ */
+export declare function createSystemdUnitContent(executablePath: string): string;
 export declare function handleCliCommand(options?: CliCommandOptions): Promise<CliCommandResult>;
 //# sourceMappingURL=cli-commands.d.ts.map

package/dist/services/cli-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-commands.d.ts","sourceRoot":"","sources":["../../src/services/cli-commands.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAG5E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,gBAAgB,CAAC;IACnE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,yBAAyB,CAAC,CAAC;CACtD;AAYD,wBAAgB,kBAAkB,CAAC,WAAW,SAA0B,GAAG,MAAM,CAMhF;AAcD,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAqC3B"}
+{"version":3,"file":"cli-commands.d.ts","sourceRoot":"","sources":["../../src/services/cli-commands.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAM5E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,gBAAgB,CAAC;IACnE,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,yBAAyB,CAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAYD,wBAAgB,kBAAkB,CAAC,WAAW,SAA0B,GAAG,MAAM,CAMhF;AAgCD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAsBvE;AAwOD,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CA+C3B"}

package/dist/services/cli-commands.js

@@ -1,8 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureStartupConfig } from "./startup-config-wizard.js";
+const SYSTEMD_SERVICE_NAME = "awsb.service";
+const DEFAULT_SYSTEMD_UNIT_PATH = `/etc/systemd/system/${SYSTEMD_SERVICE_NAME}`;
 function getDefaultPackageRoot() {
     const currentFile = fileURLToPath(import.meta.url);
     return path.resolve(path.dirname(currentFile), "..", "..");
@@ -19,14 +21,215 @@ function defaultRunCommand(command, args) {
     });
     return { status: result.status, error: result.error };
 }
+function defaultStdout(message) {
+    process.stdout.write(`${message}\n`);
+}
+function defaultStderr(message) {
+    process.stderr.write(`${message}\n`);
+}
 function isVersionCommand(command) {
     return command === "-v" || command === "--version" || command === "version";
 }
+function quoteSystemdExecArg(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function getDefaultExecutablePath() {
+    return process.argv[1]
+        ? path.resolve(process.argv[1])
+        : fileURLToPath(import.meta.url);
+}
+/**
+ * 生成 systemd unit 内容，主流程是用当前 Node 可执行文件启动当前 CLI 入口。
+ */
+export function createSystemdUnitContent(executablePath) {
+    const execStart = [process.execPath, executablePath]
+        .map((part) => quoteSystemdExecArg(part))
+        .join(" ");
+    return [
+        "[Unit]",
+        "Description=AgentsWorkStudio Runtime Bridge",
+        "After=network-online.target",
+        "Wants=network-online.target",
+        "",
+        "[Service]",
+        "Type=simple",
+        "Environment=AWS_BRIDGE_SKIP_SETUP=true",
+        `ExecStart=${execStart}`,
+        "Restart=on-failure",
+        "RestartSec=5s",
+        "",
+        "[Install]",
+        "WantedBy=multi-user.target",
+        "",
+    ].join("\n");
+}
+function runSystemctl(runCommand, args) {
+    return runCommand("systemctl", args);
+}
+function systemctlFailureMessage(action, result) {
+    if (result.error) {
+        return `[runtime-bridge] ${action}失败: ${result.error.message}`;
+    }
+    return `[runtime-bridge] ${action}失败，systemctl 退出码: ${result.status ?? "unknown"}`;
+}
+function commandSucceeded(result) {
+    return !result.error && result.status === 0;
+}
+function ensureLinuxSystemd(platform, stderr) {
+    if (platform === "linux") {
+        return true;
+    }
+    stderr("[runtime-bridge] service 命令仅支持 Linux systemd 环境。");
+    return false;
+}
+function printServiceUsage(stdout) {
+    stdout("Usage: awsb service <install|uninstall>");
+}
+/**
+ * 安装 systemd 服务，主干流程是写入 unit、重载 systemd、启用开机自启，并在未运行时启动服务。
+ */
+function installSystemdService(options) {
+    if (!ensureLinuxSystemd(options.platform, options.stderr)) {
+        return { handled: true, exitCode: 1 };
+    }
+    const unitContent = createSystemdUnitContent(options.executablePath);
+    try {
+        mkdirSync(path.dirname(options.serviceUnitPath), { recursive: true });
+        writeFileSync(options.serviceUnitPath, unitContent, {
+            encoding: "utf-8",
+            mode: 0o644,
+        });
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        options.stderr(`[runtime-bridge] 写入 systemd unit 失败: ${err.message}`);
+        return { handled: true, exitCode: 1 };
+    }
+    const daemonReloadResult = runSystemctl(options.runCommand, ["daemon-reload"]);
+    if (!commandSucceeded(daemonReloadResult)) {
+        options.stderr(systemctlFailureMessage("重载 systemd", daemonReloadResult));
+        return { handled: true, exitCode: daemonReloadResult.status ?? 1 };
+    }
+    const enableResult = runSystemctl(options.runCommand, [
+        "enable",
+        SYSTEMD_SERVICE_NAME,
+    ]);
+    if (!commandSucceeded(enableResult)) {
+        options.stderr(systemctlFailureMessage("启用 awsb 开机自启", enableResult));
+        return { handled: true, exitCode: enableResult.status ?? 1 };
+    }
+    const activeResult = runSystemctl(options.runCommand, [
+        "is-active",
+        "--quiet",
+        SYSTEMD_SERVICE_NAME,
+    ]);
+    if (activeResult.error) {
+        options.stderr(systemctlFailureMessage("检查 awsb 服务状态", activeResult));
+        return { handled: true, exitCode: 1 };
+    }
+    if (activeResult.status !== 0) {
+        const startResult = runSystemctl(options.runCommand, [
+            "start",
+            SYSTEMD_SERVICE_NAME,
+        ]);
+        if (!commandSucceeded(startResult)) {
+            options.stderr(systemctlFailureMessage("启动 awsb 服务", startResult));
+            return { handled: true, exitCode: startResult.status ?? 1 };
+        }
+        options.stdout("[runtime-bridge] awsb systemd 服务已安装、已启用开机自启并已启动。");
+        return { handled: true, exitCode: 0 };
+    }
+    options.stdout("[runtime-bridge] awsb systemd 服务已安装并已启用开机自启；服务已在运行。");
+    return { handled: true, exitCode: 0 };
+}
+/**
+ * 卸载 systemd 服务，主干流程是按需停止、禁用自启、删除 unit，并重载 systemd。
+ */
+function uninstallSystemdService(options) {
+    if (!ensureLinuxSystemd(options.platform, options.stderr)) {
+        return { handled: true, exitCode: 1 };
+    }
+    const unitExists = existsSync(options.serviceUnitPath);
+    const activeResult = runSystemctl(options.runCommand, [
+        "is-active",
+        "--quiet",
+        SYSTEMD_SERVICE_NAME,
+    ]);
+    if (activeResult.error) {
+        options.stderr(systemctlFailureMessage("检查 awsb 服务状态", activeResult));
+        return { handled: true, exitCode: 1 };
+    }
+    if (activeResult.status === 0) {
+        const stopResult = runSystemctl(options.runCommand, [
+            "stop",
+            SYSTEMD_SERVICE_NAME,
+        ]);
+        if (!commandSucceeded(stopResult)) {
+            options.stderr(systemctlFailureMessage("停止 awsb 服务", stopResult));
+            return { handled: true, exitCode: stopResult.status ?? 1 };
+        }
+    }
+    const disableResult = runSystemctl(options.runCommand, [
+        "disable",
+        SYSTEMD_SERVICE_NAME,
+    ]);
+    if (disableResult.error || (disableResult.status !== 0 && unitExists)) {
+        options.stderr(systemctlFailureMessage("禁用 awsb 开机自启", disableResult));
+        return { handled: true, exitCode: disableResult.status ?? 1 };
+    }
+    if (unitExists) {
+        try {
+            unlinkSync(options.serviceUnitPath);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            options.stderr(`[runtime-bridge] 删除 systemd unit 失败: ${err.message}`);
+            return { handled: true, exitCode: 1 };
+        }
+    }
+    else {
+        options.stdout("[runtime-bridge] awsb systemd unit 不存在，跳过删除。");
+    }
+    const daemonReloadResult = runSystemctl(options.runCommand, ["daemon-reload"]);
+    if (!commandSucceeded(daemonReloadResult)) {
+        options.stderr(systemctlFailureMessage("重载 systemd", daemonReloadResult));
+        return { handled: true, exitCode: daemonReloadResult.status ?? 1 };
+    }
+    options.stdout("[runtime-bridge] awsb systemd 服务已卸载。");
+    return { handled: true, exitCode: 0 };
+}
+function handleServiceCommand(argv, options, stdout, stderr) {
+    const subcommand = argv[1];
+    if (!subcommand ||
+        subcommand === "-h" ||
+        subcommand === "--help" ||
+        subcommand === "help") {
+        printServiceUsage(stdout);
+        return { handled: true, exitCode: subcommand ? 0 : 1 };
+    }
+    const serviceOptions = {
+        stdout,
+        stderr,
+        runCommand: options.runCommand || defaultRunCommand,
+        platform: options.platform || process.platform,
+        serviceUnitPath: options.serviceUnitPath || DEFAULT_SYSTEMD_UNIT_PATH,
+        executablePath: options.executablePath || getDefaultExecutablePath(),
+    };
+    if (subcommand === "install") {
+        return installSystemdService(serviceOptions);
+    }
+    if (subcommand === "uninstall") {
+        return uninstallSystemdService(serviceOptions);
+    }
+    stderr(`[runtime-bridge] 未知 service 子命令: ${subcommand}`);
+    printServiceUsage(stdout);
+    return { handled: true, exitCode: 1 };
+}
 export async function handleCliCommand(options = {}) {
     const argv = options.argv || process.argv.slice(2);
     const command = argv[0];
-    const stdout = options.stdout || console.log;
-    const stderr = options.stderr || console.error;
+    const stdout = options.stdout || defaultStdout;
+    const stderr = options.stderr || defaultStderr;
     if (isVersionCommand(command)) {
         stdout(`aws-runtime-bridge ${readPackageVersion(options.packageRoot)}`);
         return { handled: true, exitCode: 0 };
@@ -34,7 +237,11 @@ export async function handleCliCommand(options = {}) {
     if (command === "update") {
         stdout("[runtime-bridge] 正在更新 aws-runtime-bridge 到最新版本...");
         const runCommand = options.runCommand || defaultRunCommand;
-        const result = runCommand("npm", ["install", "-g", "aws-runtime-bridge@latest"]);
+        const result = runCommand("npm", [
+            "install",
+            "-g",
+            "aws-runtime-bridge@latest",
+        ]);
         if (result.error) {
             stderr(`[runtime-bridge] 更新失败: ${result.error.message}`);
             return { handled: true, exitCode: 1 };
@@ -51,5 +258,8 @@ export async function handleCliCommand(options = {}) {
         const result = await configure();
         return { handled: true, exitCode: result === "configured" ? 0 : 1 };
     }
+    if (command === "service") {
+        return handleServiceCommand(argv, options, stdout, stderr);
+    }
     return { handled: false, exitCode: 0 };
 }

package/dist/services/cli-commands.test.js

@@ -1,8 +1,8 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { handleCliCommand, readPackageVersion } from "./cli-commands.js";
+import { createSystemdUnitContent, handleCliCommand, readPackageVersion, } from "./cli-commands.js";
 const tempRoots = [];
 function createPackageRoot(version = "9.8.7") {
     const root = mkdtempSync(path.join(os.tmpdir(), "aws-bridge-cli-"));
@@ -11,6 +11,14 @@ function createPackageRoot(version = "9.8.7") {
     writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "aws-runtime-bridge", version }), "utf-8");
     return root;
 }
+function createServiceUnitPath() {
+    const root = mkdtempSync(path.join(os.tmpdir(), "aws-bridge-service-"));
+    tempRoots.push(root);
+    return path.join(root, "systemd", "awsb.service");
+}
+function quotedSystemdArg(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
 afterEach(() => {
     for (const root of tempRoots.splice(0)) {
         rmSync(root, { recursive: true, force: true });
@@ -85,6 +93,136 @@ describe("cli commands", () => {
         });
         expect(result).toEqual({ handled: true, exitCode: 1 });
     });
+    it("creates a systemd unit that starts the current executable with setup skipped", () => {
+        const executablePath = "/opt/aws-runtime-bridge/dist/index.js";
+        const unit = createSystemdUnitContent(executablePath);
+        expect(unit).toContain("Description=AgentsWorkStudio Runtime Bridge");
+        expect(unit).toContain("Environment=AWS_BRIDGE_SKIP_SETUP=true");
+        expect(unit).toContain(`ExecStart=${quotedSystemdArg(process.execPath)} ${quotedSystemdArg(executablePath)}`);
+        expect(unit).toContain("Restart=on-failure");
+        expect(unit).toContain("WantedBy=multi-user.target");
+    });
+    it("installs service, enables autostart, and starts when inactive", async () => {
+        const output = [];
+        const commands = [];
+        const serviceUnitPath = createServiceUnitPath();
+        const executablePath = "/usr/local/bin/awsb";
+        const result = await handleCliCommand({
+            argv: ["service", "install"],
+            platform: "linux",
+            serviceUnitPath,
+            executablePath,
+            stdout: (message) => output.push(message),
+            runCommand: (command, args) => {
+                commands.push({ command, args });
+                if (args[0] === "is-active") {
+                    return { status: 3 };
+                }
+                return { status: 0 };
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(readFileSync(serviceUnitPath, "utf-8")).toContain(`ExecStart=${quotedSystemdArg(process.execPath)} ${quotedSystemdArg(executablePath)}`);
+        expect(commands).toEqual([
+            { command: "systemctl", args: ["daemon-reload"] },
+            { command: "systemctl", args: ["enable", "awsb.service"] },
+            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
+            { command: "systemctl", args: ["start", "awsb.service"] },
+        ]);
+        expect(output.at(-1)).toBe("[runtime-bridge] awsb systemd 服务已安装、已启用开机自启并已启动。");
+    });
+    it("does not start service during install when it is already active", async () => {
+        const commands = [];
+        const serviceUnitPath = createServiceUnitPath();
+        const result = await handleCliCommand({
+            argv: ["service", "install"],
+            platform: "linux",
+            serviceUnitPath,
+            executablePath: "/usr/local/bin/awsb",
+            runCommand: (command, args) => {
+                commands.push({ command, args });
+                return { status: 0 };
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(commands).toEqual([
+            { command: "systemctl", args: ["daemon-reload"] },
+            { command: "systemctl", args: ["enable", "awsb.service"] },
+            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
+        ]);
+    });
+    it("uninstalls service by stopping, disabling, removing unit, and reloading systemd", async () => {
+        const output = [];
+        const commands = [];
+        const serviceUnitPath = createServiceUnitPath();
+        mkdirSync(path.dirname(serviceUnitPath), { recursive: true });
+        writeFileSync(serviceUnitPath, "unit", "utf-8");
+        const result = await handleCliCommand({
+            argv: ["service", "uninstall"],
+            platform: "linux",
+            serviceUnitPath,
+            stdout: (message) => output.push(message),
+            runCommand: (command, args) => {
+                commands.push({ command, args });
+                return { status: 0 };
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(existsSync(serviceUnitPath)).toBe(false);
+        expect(commands).toEqual([
+            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
+            { command: "systemctl", args: ["stop", "awsb.service"] },
+            { command: "systemctl", args: ["disable", "awsb.service"] },
+            { command: "systemctl", args: ["daemon-reload"] },
+        ]);
+        expect(output.at(-1)).toBe("[runtime-bridge] awsb systemd 服务已卸载。");
+    });
+    it("tolerates uninstall when service is inactive and unit is absent", async () => {
+        const output = [];
+        const commands = [];
+        const serviceUnitPath = createServiceUnitPath();
+        const result = await handleCliCommand({
+            argv: ["service", "uninstall"],
+            platform: "linux",
+            serviceUnitPath,
+            stdout: (message) => output.push(message),
+            runCommand: (command, args) => {
+                commands.push({ command, args });
+                if (args[0] === "is-active" || args[0] === "disable") {
+                    return { status: 1 };
+                }
+                return { status: 0 };
+            },
+        });
+        expect(result).toEqual({ handled: true, exitCode: 0 });
+        expect(commands).toEqual([
+            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
+            { command: "systemctl", args: ["disable", "awsb.service"] },
+            { command: "systemctl", args: ["daemon-reload"] },
+        ]);
+        expect(output).toContain("[runtime-bridge] awsb systemd unit 不存在，跳过删除。");
+    });
+    it("fails service commands clearly on non-linux platforms", async () => {
+        const errors = [];
+        const result = await handleCliCommand({
+            argv: ["service", "install"],
+            platform: "win32",
+            stderr: (message) => errors.push(message),
+        });
+        expect(result).toEqual({ handled: true, exitCode: 1 });
+        expect(errors).toEqual([
+            "[runtime-bridge] service 命令仅支持 Linux systemd 环境。",
+        ]);
+    });
+    it("prints service help for missing subcommand", async () => {
+        const output = [];
+        const result = await handleCliCommand({
+            argv: ["service"],
+            stdout: (message) => output.push(message),
+        });
+        expect(result).toEqual({ handled: true, exitCode: 1 });
+        expect(output).toEqual(["Usage: awsb service <install|uninstall>"]);
+    });
     it("does not handle normal startup arguments", async () => {
         const result = await handleCliCommand({ argv: [] });
         expect(result).toEqual({ handled: false, exitCode: 0 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-runtime-bridge",
-  "version": "1.3.2",
+  "version": "1.3.5",
   "description": "AgentsWorkStudio runtime bridge service for machine-level agent runtime integration",
   "type": "module",
   "main": "dist/index.js",