@fonz/tgcc 0.6.19 → 0.7.0

package/dist/plugin/src/client.d.ts

@@ -0,0 +1,167 @@
+/**
+ * TgccSupervisorClient — Unix socket client for the TGCC Supervisor Protocol.
+ *
+ * Connects to TGCC's ctl socket, registers as a supervisor, and provides
+ * async methods for interacting with TGCC-managed agents and CC processes.
+ *
+ * Adapted from the OpenClaw fork (src/agents/tgcc-supervisor/client.ts)
+ * to use only the plugin API — no OpenClaw internal imports.
+ */
+import { EventEmitter } from "node:events";
+import type { PluginLogger } from "openclaw/plugin-sdk";
+export interface SupervisorCommand {
+    type: "command";
+    requestId: string;
+    action: string;
+    params?: Record<string, unknown>;
+}
+export interface SupervisorResponse {
+    type: "response";
+    requestId: string;
+    result?: unknown;
+    error?: string;
+}
+export interface SupervisorEvent {
+    type: "event";
+    event: string;
+    [key: string]: unknown;
+}
+export interface TgccAgentStatus {
+    id: string;
+    type: "persistent" | "ephemeral";
+    state: "idle" | "active";
+    sessionId: string | null;
+    repo: string;
+    supervisorSubscribed: boolean;
+}
+export interface TgccStatusResult {
+    agents: TgccAgentStatus[];
+    sessions?: Array<{
+        id: string;
+        agentId: string;
+        messageCount?: number;
+        totalCostUsd?: number;
+    }>;
+}
+export interface TgccResultEvent {
+    agentId: string;
+    sessionId: string;
+    text: string;
+    cost_usd?: number;
+    duration_ms?: number;
+    is_error?: boolean;
+}
+export interface TgccProcessExitEvent {
+    agentId: string;
+    sessionId: string;
+    exitCode: number | null;
+}
+export interface TgccSessionTakeoverEvent {
+    agentId: string;
+    sessionId: string;
+    exitCode: number | null;
+}
+export interface TgccApiErrorEvent {
+    agentId: string;
+    sessionId: string;
+    message: string;
+}
+export interface TgccPermissionRequestEvent {
+    agentId: string;
+    toolName: string;
+    requestId: string;
+    description: string;
+}
+export interface TgccSupervisorClientConfig {
+    socket: string;
+    logger: PluginLogger;
+    reconnectInitialMs?: number;
+    reconnectMaxMs?: number;
+    heartbeatMs?: number;
+}
+export declare class TgccSupervisorClient extends EventEmitter {
+    private log;
+    private socketPath;
+    private socket;
+    private connected;
+    private destroyed;
+    private reconnectDelay;
+    private reconnectInitialMs;
+    private reconnectMaxMs;
+    private heartbeatMs;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private pongTimer;
+    private pendingRequests;
+    private lineBuffer;
+    constructor(config: TgccSupervisorClientConfig);
+    start(): void;
+    stop(): void;
+    isConnected(): boolean;
+    sendMessage(agentId: string, text: string, opts?: {
+        sessionId?: string;
+        subscribe?: boolean;
+    }): Promise<{
+        sessionId: string;
+        state: string;
+        subscribed?: boolean;
+    }>;
+    sendToCC(agentId: string, text: string): Promise<{
+        sent: boolean;
+    }>;
+    getStatus(agentId?: string): Promise<TgccStatusResult>;
+    killCC(agentId: string): Promise<unknown>;
+    subscribe(agentId: string, sessionId?: string): Promise<unknown>;
+    unsubscribe(agentId: string): Promise<unknown>;
+    respondToPermission(agentId: string, permissionRequestId: string, decision: "allow" | "deny"): Promise<unknown>;
+    createAgent(params: {
+        agentId?: string;
+        repo: string;
+        model?: string;
+        permissionMode?: string;
+        timeoutMs?: number;
+    }): Promise<{
+        agentId: string;
+        state: string;
+    }>;
+    destroyAgent(agentId: string): Promise<{
+        destroyed: boolean;
+    }>;
+    getLog(agentId: string, opts?: {
+        offset?: number;
+        limit?: number;
+        grep?: string;
+        since?: number;
+        type?: string;
+    }): Promise<{
+        totalLines: number;
+        returnedLines: number;
+        offset: number;
+        lines: Array<{
+            ts: number;
+            type: string;
+            text: string;
+        }>;
+    }>;
+    private connect;
+    private scheduleReconnect;
+    private register;
+    private startHeartbeat;
+    private sendPing;
+    private forceReconnect;
+    private handleData;
+    private handleMessage;
+    private handleResponse;
+    private handleEvent;
+    private syncStateAfterConnect;
+    private handleReverseCommand;
+    private handleExecCommand;
+    private handleRestartServiceCommand;
+    private handleNotifyCommand;
+    private sendResponse;
+    private sendCommand;
+    private sendRaw;
+    private clearTimers;
+    private clearHeartbeat;
+    private rejectAllPending;
+}

package/dist/plugin/src/client.js

@@ -0,0 +1,523 @@
+"use strict";
+/**
+ * TgccSupervisorClient — Unix socket client for the TGCC Supervisor Protocol.
+ *
+ * Connects to TGCC's ctl socket, registers as a supervisor, and provides
+ * async methods for interacting with TGCC-managed agents and CC processes.
+ *
+ * Adapted from the OpenClaw fork (src/agents/tgcc-supervisor/client.ts)
+ * to use only the plugin API — no OpenClaw internal imports.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TgccSupervisorClient = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const node_net_1 = __importDefault(require("node:net"));
+const node_events_1 = require("node:events");
+const DEFAULT_RECONNECT_INITIAL_MS = 1_000;
+const DEFAULT_RECONNECT_MAX_MS = 30_000;
+const DEFAULT_HEARTBEAT_MS = 30_000;
+const HEARTBEAT_PONG_TIMEOUT_MS = 5_000;
+const COMMAND_TIMEOUT_MS = 30_000;
+// ---------------------------------------------------------------------------
+// Safety patterns for reverse-exec
+// ---------------------------------------------------------------------------
+const EXEC_DENY_PATTERNS = [
+    /rm\s+(-[a-z]*f[a-z]*\s+)?\//i,
+    /\bsudo\b/,
+    /\bmkfs\b/,
+    /\bdd\b.*\bof=\//,
+    /:\(\)\{/,
+    /\bchmod\s+777\s+\//,
+    /\bchown\b.*\//,
+    /\|\s*sh\b/,
+    /\$\(/,
+    /`[^`]*`/,
+];
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+class TgccSupervisorClient extends node_events_1.EventEmitter {
+    log;
+    socketPath;
+    socket = null;
+    connected = false;
+    destroyed = false;
+    reconnectDelay;
+    reconnectInitialMs;
+    reconnectMaxMs;
+    heartbeatMs;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    pongTimer = null;
+    pendingRequests = new Map();
+    lineBuffer = "";
+    constructor(config) {
+        super();
+        this.log = config.logger;
+        this.socketPath = config.socket;
+        this.reconnectInitialMs = config.reconnectInitialMs ?? DEFAULT_RECONNECT_INITIAL_MS;
+        this.reconnectMaxMs = config.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
+        this.heartbeatMs = config.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        this.reconnectDelay = this.reconnectInitialMs;
+    }
+    // ── Public lifecycle ─────────────────────────────────────────────────
+    start() {
+        if (this.destroyed)
+            return;
+        this.connect();
+    }
+    stop() {
+        this.destroyed = true;
+        this.clearTimers();
+        this.rejectAllPending("Client stopped");
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // ── Public API methods ───────────────────────────────────────────────
+    async sendMessage(agentId, text, opts) {
+        return (await this.sendCommand("send_message", {
+            agentId,
+            text,
+            sessionId: opts?.sessionId,
+            subscribe: opts?.subscribe ?? true,
+        }));
+    }
+    async sendToCC(agentId, text) {
+        return (await this.sendCommand("send_to_cc", { agentId, text }));
+    }
+    async getStatus(agentId) {
+        const params = {};
+        if (agentId)
+            params.agentId = agentId;
+        return (await this.sendCommand("status", params));
+    }
+    async killCC(agentId) {
+        return this.sendCommand("kill_cc", { agentId });
+    }
+    async subscribe(agentId, sessionId) {
+        const params = { agentId };
+        if (sessionId)
+            params.sessionId = sessionId;
+        return this.sendCommand("subscribe", params);
+    }
+    async unsubscribe(agentId) {
+        return this.sendCommand("unsubscribe", { agentId });
+    }
+    async respondToPermission(agentId, permissionRequestId, decision) {
+        return this.sendCommand("permission_response", { agentId, permissionRequestId, decision });
+    }
+    async createAgent(params) {
+        return (await this.sendCommand("create_agent", {
+            agentId: params.agentId,
+            repo: params.repo,
+            model: params.model,
+            permissionMode: params.permissionMode,
+            timeoutMs: params.timeoutMs,
+        }));
+    }
+    async destroyAgent(agentId) {
+        return (await this.sendCommand("destroy_agent", { agentId }));
+    }
+    async getLog(agentId, opts) {
+        const params = { agentId };
+        if (opts?.offset != null)
+            params.offset = opts.offset;
+        if (opts?.limit != null)
+            params.limit = opts.limit;
+        if (opts?.grep)
+            params.grep = opts.grep;
+        if (opts?.since != null)
+            params.since = opts.since;
+        if (opts?.type)
+            params.type = opts.type;
+        return (await this.sendCommand("get_log", params));
+    }
+    // ── Connection management ────────────────────────────────────────────
+    connect() {
+        if (this.destroyed)
+            return;
+        this.log.info(`[tgcc] connecting to ctl socket: ${this.socketPath}`);
+        const sock = node_net_1.default.createConnection({ path: this.socketPath });
+        this.socket = sock;
+        sock.on("connect", () => {
+            this.log.info("[tgcc] connected to ctl socket");
+            this.connected = true;
+            this.reconnectDelay = this.reconnectInitialMs;
+            this.lineBuffer = "";
+            this.register();
+            this.startHeartbeat();
+            this.emit("connected");
+        });
+        sock.on("data", (data) => {
+            this.handleData(data);
+        });
+        sock.on("error", (err) => {
+            this.log.warn(`[tgcc] socket error: ${err.message}`);
+        });
+        sock.on("close", () => {
+            const wasConnected = this.connected;
+            this.connected = false;
+            this.clearTimers();
+            this.socket = null;
+            if (wasConnected) {
+                this.log.info("[tgcc] socket closed, scheduling reconnect");
+                this.emit("disconnected");
+            }
+            else {
+                this.emit("connectFailed");
+            }
+            this.scheduleReconnect();
+        });
+    }
+    scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        if (this.reconnectTimer)
+            return;
+        const delay = this.reconnectDelay;
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.reconnectMaxMs);
+        this.log.info(`[tgcc] reconnecting in ${delay}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+        this.reconnectTimer.unref?.();
+    }
+    register() {
+        this.sendRaw({
+            type: "register_supervisor",
+            agentId: "openclaw",
+            capabilities: ["exec", "notify"],
+        });
+    }
+    // ── Heartbeat ────────────────────────────────────────────────────────
+    startHeartbeat() {
+        this.clearHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            this.sendPing();
+        }, this.heartbeatMs);
+        this.heartbeatTimer.unref?.();
+    }
+    sendPing() {
+        if (!this.connected)
+            return;
+        const requestId = node_crypto_1.default.randomUUID();
+        this.sendRaw({
+            type: "command",
+            requestId,
+            action: "ping",
+        });
+        this.pongTimer = setTimeout(() => {
+            this.log.warn("[tgcc] pong timeout, forcing reconnect");
+            this.forceReconnect();
+        }, HEARTBEAT_PONG_TIMEOUT_MS);
+        this.pongTimer.unref?.();
+        this.pendingRequests.set(requestId, {
+            resolve: () => {
+                if (this.pongTimer) {
+                    clearTimeout(this.pongTimer);
+                    this.pongTimer = null;
+                }
+            },
+            reject: () => { },
+            timer: setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+            }, HEARTBEAT_PONG_TIMEOUT_MS + 1_000),
+        });
+        this.pendingRequests.get(requestId).timer.unref?.();
+    }
+    forceReconnect() {
+        this.rejectAllPending("Connection lost");
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
+        this.connected = false;
+        this.clearTimers();
+        this.scheduleReconnect();
+    }
+    // ── Data parsing ─────────────────────────────────────────────────────
+    handleData(data) {
+        this.lineBuffer += data.toString("utf-8");
+        const lines = this.lineBuffer.split("\n");
+        this.lineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                this.handleMessage(msg);
+            }
+            catch {
+                this.log.warn(`[tgcc] failed to parse message: ${trimmed.slice(0, 200)}`);
+            }
+        }
+    }
+    handleMessage(msg) {
+        if (msg.type === "response") {
+            this.handleResponse(msg);
+        }
+        else if (msg.type === "event") {
+            this.handleEvent(msg);
+        }
+        else if (msg.type === "command") {
+            void this.handleReverseCommand(msg);
+        }
+    }
+    handleResponse(msg) {
+        const pending = this.pendingRequests.get(msg.requestId);
+        if (!pending)
+            return;
+        this.pendingRequests.delete(msg.requestId);
+        clearTimeout(pending.timer);
+        if (msg.error) {
+            pending.reject(new Error(msg.error));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+    }
+    handleEvent(msg) {
+        const eventName = msg.event;
+        this.log.info(`[tgcc] event: ${String(eventName)} agentId=${String(msg.agentId ?? "?")}`);
+        switch (eventName) {
+            case "result":
+                this.emit("tgcc:result", {
+                    agentId: msg.agentId,
+                    sessionId: msg.sessionId,
+                    text: msg.text,
+                    cost_usd: msg.cost_usd,
+                    duration_ms: msg.duration_ms,
+                    is_error: msg.is_error,
+                });
+                break;
+            case "process_exit":
+                this.emit("tgcc:process_exit", {
+                    agentId: msg.agentId,
+                    sessionId: msg.sessionId,
+                    exitCode: msg.exitCode ?? null,
+                });
+                break;
+            case "session_takeover":
+                this.emit("tgcc:session_takeover", {
+                    agentId: msg.agentId,
+                    sessionId: msg.sessionId,
+                    exitCode: msg.exitCode ?? null,
+                });
+                break;
+            case "api_error":
+                this.emit("tgcc:api_error", {
+                    agentId: msg.agentId,
+                    sessionId: msg.sessionId,
+                    message: msg.message,
+                });
+                break;
+            case "permission_request":
+                this.emit("tgcc:permission_request", {
+                    agentId: msg.agentId,
+                    toolName: msg.toolName,
+                    requestId: msg.requestId,
+                    description: msg.description,
+                });
+                break;
+            case "registered":
+                this.log.info("[tgcc] supervisor registered");
+                this.emit("registered");
+                void this.syncStateAfterConnect();
+                break;
+            case "bridge_started":
+            case "cc_spawned":
+            case "agent_created":
+            case "agent_destroyed":
+            case "state_changed":
+            case "build_result":
+            case "git_commit":
+            case "context_pressure":
+            case "failure_loop":
+            case "stuck":
+            case "task_milestone":
+            case "cc_message":
+            case "subagent_spawn":
+            case "budget_alert":
+                this.emit(`tgcc:${eventName}`, msg);
+                break;
+            default:
+                this.emit(`tgcc:${eventName}`, msg);
+                break;
+        }
+    }
+    async syncStateAfterConnect() {
+        try {
+            const status = await this.getStatus();
+            this.emit("tgcc:status_sync", status);
+        }
+        catch (err) {
+            this.log.warn(`[tgcc] failed to sync state after connect: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── Reverse command handling (TGCC → OpenClaw) ───────────────────────
+    async handleReverseCommand(msg) {
+        const { requestId, action, params } = msg;
+        this.log.info(`[tgcc] reverse command: ${action} (requestId=${requestId})`);
+        try {
+            switch (action) {
+                case "exec":
+                    await this.handleExecCommand(requestId, params ?? {});
+                    break;
+                case "restart_service":
+                    await this.handleRestartServiceCommand(requestId, params ?? {});
+                    break;
+                case "notify":
+                    this.handleNotifyCommand(requestId, params ?? {});
+                    break;
+                default:
+                    this.sendResponse(requestId, undefined, `Unknown reverse command: ${action}`);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.log.warn(`[tgcc] reverse command ${action} failed: ${errMsg}`);
+            this.sendResponse(requestId, undefined, errMsg);
+        }
+    }
+    async handleExecCommand(requestId, params) {
+        const command = typeof params.command === "string" ? params.command : "";
+        const agentId = typeof params.agentId === "string" ? params.agentId : "unknown";
+        const timeoutMs = typeof params.timeoutMs === "number" ? params.timeoutMs : 60_000;
+        if (!command.trim()) {
+            this.sendResponse(requestId, undefined, "Empty command");
+            return;
+        }
+        for (const pattern of EXEC_DENY_PATTERNS) {
+            if (pattern.test(command)) {
+                this.log.warn(`[tgcc] reverse exec DENIED (agent=${agentId}): ${command}`);
+                this.sendResponse(requestId, undefined, `Command denied by safety gate: ${command.slice(0, 100)}`);
+                return;
+            }
+        }
+        this.log.info(`[tgcc] reverse exec (agent=${agentId}): ${command.slice(0, 200)}`);
+        return new Promise((resolve) => {
+            (0, node_child_process_1.exec)(command, {
+                timeout: timeoutMs,
+                maxBuffer: 1024 * 1024,
+                cwd: typeof params.cwd === "string" ? params.cwd : undefined,
+            }, (err, stdout, stderr) => {
+                const exitCode = err && "code" in err ? (err.code ?? 1) : err ? 1 : 0;
+                this.sendResponse(requestId, {
+                    exitCode,
+                    stdout: stdout.slice(0, 50_000),
+                    stderr: stderr.slice(0, 50_000),
+                });
+                resolve();
+            });
+        });
+    }
+    async handleRestartServiceCommand(requestId, params) {
+        const service = typeof params.service === "string" ? params.service : "";
+        const agentId = typeof params.agentId === "string" ? params.agentId : "unknown";
+        this.log.info(`[tgcc] reverse restart_service (agent=${agentId}, service=${service})`);
+        if (service === "tgcc") {
+            return new Promise((resolve) => {
+                (0, node_child_process_1.exec)(`tmux send-keys -t tgcc C-c '' Enter; sleep 1; tmux send-keys -t tgcc 'cd ~/Botverse/tgcc && node dist/cli.js run' Enter`, { timeout: 15_000 }, (err) => {
+                    if (err) {
+                        this.sendResponse(requestId, undefined, `Failed to restart tgcc: ${err.message}`);
+                    }
+                    else {
+                        this.sendResponse(requestId, { restarted: true, service });
+                    }
+                    resolve();
+                });
+            });
+        }
+        this.sendResponse(requestId, undefined, `Unknown service: ${service}`);
+    }
+    handleNotifyCommand(requestId, params) {
+        const message = typeof params.message === "string" ? params.message : "";
+        const target = typeof params.target === "string" ? params.target : "";
+        if (!message.trim()) {
+            this.sendResponse(requestId, undefined, "Empty notification message");
+            return;
+        }
+        this.emit("tgcc:reverse_notify", { target, message });
+        this.sendResponse(requestId, { notified: true });
+    }
+    sendResponse(requestId, result, error) {
+        this.sendRaw({
+            type: "response",
+            requestId,
+            ...(error ? { error } : { result }),
+        });
+    }
+    // ── Command sending ──────────────────────────────────────────────────
+    sendCommand(action, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected || !this.socket) {
+                reject(new Error("Not connected to TGCC"));
+                return;
+            }
+            const requestId = node_crypto_1.default.randomUUID();
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(requestId);
+                reject(new Error(`TGCC command timeout: ${action}`));
+            }, COMMAND_TIMEOUT_MS);
+            timer.unref?.();
+            this.pendingRequests.set(requestId, { resolve, reject, timer });
+            this.sendRaw({
+                type: "command",
+                requestId,
+                action,
+                params,
+            });
+        });
+    }
+    sendRaw(msg) {
+        if (!this.socket || this.socket.destroyed)
+            return;
+        try {
+            this.socket.write(JSON.stringify(msg) + "\n");
+        }
+        catch (err) {
+            this.log.warn(`[tgcc] failed to send: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── Timer management ─────────────────────────────────────────────────
+    clearTimers() {
+        this.clearHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    clearHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.pongTimer) {
+            clearTimeout(this.pongTimer);
+            this.pongTimer = null;
+        }
+    }
+    rejectAllPending(reason) {
+        for (const [, pending] of this.pendingRequests) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(reason));
+        }
+        this.pendingRequests.clear();
+    }
+}
+exports.TgccSupervisorClient = TgccSupervisorClient;
+//# sourceMappingURL=client.js.map