@getforgeai/cli 0.1.0-beta.1

package/dist/commands/auth-login.js

@@ -0,0 +1,202 @@
+import { randomUUID } from "node:crypto";
+import chalk from "chalk";
+import open from "open";
+import ora from "ora";
+import { createCliAuthClient } from "../lib/auth-client.js";
+import { getConfig, getServerUrl, setConfig, } from "../config/config-manager.js";
+import { saveToken } from "../config/token-manager.js";
+import { createRestClient, getOrgSelection } from "../lib/rest-client.js";
+const CLIENT_ID = "forgeai-cli";
+const GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+const MAX_POLL_DURATION_MS = 30 * 60 * 1000; // 30 minutes
+export async function loginAction(options) {
+    const authClient = createCliAuthClient(options.server);
+    const spinner = ora("Requesting device authorization...").start();
+    const { data, error } = await authClient.device.code({
+        client_id: CLIENT_ID,
+    });
+    if (error || !data) {
+        spinner.fail("Failed to request device authorization.");
+        if (error) {
+            const errorMsg = typeof error === "object" && error !== null && "message" in error
+                ? String(error.message)
+                : JSON.stringify(error);
+            console.error(chalk.red(`Error: ${errorMsg}`));
+        }
+        process.exit(1);
+    }
+    const { device_code, user_code, verification_uri, verification_uri_complete, interval = 5, } = data;
+    spinner.stop();
+    console.log();
+    console.log(chalk.bold("Device Authorization"));
+    console.log();
+    console.log(`  Visit:  ${chalk.cyan(verification_uri)}`);
+    console.log(`  Code:   ${chalk.bold.yellow(user_code)}`);
+    console.log();
+    const urlToOpen = verification_uri_complete ?? verification_uri;
+    try {
+        await open(urlToOpen);
+        console.log(chalk.dim("Browser opened automatically."));
+    }
+    catch {
+        console.log(chalk.dim("Open the URL above in your browser."));
+    }
+    console.log();
+    const pollSpinner = ora("Waiting for authorization...").start();
+    const serverUrl = options.server ?? getServerUrl();
+    await pollForToken(authClient, device_code, interval, pollSpinner, user_code, serverUrl);
+    // Persist server URL on successful login
+    if (options.server) {
+        setConfig({ serverUrl: options.server });
+    }
+}
+async function handleSuccessfulAuth(authClient, accessToken, userCode, serverUrl, spinner) {
+    try {
+        saveToken(accessToken);
+    }
+    catch (saveError) {
+        spinner.fail(`Failed to save token: ${String(saveError)}`);
+        process.exit(1);
+    }
+    const { data: session } = await authClient.getSession({
+        fetchOptions: {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        },
+    });
+    try {
+        await handleOrgSelection(authClient, serverUrl, accessToken, userCode);
+    }
+    catch {
+        // Non-fatal: org fetch failure shouldn't block login
+    }
+    spinner.succeed("Authentication successful!");
+    console.log();
+    if (session?.user) {
+        console.log(`  Signed in as: ${chalk.bold(session.user.name ?? session.user.email)}`);
+        console.log(`  Email:        ${session.user.email}`);
+    }
+    const config = getConfig();
+    if (config.linkedOrgs && config.linkedOrgs.length > 1) {
+        console.log(`  Linked to: ${config.linkedOrgs.map((o) => o.orgSlug).join(", ")}`);
+    }
+    else if (config.defaultOrg) {
+        console.log(`  Org:          ${config.defaultOrg}`);
+    }
+    console.log();
+}
+async function handleOrgSelection(authClient, serverUrl, accessToken, userCode) {
+    const orgSelection = await getOrgSelection(serverUrl, accessToken, userCode);
+    if (orgSelection.orgIds.length > 0) {
+        await handleApprovedOrgSelection(orgSelection, serverUrl, accessToken);
+    }
+    else {
+        await handleFallbackOrgList(authClient, accessToken);
+    }
+}
+async function handleApprovedOrgSelection(orgSelection, serverUrl, accessToken) {
+    const linkedOrgs = orgSelection.orgIds.map((orgId, i) => ({
+        orgId,
+        orgSlug: orgSelection.orgSlugs[i] ?? "",
+    }));
+    setConfig({
+        defaultOrg: linkedOrgs[0]?.orgSlug,
+        defaultOrgId: linkedOrgs[0]?.orgId,
+        linkedOrgs,
+    });
+    const cliId = getConfig().cliId ?? randomUUID();
+    const { stableHostname } = await import("../config/token-manager.js");
+    const cliName = getConfig().cliName ?? stableHostname();
+    if (!getConfig().cliId) {
+        setConfig({ cliId });
+    }
+    for (const org of linkedOrgs) {
+        try {
+            const restClient = createRestClient(serverUrl, accessToken, org.orgId);
+            await restClient.registerCli({ cliId, name: cliName });
+        }
+        catch {
+            // Non-fatal: registration failure per org shouldn't block login
+        }
+    }
+}
+async function handleFallbackOrgList(authClient, accessToken) {
+    const { data: orgsData } = await authClient.organization.list({
+        fetchOptions: {
+            headers: { Authorization: `Bearer ${accessToken}` },
+        },
+    });
+    if (orgsData && orgsData.length > 0) {
+        const defaultOrg = orgsData[0];
+        const linkedOrgs = orgsData.map((org) => ({
+            orgId: org.id,
+            orgSlug: org.slug,
+            orgName: org.name,
+        }));
+        setConfig({
+            defaultOrg: defaultOrg.slug,
+            defaultOrgId: defaultOrg.id,
+            linkedOrgs,
+        });
+    }
+}
+function handleTokenError(error, spinner, pollingInterval) {
+    const errorCode = error.error;
+    switch (errorCode) {
+        case "authorization_pending":
+            return true;
+        case "slow_down":
+            pollingInterval.value += 5;
+            return true;
+        case "access_denied":
+            spinner.fail("Access was denied by the user.");
+            process.exit(1);
+        case "expired_token":
+            spinner.fail("The device code has expired. Please try again.");
+            process.exit(1);
+        default: {
+            const failMsg = typeof error === "object" && error !== null && "message" in error
+                ? String(error.message)
+                : JSON.stringify(error);
+            spinner.fail(`Authorization failed: ${failMsg}`);
+            process.exit(1);
+        }
+    }
+}
+async function pollForToken(authClient, deviceCode, initialInterval, spinner, userCode, serverUrl) {
+    const pollingInterval = { value: initialInterval };
+    const startTime = Date.now();
+    const poll = async () => {
+        if (Date.now() - startTime > MAX_POLL_DURATION_MS) {
+            spinner.fail("Device authorization timed out. Please try again.");
+            process.exit(1);
+        }
+        try {
+            const { data, error } = await authClient.device.token({
+                grant_type: GRANT_TYPE,
+                device_code: deviceCode,
+                client_id: CLIENT_ID,
+            });
+            if (data?.access_token) {
+                await handleSuccessfulAuth(authClient, data.access_token, userCode, serverUrl, spinner);
+                return;
+            }
+            if (error) {
+                handleTokenError(error, spinner, pollingInterval);
+            }
+        }
+        catch (networkError) {
+            spinner.fail(`Network error: ${String(networkError)}`);
+            process.exit(1);
+        }
+        await sleep(pollingInterval.value * 1000);
+        return poll();
+    };
+    await sleep(pollingInterval.value * 1000);
+    return poll();
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=auth-login.js.map

package/dist/commands/auth-logout.d.ts

@@ -0,0 +1,2 @@
+export declare function logoutAction(): Promise<void>;
+//# sourceMappingURL=auth-logout.d.ts.map

package/dist/commands/auth-logout.js

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { clearSessionConfig } from "../config/config-manager.js";
+import { deleteToken, loadToken } from "../config/token-manager.js";
+import { isDaemonRunning } from "../lib/daemon.js";
+import { DaemonNotRunningError, sendIpcCommand } from "../lib/ipc-client.js";
+export async function logoutAction() {
+    const token = loadToken();
+    if (!token) {
+        console.log();
+        console.log(chalk.dim("No stored credentials found."));
+        console.log();
+        return;
+    }
+    // Stop running daemon before clearing credentials — the daemon holds
+    // in-memory org context and socket connections tied to the current token.
+    const daemonPid = isDaemonRunning();
+    if (daemonPid) {
+        try {
+            await sendIpcCommand({ cmd: "shutdown" });
+            console.log(chalk.dim("Daemon stopped."));
+        }
+        catch (error) {
+            if (!(error instanceof DaemonNotRunningError)) {
+                // Daemon PID exists but IPC failed — force kill
+                try {
+                    process.kill(daemonPid, "SIGTERM");
+                    console.log(chalk.dim("Daemon stopped."));
+                }
+                catch {
+                    // Process already gone
+                }
+            }
+        }
+    }
+    deleteToken();
+    clearSessionConfig();
+    console.log();
+    console.log(chalk.green("Signed out successfully."));
+    console.log();
+}
+//# sourceMappingURL=auth-logout.js.map

package/dist/commands/auth-status.d.ts

@@ -0,0 +1,4 @@
+export declare function statusAction(options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=auth-status.d.ts.map

package/dist/commands/auth-status.js

@@ -0,0 +1,81 @@
+import chalk from "chalk";
+import { createCliAuthClient } from "../lib/auth-client.js";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+export async function statusAction(options) {
+    const token = loadToken();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!token) {
+        console.log();
+        console.log(chalk.yellow("Not authenticated."));
+        console.log();
+        console.log(`  Run ${chalk.cyan("forge auth login")} to sign in.`);
+        console.log();
+        return;
+    }
+    const authClient = createCliAuthClient(serverUrl);
+    try {
+        const { data: session } = await authClient.getSession({
+            fetchOptions: {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            },
+        });
+        if (session?.user) {
+            console.log();
+            console.log(chalk.green("Authenticated"));
+            console.log();
+            console.log(`  User:   ${chalk.bold(session.user.name ?? session.user.email)}`);
+            console.log(`  Email:  ${session.user.email}`);
+            console.log(`  Server: ${serverUrl}`);
+            const config = getConfig();
+            if (config.defaultOrg) {
+                console.log(`  Org:    ${config.defaultOrg}`);
+            }
+            // Cloud connectivity check via heartbeat
+            if (config.defaultOrgId) {
+                await checkCloudConnectivity(serverUrl, token, config.defaultOrgId);
+            }
+            else {
+                console.log();
+                console.log(chalk.dim("  No org linked. Run forge auth login to link an org."));
+            }
+            console.log();
+        }
+        else {
+            console.log();
+            console.log(chalk.yellow("Token is invalid or expired."));
+            console.log();
+            console.log(`  Run ${chalk.cyan("forge auth login")} to re-authenticate.`);
+            console.log();
+        }
+    }
+    catch {
+        console.log();
+        console.log(chalk.yellow("Token is invalid or expired."));
+        console.log();
+        console.log(`  Run ${chalk.cyan("forge auth login")} to re-authenticate.`);
+        console.log();
+    }
+}
+async function checkCloudConnectivity(serverUrl, token, orgId) {
+    try {
+        const client = createRestClient(serverUrl, token, orgId, {
+            timeoutMs: 5000,
+        });
+        const result = await client.heartbeat({
+            cliId: "status-probe",
+            agentSlots: 0,
+            activeAgents: 0,
+        });
+        if (result.status === "ok") {
+            console.log(`  Cloud:  ${chalk.green("Connected")}`);
+        }
+    }
+    catch {
+        console.log(`  Cloud:  ${chalk.yellow("Unreachable")}`);
+    }
+}
+//# sourceMappingURL=auth-status.js.map

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

@@ -0,0 +1,4 @@
+export declare function cliListAction(options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=cli-list.d.ts.map

package/dist/commands/cli-list.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+export async function cliListAction(options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!config.defaultOrgId) {
+        console.error(chalk.red("No organization configured. Run `forge auth login` to select one."));
+        return;
+    }
+    const restClient = createRestClient(serverUrl, token, config.defaultOrgId);
+    try {
+        const { devices } = await restClient.listCliDevices();
+        if (devices.length === 0) {
+            console.log(chalk.yellow("No CLI devices registered."));
+            return;
+        }
+        console.log(chalk.bold(`\nRegistered CLIs (${devices.length}):\n`));
+        for (const device of devices) {
+            const isCurrent = device.cliId === config.cliId;
+            const marker = isCurrent ? chalk.green(" (current)") : "";
+            const lastSeen = device.lastSeenAt
+                ? new Date(device.lastSeenAt).toLocaleString()
+                : "never";
+            console.log(`  ${chalk.bold(device.name)}${marker}`);
+            console.log(`    ID: ${device.cliId}  Owner: ${device.memberName}  Agents: ${device.agentSlots}  Last seen: ${lastSeen}`);
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to list CLIs: ${error instanceof Error ? error.message : String(error)}`));
+    }
+}
+//# sourceMappingURL=cli-list.js.map

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

@@ -0,0 +1,4 @@
+export declare function cliUnlinkAction(cliId: string, options: {
+    server?: string;
+}): Promise<void>;
+//# sourceMappingURL=cli-unlink.d.ts.map

package/dist/commands/cli-unlink.js

@@ -0,0 +1,45 @@
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { getConfig, getServerUrl } from "../config/config-manager.js";
+import { loadToken } from "../config/token-manager.js";
+import { createRestClient } from "../lib/rest-client.js";
+function confirm(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}
+export async function cliUnlinkAction(cliId, options) {
+    const token = loadToken();
+    if (!token) {
+        console.error(chalk.red("Not authenticated. Run `forge auth login` first."));
+        return;
+    }
+    const config = getConfig();
+    const serverUrl = options.server ?? getServerUrl();
+    if (!config.defaultOrgId) {
+        console.error(chalk.red("No organization configured. Run `forge auth login` to select one."));
+        return;
+    }
+    const isSelf = cliId === config.cliId;
+    const warning = isSelf
+        ? chalk.yellow("Warning: This is your current CLI device!\n")
+        : "";
+    const confirmed = await confirm(`${warning}Are you sure you want to unlink CLI "${cliId}"? (y/N) `);
+    if (!confirmed) {
+        console.log("Cancelled.");
+        return;
+    }
+    const restClient = createRestClient(serverUrl, token, config.defaultOrgId);
+    try {
+        await restClient.unlinkCli({ cliId });
+        console.log(chalk.green(`CLI "${cliId}" unlinked successfully.`));
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to unlink CLI: ${error instanceof Error ? error.message : String(error)}`));
+    }
+}
+//# sourceMappingURL=cli-unlink.js.map

package/dist/commands/config-set.d.ts

@@ -0,0 +1,5 @@
+export declare function configSetAgentTypeAction(value: string): Promise<void>;
+export declare function configSetAgentSlotsAction(value: string): Promise<void>;
+export declare function configSetOpenerAction(value: string): void;
+export declare function configGetAction(): void;
+//# sourceMappingURL=config-set.d.ts.map

package/dist/commands/config-set.js

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import { getConfig, setConfig } from "../config/config-manager.js";
+import { isDaemonRunning } from "../lib/daemon.js";
+import { DaemonNotRunningError, sendIpcCommand } from "../lib/ipc-client.js";
+const VALID_AGENT_TYPES = ["CLAUDE_CODE"];
+const VALID_OPENERS = ["terminal", "vscode", "finder"];
+export async function configSetAgentTypeAction(value) {
+    const upper = value.toUpperCase();
+    if (!VALID_AGENT_TYPES.includes(upper)) {
+        console.error(chalk.red(`Invalid agent type "${value}". Allowed: ${VALID_AGENT_TYPES.join(", ")}`));
+        process.exitCode = 1;
+        return;
+    }
+    setConfig({ agentType: upper });
+    const applied = await tryReRegister();
+    console.log(chalk.green(`Agent type set to ${upper}. ${applied ? "(Applied immediately)" : "(Will apply on next connect)"}`));
+}
+export async function configSetAgentSlotsAction(value) {
+    const num = Number.parseInt(value, 10);
+    if (Number.isNaN(num) || num < 1 || num > 20) {
+        console.error(chalk.red("Invalid agent slots. Must be an integer between 1 and 20."));
+        process.exitCode = 1;
+        return;
+    }
+    setConfig({ agentSlots: num });
+    const applied = await tryReRegister();
+    console.log(chalk.green(`Agent slots set to ${num}. ${applied ? "(Applied immediately)" : "(Will apply on next connect)"}`));
+}
+export function configSetOpenerAction(value) {
+    const lower = value.toLowerCase();
+    if (!VALID_OPENERS.includes(lower)) {
+        console.error(chalk.red(`Invalid opener "${value}". Allowed: ${VALID_OPENERS.join(", ")}`));
+        process.exitCode = 1;
+        return;
+    }
+    setConfig({ opener: lower });
+    console.log(chalk.green(`Opener set to ${lower}.`));
+}
+export function configGetAction() {
+    const config = getConfig();
+    console.log(chalk.dim("Current configuration:"));
+    console.log(`  Agent type:  ${config.agentType ?? "CLAUDE_CODE"}`);
+    console.log(`  Agent slots: ${config.agentSlots ?? 5}`);
+    console.log(`  Opener:      ${config.opener ?? "terminal"}`);
+    console.log(`  Server URL:  ${config.serverUrl}`);
+    console.log(`  CLI ID:      ${config.cliId ?? "(not set)"}`);
+    console.log(`  CLI name:    ${config.cliName ?? "(auto-detected)"}`);
+}
+async function tryReRegister() {
+    const pid = isDaemonRunning();
+    if (!pid)
+        return false;
+    try {
+        const response = await sendIpcCommand({ cmd: "re-register" });
+        return response.ok;
+    }
+    catch (error) {
+        if (error instanceof DaemonNotRunningError)
+            return false;
+        return false;
+    }
+}
+//# sourceMappingURL=config-set.js.map

package/dist/commands/connect.d.ts

@@ -0,0 +1,9 @@
+export { activeConnections } from "../lib/connection-manager.js";
+export type { OrgConnection } from "../lib/connection-manager.js";
+export declare function connectAction(options: {
+    server?: string;
+    org?: string;
+    attach?: boolean;
+    stop?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/commands/connect.js

@@ -0,0 +1,165 @@
+import chalk from "chalk";
+import { isDaemonRunning, spawnDaemon } from "../lib/daemon.js";
+import { sendIpcCommand, DaemonNotRunningError } from "../lib/ipc-client.js";
+import { resolveConnectContext, establishConnections, shutdownConnections, runMcpProbe, } from "../lib/connection-manager.js";
+// Re-export for backward compatibility with existing tests
+export { activeConnections } from "../lib/connection-manager.js";
+export async function connectAction(options) {
+    // --stop: send shutdown command to running daemon
+    if (options.stop) {
+        try {
+            const response = await sendIpcCommand({ cmd: "shutdown" });
+            if (response.ok) {
+                console.log(chalk.green("Daemon shutdown initiated."));
+            }
+            else {
+                console.error(chalk.red(`Shutdown failed: ${response.error}`));
+            }
+        }
+        catch (error) {
+            if (error instanceof DaemonNotRunningError) {
+                console.log(chalk.yellow("No daemon running."));
+            }
+            else {
+                console.error(chalk.red(`Failed to send shutdown: ${error instanceof Error ? error.message : String(error)}`));
+            }
+        }
+        return;
+    }
+    // --attach: foreground mode (original behavior)
+    if (options.attach) {
+        return connectForeground(options);
+    }
+    // Default: daemon mode
+    return connectDaemon(options);
+}
+/**
+ * Handle status response from existing daemon.
+ */
+async function handleExistingDaemonStatus(existingPid, response) {
+    if (!response.ok || !("orgs" in response) || !response.orgs) {
+        console.log(chalk.green(`Daemon running (PID: ${existingPid})`));
+        return;
+    }
+    const config = (await import("../config/config-manager.js")).getConfig();
+    const linkedSlugs = (config.linkedOrgs ?? []).map((o) => o.orgSlug);
+    const connectedSlugs = new Set(response.orgs.map((o) => o.slug));
+    const missingSlugs = linkedSlugs.filter((s) => !connectedSlugs.has(s));
+    if (missingSlugs.length > 0) {
+        await attemptReconnectMissingOrgs(existingPid);
+    }
+    else {
+        printOrgStatus(existingPid, response.orgs);
+    }
+}
+/**
+ * Attempt to reconnect missing orgs and print status.
+ */
+async function attemptReconnectMissingOrgs(existingPid) {
+    const reconnResp = await sendIpcCommand({ cmd: "reconnect" });
+    if (reconnResp.ok && "orgs" in reconnResp && reconnResp.orgs) {
+        printOrgStatus(existingPid, reconnResp.orgs);
+    }
+}
+/**
+ * Print organization connection status.
+ */
+function printOrgStatus(pid, orgs, defaultStatus = "connected") {
+    console.log(chalk.green(`Daemon running (PID: ${pid})`));
+    for (const org of orgs) {
+        let statusText;
+        if (defaultStatus === "connected" || defaultStatus === "disconnected") {
+            statusText = org.connected
+                ? chalk.green("connected")
+                : chalk.yellow("disconnected");
+        }
+        else {
+            statusText = org.connected
+                ? chalk.green("connected")
+                : chalk.yellow(defaultStatus);
+        }
+        console.log(`  ${org.slug}: ${statusText}`);
+    }
+}
+/**
+ * Daemon mode (default): spawn background daemon or query existing one.
+ */
+async function connectDaemon(options) {
+    const existingPid = isDaemonRunning();
+    if (existingPid) {
+        try {
+            const response = await sendIpcCommand({ cmd: "status" });
+            await handleExistingDaemonStatus(existingPid, response);
+        }
+        catch {
+            console.log(chalk.yellow(`Daemon PID ${existingPid} found but IPC unreachable. Try \`forge connect --stop\` then \`forge connect\`.`));
+        }
+        return;
+    }
+    // No daemon running — validate context before spawning
+    const ctx = resolveConnectContext(options);
+    if (!ctx)
+        return;
+    // Spawn daemon
+    const pid = spawnDaemon();
+    console.log(chalk.green(`Daemon started (PID: ${pid})`));
+    // Wait briefly for daemon to initialize, then query status
+    await sleep(1_500);
+    try {
+        const response = await sendIpcCommand({ cmd: "status" });
+        if (response.ok && "orgs" in response && response.orgs) {
+            printOrgStatus(pid, response.orgs, "connecting...");
+        }
+    }
+    catch {
+        console.log(chalk.yellow("Daemon spawned but IPC not ready yet. Check status with `forge connect`."));
+    }
+}
+/**
+ * Foreground / attach mode: original blocking behavior for dev/debug.
+ */
+async function connectForeground(options) {
+    const ctx = resolveConnectContext(options);
+    if (!ctx)
+        return;
+    // Ensure Claude OAuth token is available for container authentication
+    try {
+        const { ensureClaudeToken } = await import("../vm/claude-token-manager.js");
+        await ensureClaudeToken();
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`[connect] Claude token setup failed: ${err instanceof Error ? err.message : String(err)}`));
+        console.warn(chalk.yellow("[connect] Agents may fail to authenticate. Run: forge auth setup-claude"));
+    }
+    // Initialize VM manager (helper process or direct addon)
+    try {
+        const { isVmCapable, initVmManager } = await import("../vm/vm-manager-facade.js");
+        if (isVmCapable()) {
+            await initVmManager();
+            console.log(chalk.green("[connect] VM manager initialized"));
+        }
+        else {
+            console.warn(chalk.yellow("[connect] Native VM addon not available — agent execution disabled"));
+        }
+    }
+    catch (err) {
+        console.warn(chalk.yellow(`[connect] VM init failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    establishConnections(ctx);
+    // Run MCP health probe (non-blocking — heartbeats update when result arrives)
+    void runMcpProbe(ctx);
+    // Keep process alive until SIGINT/SIGTERM
+    await new Promise((resolve) => {
+        const shutdown = async () => {
+            console.log(chalk.cyan("\nDisconnecting..."));
+            await shutdownConnections();
+            resolve();
+        };
+        process.once("SIGINT", () => void shutdown());
+        process.once("SIGTERM", () => void shutdown());
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=connect.js.map