tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/command-center/ws-events.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Unified push channel for clients — single WebSocket carrying session,
+ * workspace, project-registry, terminal, and config change signals.
+ *
+ * Endpoint: `/ws/events` (mounted by the daemon's HTTP server).
+ *
+ * Wire protocol: see `src/schemas/ws-events.ts`.
+ *
+ * The orchestrator/task/chat event feed moved out of tmux-ide (agent
+ * coordination now lives in sfora.ai), so this channel only carries
+ * session-control signals.
+ */
+import type { RawData, WebSocket } from "ws";
+interface WsLike {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    on(event: "message", listener: (data: RawData | string, isBinary: boolean) => void): this;
+    on(event: "close", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    off?(event: string, listener: (...args: unknown[]) => void): this;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): this;
+}
+/**
+ * Push an `init.output` chunk to every connected client. Called by the
+ * REST handler that runs `tmux-ide init`; clients filter by `jobId`.
+ */
+export declare function broadcastInitOutput(jobId: string, chunk: string, done?: boolean): void;
+/**
+ * Push an `init.error` frame to every connected client.
+ */
+export declare function broadcastInitError(jobId: string, message: string): void;
+/**
+ * Push an `action.complete` frame to every connected client. Called by the
+ * v2 action dispatcher after a handler succeeds — clients use it to
+ * invalidate caches without polling.
+ */
+export declare function broadcastActionComplete(name: string, result: unknown): void;
+export declare function broadcastConfigChanged(sessionName: string): void;
+export declare function broadcastTerminalsChanged(sessionName: string): void;
+/**
+ * Build the snapshot payload pushed to a client when they subscribe to a
+ * session — the live project + pane state.
+ */
+export declare function buildSessionSnapshot(sessionName: string): unknown | null;
+/**
+ * Wire a single WebSocket connection. Tracks per-session subscriptions and
+ * tears all listeners down on close — no leaks.
+ */
+export declare function handleWsEventsConnection(socket: WebSocket | WsLike): void;
+/**
+ * Test-only hook to shut down the global sessions poller.
+ */
+export declare function _stopSessionsPollerForTests(): void;
+/**
+ * Test-only hook to detach the registry listener.
+ */
+export declare function _detachProjectRegistryListenerForTests(): void;
+export {};

package/packages/daemon/dist/command-center/ws-events.js

@@ -0,0 +1,277 @@
+/**
+ * Unified push channel for clients — single WebSocket carrying session,
+ * workspace, project-registry, terminal, and config change signals.
+ *
+ * Endpoint: `/ws/events` (mounted by the daemon's HTTP server).
+ *
+ * Wire protocol: see `src/schemas/ws-events.ts`.
+ *
+ * The orchestrator/task/chat event feed moved out of tmux-ide (agent
+ * coordination now lives in sfora.ai), so this channel only carries
+ * session-control signals.
+ */
+import { discoverSessions, buildOverviews, buildProjectDetail } from "./discovery.js";
+import { projectRegistryEmitter } from "../lib/project-registry.js";
+import { getDefaultWorkspaceRegistry } from "../lib/workspace-registry.js";
+const WS_OPEN = 1;
+const KEEPALIVE_INTERVAL_MS = 25_000;
+const SESSIONS_POLL_MS = 2_000;
+const allClients = new Set();
+let sessionsPollTimer = null;
+let lastSessionsHash = "";
+let projectRegistryListener = null;
+function snapshotSessionsHash() {
+    try {
+        return JSON.stringify(discoverSessions()
+            .map((s) => s.name)
+            .sort());
+    }
+    catch {
+        return "";
+    }
+}
+function ensureSessionsPoller() {
+    if (sessionsPollTimer)
+        return;
+    lastSessionsHash = snapshotSessionsHash();
+    sessionsPollTimer = setInterval(() => {
+        const hash = snapshotSessionsHash();
+        if (hash === lastSessionsHash)
+            return;
+        lastSessionsHash = hash;
+        for (const client of allClients)
+            client.broadcastSessionsChanged();
+    }, SESSIONS_POLL_MS);
+    sessionsPollTimer.unref?.();
+}
+function maybeStopSessionsPoller() {
+    if (allClients.size > 0 || !sessionsPollTimer)
+        return;
+    clearInterval(sessionsPollTimer);
+    sessionsPollTimer = null;
+}
+/**
+ * Subscribe (lazily) to the project-registry emitter and fan changes out to
+ * every connected ws client. The listener is registered on the first client
+ * and removed when the last one disconnects so we never leak.
+ */
+function ensureProjectRegistryListener() {
+    if (projectRegistryListener)
+        return;
+    const listener = () => {
+        for (const client of allClients)
+            client.broadcastProjectsChanged();
+    };
+    projectRegistryListener = listener;
+    projectRegistryEmitter.on("change", listener);
+}
+function maybeStopProjectRegistryListener() {
+    if (allClients.size > 0 || !projectRegistryListener)
+        return;
+    projectRegistryEmitter.off("change", projectRegistryListener);
+    projectRegistryListener = null;
+}
+/**
+ * Push an `init.output` chunk to every connected client. Called by the
+ * REST handler that runs `tmux-ide init`; clients filter by `jobId`.
+ */
+export function broadcastInitOutput(jobId, chunk, done) {
+    for (const client of allClients)
+        client.broadcastInitOutput(jobId, chunk, done);
+}
+/**
+ * Push an `init.error` frame to every connected client.
+ */
+export function broadcastInitError(jobId, message) {
+    for (const client of allClients)
+        client.broadcastInitError(jobId, message);
+}
+/**
+ * Push an `action.complete` frame to every connected client. Called by the
+ * v2 action dispatcher after a handler succeeds — clients use it to
+ * invalidate caches without polling.
+ */
+export function broadcastActionComplete(name, result) {
+    for (const client of allClients)
+        client.broadcastActionComplete(name, result);
+}
+export function broadcastConfigChanged(sessionName) {
+    for (const client of allClients)
+        client.broadcastConfigChanged(sessionName);
+}
+export function broadcastTerminalsChanged(sessionName) {
+    for (const client of allClients)
+        client.broadcastTerminalsChanged(sessionName);
+}
+function rawDataToText(data) {
+    if (typeof data === "string")
+        return data;
+    if (Buffer.isBuffer(data))
+        return data.toString("utf8");
+    if (data instanceof ArrayBuffer)
+        return Buffer.from(data).toString("utf8");
+    if (Array.isArray(data))
+        return Buffer.concat(data).toString("utf8");
+    return Buffer.from(data).toString("utf8");
+}
+/**
+ * Build the snapshot payload pushed to a client when they subscribe to a
+ * session — the live project + pane state.
+ */
+export function buildSessionSnapshot(sessionName) {
+    const session = discoverSessions().find((s) => s.name === sessionName);
+    if (!session)
+        return null;
+    return { project: buildProjectDetail(session) };
+}
+/**
+ * Wire a single WebSocket connection. Tracks per-session subscriptions and
+ * tears all listeners down on close — no leaks.
+ */
+export function handleWsEventsConnection(socket) {
+    const ws = socket;
+    const subscriptions = new Set();
+    let closed = false;
+    const send = (frame) => {
+        if (closed || ws.readyState !== WS_OPEN)
+            return;
+        try {
+            ws.send(JSON.stringify(frame));
+        }
+        catch {
+            // peer went away mid-send; close path will clean up
+        }
+    };
+    const broadcastSessionsChanged = () => {
+        send({ type: "sessions.changed" });
+    };
+    const broadcastProjectsChanged = () => {
+        send({ type: "projects.changed" });
+    };
+    const broadcastInitOutputForClient = (jobId, chunk, done) => {
+        const frame = done === undefined
+            ? { type: "init.output", jobId, chunk }
+            : { type: "init.output", jobId, chunk, done };
+        send(frame);
+    };
+    const broadcastInitErrorForClient = (jobId, message) => {
+        send({ type: "init.error", jobId, message });
+    };
+    const broadcastActionCompleteForClient = (name, result) => {
+        send({ type: "action.complete", name, result });
+    };
+    const broadcastConfigChangedForClient = (sessionName) => {
+        send({ type: "config.changed", sessionName });
+    };
+    const broadcastTerminalsChangedForClient = (sessionName) => {
+        send({ type: "terminals.changed", sessionName });
+    };
+    // Per-connection subscription to the current workspace-registry singleton.
+    const workspaceRegistry = getDefaultWorkspaceRegistry();
+    const unsubWorkspaceAdded = workspaceRegistry.on("workspace.added", (workspace) => send({ type: "workspace.added", workspace: workspace }));
+    const unsubWorkspaceRemoved = workspaceRegistry.on("workspace.removed", (name) => send({ type: "workspace.removed", name: name }));
+    const clientHandle = {
+        broadcastSessionsChanged,
+        broadcastProjectsChanged,
+        broadcastInitOutput: broadcastInitOutputForClient,
+        broadcastInitError: broadcastInitErrorForClient,
+        broadcastActionComplete: broadcastActionCompleteForClient,
+        broadcastConfigChanged: broadcastConfigChangedForClient,
+        broadcastTerminalsChanged: broadcastTerminalsChangedForClient,
+    };
+    allClients.add(clientHandle);
+    ensureSessionsPoller();
+    ensureProjectRegistryListener();
+    // Server-initiated keepalive — mirrors the SSE behavior so middle-boxes
+    // don't reap the connection.
+    const keepalive = setInterval(() => {
+        send({ type: "pong" });
+    }, KEEPALIVE_INTERVAL_MS);
+    keepalive.unref?.();
+    const subscribe = (sessionName) => {
+        if (subscriptions.has(sessionName))
+            return;
+        const session = discoverSessions().find((s) => s.name === sessionName);
+        subscriptions.add(sessionName);
+        if (session) {
+            const data = buildSessionSnapshot(sessionName);
+            if (data) {
+                send({ type: "snapshot", sessionName, data: data });
+            }
+        }
+    };
+    const unsubscribe = (sessionName) => {
+        subscriptions.delete(sessionName);
+    };
+    const cleanup = () => {
+        if (closed)
+            return;
+        closed = true;
+        clearInterval(keepalive);
+        allClients.delete(clientHandle);
+        subscriptions.clear();
+        unsubWorkspaceAdded();
+        unsubWorkspaceRemoved();
+        maybeStopSessionsPoller();
+        maybeStopProjectRegistryListener();
+    };
+    ws.on("message", (data) => {
+        if (closed)
+            return;
+        let parsed = null;
+        try {
+            const obj = JSON.parse(rawDataToText(data));
+            if (obj && typeof obj === "object" && typeof obj.type === "string") {
+                parsed = obj;
+            }
+        }
+        catch {
+            return; // ignore non-JSON / malformed frames
+        }
+        if (!parsed)
+            return;
+        if (parsed.type === "subscribe") {
+            for (const name of parsed.sessions)
+                subscribe(name);
+            return;
+        }
+        if (parsed.type === "unsubscribe") {
+            for (const name of parsed.sessions)
+                unsubscribe(name);
+            return;
+        }
+        if (parsed.type === "ping") {
+            send({ type: "pong" });
+            return;
+        }
+    });
+    ws.on("close", cleanup);
+    ws.on("error", cleanup);
+    // Send the initial hello — caller knows which sessions exist without
+    // a separate REST round-trip.
+    try {
+        const sessions = discoverSessions();
+        send({ type: "hello", sessions: buildOverviews(sessions) });
+    }
+    catch {
+        send({ type: "hello", sessions: [] });
+    }
+}
+/**
+ * Test-only hook to shut down the global sessions poller.
+ */
+export function _stopSessionsPollerForTests() {
+    if (!sessionsPollTimer)
+        return;
+    clearInterval(sessionsPollTimer);
+    sessionsPollTimer = null;
+}
+/**
+ * Test-only hook to detach the registry listener.
+ */
+export function _detachProjectRegistryListenerForTests() {
+    if (!projectRegistryListener)
+        return;
+    projectRegistryEmitter.off("change", projectRegistryListener);
+    projectRegistryListener = null;
+}

package/packages/daemon/dist/config.d.ts

@@ -0,0 +1,19 @@
+import type { IdeConfig, Pane } from "./types.ts";
+export declare function mutateConfig<T>(dir: string, mutator: (cfg: IdeConfig) => T): {
+    config: IdeConfig;
+    result: T;
+};
+export declare function configSetValue(dir: string, path: string, value: unknown): IdeConfig;
+export declare function configAddPane(dir: string, rowIndex: number, pane: Partial<Pane>): IdeConfig;
+export declare function configRemovePane(dir: string, rowIndex: number, paneIndex: number): {
+    config: IdeConfig;
+    removed: Pane;
+};
+export declare function configAddRow(dir: string, size?: string): IdeConfig;
+export declare function configEnableTeam(dir: string, name?: string): IdeConfig;
+export declare function configDisableTeam(dir: string): IdeConfig;
+export declare function config(targetDir: string | null, { json, action, args }?: {
+    json?: boolean;
+    action?: string;
+    args?: string[];
+}): Promise<void>;