@opentrust/cli 7.3.18 → 7.3.21

package/dist/commands/connect.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerConnectCommand(program: Command): void;

package/dist/commands/connect.js

@@ -0,0 +1,192 @@
+import { DashboardClient, loadConfig, saveConfig, clearConfig, } from "../lib/dashboard-client.js";
+import { getHostInfo, getServicesSnapshot, getSystemMetadata } from "../lib/host-reporter.js";
+import { executeHostCommand } from "../lib/command-handler.js";
+import { projectMode, projectRoot } from "../lib/paths.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawn } from "node:child_process";
+const HEARTBEAT_INTERVAL = 30_000;
+const POLL_INTERVAL = 10_000;
+const PID_FILE = path.join(os.homedir(), ".opentrust", "connect.pid");
+export function registerConnectCommand(program) {
+    program
+        .command("connect")
+        .description("Connect this host to an OpenTrust Dashboard for remote management")
+        .option("--dashboard-url <url>", "Dashboard URL (e.g. http://host:53667)")
+        .option("--api-key <key>", "Core API key (sk-og-...)")
+        .option("--daemon", "Run in background as a daemon process")
+        .action(async (opts) => {
+        let config = loadConfig();
+        if (opts.dashboardUrl && opts.apiKey) {
+            config = {
+                dashboardUrl: opts.dashboardUrl,
+                apiKey: opts.apiKey,
+                hostId: config?.hostId,
+            };
+            saveConfig(config);
+            console.log("Configuration saved to ~/.opentrust/client.json");
+        }
+        if (!config?.dashboardUrl || !config?.apiKey) {
+            console.error("No connection configured.");
+            console.error("");
+            console.error("Usage:");
+            console.error("  opentrust connect --dashboard-url http://host:53667 --api-key sk-og-xxx");
+            process.exit(1);
+        }
+        if (opts.daemon) {
+            launchDaemon(config);
+            return;
+        }
+        await runDaemon(config);
+    });
+    program
+        .command("disconnect")
+        .description("Disconnect this host from Dashboard and clear configuration")
+        .action(async () => {
+        const config = loadConfig();
+        if (config?.dashboardUrl && config?.apiKey) {
+            try {
+                const client = new DashboardClient(config);
+                await client.disconnect();
+                console.log("Host unregistered from Dashboard.");
+            }
+            catch {
+                // Dashboard may be unreachable; still clear local config
+            }
+        }
+        stopDaemon();
+        clearConfig();
+        console.log("Configuration cleared. Host disconnected.");
+    });
+}
+function launchDaemon(config) {
+    if (fs.existsSync(PID_FILE)) {
+        const existingPid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+        try {
+            process.kill(existingPid, 0);
+            console.log(`Connect daemon already running (PID ${existingPid}).`);
+            return;
+        }
+        catch {
+            // stale pid file
+        }
+    }
+    const logFile = path.join(os.homedir(), ".opentrust", "logs", "connect.log");
+    const logDir = path.dirname(logFile);
+    if (!fs.existsSync(logDir))
+        fs.mkdirSync(logDir, { recursive: true });
+    const logFd = fs.openSync(logFile, "a");
+    const child = spawn(process.execPath, [process.argv[1], "connect"], {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: ["ignore", logFd, logFd],
+        detached: true,
+    });
+    if (child.pid) {
+        fs.writeFileSync(PID_FILE, String(child.pid), "utf-8");
+        child.unref();
+        fs.closeSync(logFd);
+        console.log(`Connect daemon started (PID ${child.pid}).`);
+        console.log(`Logs: ${logFile}`);
+    }
+    else {
+        fs.closeSync(logFd);
+        console.error("Failed to launch daemon.");
+        process.exit(1);
+    }
+}
+function stopDaemon() {
+    if (!fs.existsSync(PID_FILE))
+        return;
+    const pid = parseInt(fs.readFileSync(PID_FILE, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, "SIGTERM");
+        console.log(`Daemon stopped (PID ${pid}).`);
+    }
+    catch {
+        // already dead
+    }
+    try {
+        fs.unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+async function runDaemon(config) {
+    const client = new DashboardClient(config);
+    const log = (msg) => console.log(`[${new Date().toISOString()}] ${msg}`);
+    // Register
+    log("Registering with Dashboard...");
+    const hostInfo = getHostInfo();
+    const services = await getServicesSnapshot();
+    const metadata = getSystemMetadata();
+    try {
+        const hostId = await client.register({
+            ...hostInfo,
+            projectMode,
+            projectRoot,
+            services,
+            metadata,
+        });
+        config.hostId = hostId;
+        saveConfig(config);
+        log(`Registered as host ${hostId}`);
+    }
+    catch (err) {
+        log(`Registration failed: ${err.message}`);
+        process.exit(1);
+    }
+    // Heartbeat
+    const heartbeat = async () => {
+        try {
+            const svc = await getServicesSnapshot();
+            const meta = getSystemMetadata();
+            await client.heartbeat({ services: svc, metadata: meta });
+        }
+        catch (err) {
+            log(`Heartbeat failed: ${err.message}`);
+        }
+    };
+    const heartbeatTimer = setInterval(heartbeat, HEARTBEAT_INTERVAL);
+    // Command polling
+    const poll = async () => {
+        try {
+            const cmds = await client.fetchPendingCommands();
+            for (const cmd of cmds) {
+                log(`Executing command: ${cmd.type} (${cmd.id})`);
+                await client.ackCommand(cmd.id, "running").catch(() => { });
+                const result = executeHostCommand(cmd);
+                await client
+                    .ackCommand(cmd.id, result.success ? "completed" : "failed", {
+                    output: result.output,
+                    error: result.error,
+                })
+                    .catch(() => { });
+                log(`Command ${cmd.id}: ${result.success ? "completed" : "failed"}`);
+            }
+        }
+        catch {
+            // Dashboard may be unreachable
+        }
+    };
+    const pollTimer = setInterval(poll, POLL_INTERVAL);
+    poll();
+    // Graceful shutdown
+    const shutdown = async () => {
+        log("Shutting down...");
+        clearInterval(heartbeatTimer);
+        clearInterval(pollTimer);
+        try {
+            await client.heartbeat({ services: await getServicesSnapshot(), metadata: { ...getSystemMetadata(), shuttingDown: true } });
+        }
+        catch { }
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch { }
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    log("Connected. Listening for commands... (Ctrl+C to stop)");
+}

package/dist/commands/init.js

@@ -13,9 +13,9 @@ const SCAFFOLD_PKG = {
         status: "opentrust status",
     },
     dependencies: {
-        "@opentrust/core": "^7.3.18",
-        "@opentrust/gateway": "^7.3.18",
-        "@opentrust/dashboard": "^7.3.18",
+        "@opentrust/core": "^7.3.21",
+        "@opentrust/gateway": "^7.3.21",
+        "@opentrust/dashboard": "^7.3.21",
     },
 };
 const ENV_TEMPLATE = `# OpenTrust Configuration

package/dist/index.js

@@ -10,6 +10,7 @@ import { registerStatusCommand } from "./commands/status.js";
 import { registerSetupCommand } from "./commands/setup.js";
 import { registerLogsCommand } from "./commands/logs.js";
 import { registerUpgradeCommand } from "./commands/upgrade.js";
+import { registerConnectCommand } from "./commands/connect.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
 const program = new Command();
@@ -24,4 +25,5 @@ registerStopCommand(program);
 registerStatusCommand(program);
 registerLogsCommand(program);
 registerUpgradeCommand(program);
+registerConnectCommand(program);
 program.parse();

package/dist/lib/command-handler.d.ts

@@ -0,0 +1,7 @@
+import type { HostCommand } from "./dashboard-client.js";
+export interface CommandResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+}
+export declare function executeHostCommand(cmd: HostCommand): CommandResult;

package/dist/lib/command-handler.js

@@ -0,0 +1,141 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { startService, stopService, getStatus, SERVICES } from "./process-manager.js";
+import { paths, projectRoot, projectMode } from "./paths.js";
+const SERVICE_KEYS = Object.keys(SERVICES);
+export function executeHostCommand(cmd) {
+    const payload = cmd.payload ?? {};
+    switch (cmd.type) {
+        case "start_service":
+            return handleStartService(payload);
+        case "stop_service":
+            return handleStopService(payload);
+        case "restart_service":
+            return handleRestartService(payload);
+        case "upgrade":
+            return handleUpgrade(payload);
+        case "fetch_logs":
+            return handleFetchLogs(payload);
+        case "update_env":
+            return handleUpdateEnv(payload);
+        default:
+            return { success: false, error: `Unknown command type: ${cmd.type}` };
+    }
+}
+function handleStartService(payload) {
+    const service = payload.service;
+    if (!service)
+        return { success: false, error: "Missing service in payload" };
+    const keys = service === "all" ? SERVICE_KEYS : [service];
+    const results = [];
+    for (const key of keys) {
+        if (!SERVICES[key]) {
+            results.push(`${key}: unknown service`);
+            continue;
+        }
+        const ok = startService(key);
+        results.push(`${key}: ${ok ? "started" : "failed to start"}`);
+    }
+    return { success: true, output: results.join("\n") };
+}
+function handleStopService(payload) {
+    const service = payload.service;
+    if (!service)
+        return { success: false, error: "Missing service in payload" };
+    const keys = service === "all" ? SERVICE_KEYS : [service];
+    const results = [];
+    for (const key of keys) {
+        if (!SERVICES[key]) {
+            results.push(`${key}: unknown service`);
+            continue;
+        }
+        const ok = stopService(key);
+        results.push(`${key}: ${ok ? "stopped" : "was not running"}`);
+    }
+    return { success: true, output: results.join("\n") };
+}
+function handleRestartService(payload) {
+    const service = payload.service;
+    if (!service)
+        return { success: false, error: "Missing service in payload" };
+    const keys = service === "all" ? SERVICE_KEYS : [service];
+    const results = [];
+    for (const key of keys) {
+        if (!SERVICES[key]) {
+            results.push(`${key}: unknown service`);
+            continue;
+        }
+        const status = getStatus(key);
+        if (status.running)
+            stopService(key);
+        const ok = startService(key);
+        results.push(`${key}: ${ok ? "restarted" : "failed to restart"}`);
+    }
+    return { success: true, output: results.join("\n") };
+}
+function handleUpgrade(payload) {
+    const version = payload.version || "latest";
+    try {
+        const results = [];
+        const cliOut = execSync(`npm install -g @opentrust/cli@${version}`, {
+            encoding: "utf-8",
+            timeout: 120_000,
+        });
+        results.push(`CLI: upgraded to ${version}`);
+        if (projectMode === "npm") {
+            const pkgs = ["@opentrust/core", "@opentrust/gateway", "@opentrust/dashboard"].map((p) => `${p}@${version}`);
+            execSync(`npm install ${pkgs.join(" ")}`, {
+                encoding: "utf-8",
+                cwd: projectRoot,
+                timeout: 120_000,
+            });
+            results.push(`Packages: upgraded to ${version}`);
+        }
+        return { success: true, output: results.join("\n") };
+    }
+    catch (err) {
+        return { success: false, error: (err.stderr || err.message || String(err)).slice(0, 1000) };
+    }
+}
+function handleFetchLogs(payload) {
+    const service = payload.service;
+    const lines = payload.lines || 200;
+    if (!service || !SERVICE_KEYS.includes(service)) {
+        return { success: false, error: `Invalid service. Must be one of: ${SERVICE_KEYS.join(", ")}` };
+    }
+    const logFile = path.join(paths.logs, `${service}.log`);
+    if (!fs.existsSync(logFile)) {
+        return { success: true, output: "(no log file)" };
+    }
+    try {
+        const content = fs.readFileSync(logFile, "utf-8");
+        const allLines = content.split("\n");
+        const tail = allLines.slice(-lines).join("\n");
+        return { success: true, output: tail.slice(-50_000) };
+    }
+    catch (err) {
+        return { success: false, error: err.message };
+    }
+}
+function handleUpdateEnv(payload) {
+    const key = payload.key;
+    const value = payload.value;
+    if (!key)
+        return { success: false, error: "Missing key in payload" };
+    const envFile = path.join(projectRoot, ".env");
+    let content = "";
+    if (fs.existsSync(envFile)) {
+        content = fs.readFileSync(envFile, "utf-8");
+    }
+    const lines = content.split("\n");
+    const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+    if (idx >= 0) {
+        lines[idx] = `${key}=${value}`;
+    }
+    else {
+        lines.push(`${key}=${value}`);
+    }
+    fs.writeFileSync(envFile, lines.join("\n"), "utf-8");
+    return { success: true, output: `${key}=${value}` };
+}

package/dist/lib/dashboard-client.d.ts

@@ -0,0 +1,41 @@
+export interface ClientConfig {
+    dashboardUrl: string;
+    apiKey: string;
+    hostId?: string;
+}
+export interface HostCommand {
+    id: string;
+    hostId: string;
+    type: string;
+    payload: Record<string, unknown> | null;
+    status: string;
+    createdAt: string;
+}
+export declare function loadConfig(): ClientConfig | null;
+export declare function saveConfig(config: ClientConfig): void;
+export declare function clearConfig(): void;
+export declare class DashboardClient {
+    private baseUrl;
+    private apiKey;
+    hostId: string | undefined;
+    constructor(config: ClientConfig);
+    private request;
+    register(data: {
+        hostname: string;
+        os: string;
+        arch: string;
+        ip: string;
+        cliVersion: string;
+        projectMode: string;
+        projectRoot: string;
+        services?: Record<string, unknown>;
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    heartbeat(data: {
+        services?: Record<string, unknown>;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    fetchPendingCommands(): Promise<HostCommand[]>;
+    ackCommand(id: string, status: "running" | "completed" | "failed", result?: Record<string, unknown>): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/lib/dashboard-client.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const CONFIG_DIR = path.join(os.homedir(), ".opentrust");
+const CONFIG_FILE = path.join(CONFIG_DIR, "client.json");
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE))
+            return null;
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export function clearConfig() {
+    try {
+        fs.unlinkSync(CONFIG_FILE);
+    }
+    catch { }
+}
+export class DashboardClient {
+    baseUrl;
+    apiKey;
+    hostId;
+    constructor(config) {
+        this.baseUrl = config.dashboardUrl.replace(/\/+$/, "");
+        this.apiKey = config.apiKey;
+        this.hostId = config.hostId;
+    }
+    async request(path, options) {
+        const { timeoutMs = 15_000, ...init } = options ?? {};
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                ...init,
+                signal: controller.signal,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                    ...init?.headers,
+                },
+            });
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new Error(`HTTP ${res.status}: ${text}`);
+            }
+            return (await res.json());
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async register(data) {
+        const resp = await this.request("/api/hosts/register", { method: "POST", body: JSON.stringify(data), timeoutMs: 20_000 });
+        this.hostId = resp.data.id;
+        return resp.data.id;
+    }
+    async heartbeat(data) {
+        if (!this.hostId)
+            return;
+        await this.request(`/api/hosts/${this.hostId}/heartbeat`, {
+            method: "POST",
+            body: JSON.stringify(data),
+        });
+    }
+    async fetchPendingCommands() {
+        if (!this.hostId)
+            return [];
+        const resp = await this.request(`/api/hosts/commands/pending?hostId=${this.hostId}`);
+        return resp.data;
+    }
+    async ackCommand(id, status, result) {
+        await this.request(`/api/hosts/commands/${id}/ack`, {
+            method: "PUT",
+            body: JSON.stringify({ status, result }),
+        });
+    }
+    async disconnect() {
+        if (!this.hostId)
+            return;
+        try {
+            await this.request(`/api/hosts/${this.hostId}`, { method: "DELETE" });
+        }
+        catch { }
+    }
+}

package/dist/lib/host-reporter.d.ts

@@ -0,0 +1,9 @@
+export declare function getHostInfo(): {
+    hostname: string;
+    os: string;
+    arch: string;
+    ip: string;
+    cliVersion: string;
+};
+export declare function getServicesSnapshot(): Promise<Record<string, unknown>>;
+export declare function getSystemMetadata(): Record<string, unknown>;

package/dist/lib/host-reporter.js

@@ -0,0 +1,59 @@
+import os from "node:os";
+import fs from "node:fs";
+import path from "node:path";
+import { getStatus, checkHealth, getAllServiceKeys, SERVICES } from "./process-manager.js";
+function getLocalIp() {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] ?? []) {
+            if (iface.family === "IPv4" && !iface.internal)
+                return iface.address;
+        }
+    }
+    return "127.0.0.1";
+}
+function getCliVersion() {
+    try {
+        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "../../package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function getHostInfo() {
+    return {
+        hostname: os.hostname(),
+        os: `${os.platform()} ${os.release()}`,
+        arch: os.arch(),
+        ip: getLocalIp(),
+        cliVersion: getCliVersion(),
+    };
+}
+export async function getServicesSnapshot() {
+    const result = {};
+    for (const key of getAllServiceKeys()) {
+        const svc = SERVICES[key];
+        const status = getStatus(key);
+        const healthy = status.running ? await checkHealth(key) : false;
+        result[key] = {
+            name: svc.name,
+            port: svc.port,
+            running: status.running,
+            pid: status.pid ?? null,
+            healthy,
+        };
+    }
+    return result;
+}
+export function getSystemMetadata() {
+    const cpus = os.cpus();
+    return {
+        cpuModel: cpus[0]?.model ?? "unknown",
+        cpuCount: cpus.length,
+        totalMemMB: Math.round(os.totalmem() / 1048576),
+        freeMemMB: Math.round(os.freemem() / 1048576),
+        uptime: os.uptime(),
+        nodeVersion: process.version,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentrust/cli",
-  "version": "7.3.18",
+  "version": "7.3.21",
   "description": "CLI tool to manage OpenTrust AI Agent Runtime Security Platform — setup, start, stop, status, logs",
   "type": "module",
   "bin": {