@sjawhar/opencode-legion-envoy 0.1.9 → 0.2.0

package/src/{index.ts → server.ts}

@@ -1,4 +1,8 @@
 import { tool } from "@opencode-ai/plugin/tool";
+import { loadEnvoyConfig } from "./config";
+import { buildDispatchMcpEntry, injectEnvoyMcp } from "./dispatch-mcp";
+import { dispatchSubscriptionTopic } from "./dispatch-subscribe";
+import { logger } from "./log";
 import { resolvePort } from "./port";
 
 const root = process.env.ENVOY_URL ?? "http://127.0.0.1:9020";
@@ -17,8 +21,17 @@ async function call(path: string, init?: RequestInit) {
 }
 
 export default async (input: { serverUrl: URL }) => {
+  const cwd = process.cwd();
+  const config = await loadEnvoyConfig(cwd);
   let activeSessionID: string | null = null;
   let activeSessionTitle: string | null = null;
+  // All sessions that have become busy in this serve instance. The heartbeat
+  // refreshes the envoy_sessions TTL for ALL of them — a single serve hosts many
+  // sessions, so tracking only the most-recently-active one lets idle siblings
+  // expire out of the registry and become undeliverable.
+  const trackedSessions = new Map<string, { title: string | null }>();
+  // Guard so sibling re-adoption (after a serve restart) runs at most once.
+  let readoptDone = false;
   /** Cached port — resolved asynchronously, null until first successful resolution. */
   let resolvedPort: number | null = null;
 
@@ -27,7 +40,7 @@ export default async (input: { serverUrl: URL }) => {
     const port = await resolvePort(input.serverUrl);
     if (!port && !portWarningLogged) {
       portWarningLogged = true;
-      console.error(
+      logger.error(
         `[envoy-plugin] Could not resolve serve port: serverUrl=${input.serverUrl.href}, pid=${process.pid}`
       );
     }
@@ -71,26 +84,70 @@ export default async (input: { serverUrl: URL }) => {
   // Fire an immediate async attempt (non-blocking)
   syncPort().catch(() => {});
 
-  // Heartbeat: re-subscribe every 2 minutes to refresh envoy_sessions TTL (5-min)
-  const heartbeatInterval = setInterval(
-    () => {
-      if (!activeSessionID) return;
-      const port = currentPort();
-      if (!port) return;
-      call("/v1/interests/subscribe", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          session_id: activeSessionID,
-          dir: process.cwd(),
-          topics: [`notifications.agent.${activeSessionID}`],
-          port,
-          title: activeSessionTitle ?? "",
-        }),
-      }).catch(() => {});
-    },
-    2 * 60 * 1000
-  );
+  const subscribeSession = (sessionID: string, title: string | null, port: number) =>
+    call("/v1/interests/subscribe", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        session_id: sessionID,
+        dir: cwd,
+        topics: [`notifications.agent.${sessionID}`],
+        port,
+        title: title ?? "",
+      }),
+    }).catch(() => {});
+
+  // After a serve restart, sessions that were live in the previous serve instance
+  // do NOT re-register on their own (registration is gated on a session going
+  // busy), so an idle session waiting to RECEIVE a message silently falls out of
+  // the registry. Recover them once, on first activity: read the live registry and
+  // re-subscribe siblings that share this serve's machine + dir at the new port.
+  const readoptSiblings = async (selfSessionID: string) => {
+    if (readoptDone) return;
+    const port = currentPort();
+    if (!port) return;
+    try {
+      const res = await call("/v1/sessions");
+      const sessions = JSON.parse(res) as Array<{
+        session_id: string;
+        machine_id: string;
+        dir: string;
+        title?: string;
+      }>;
+      // Authoritative machine id for this serve = the listener-stamped machine of
+      // our own active session. Only adopt siblings that match it (and our dir) to
+      // avoid hijacking a same-path session that lives on another machine.
+      const self = sessions.find((s) => s.session_id === selfSessionID);
+      if (!self) return;
+      readoptDone = true;
+      for (const s of sessions) {
+        if (s.machine_id !== self.machine_id) continue;
+        if (s.dir !== cwd) continue;
+        if (trackedSessions.has(s.session_id)) continue;
+        trackedSessions.set(s.session_id, { title: s.title ?? null });
+        subscribeSession(s.session_id, s.title ?? null, port);
+      }
+    } catch {}
+  };
+
+  // Heartbeat: re-subscribe every tracked session to refresh the envoy_sessions
+  // TTL (5-min). Refreshes ALL sessions that have been busy in this serve, not
+  // just the most recently active one. Interval is env-tunable for tests/tuning.
+  const rawHeartbeatMs = Number(process.env.ENVOY_HEARTBEAT_MS);
+  const heartbeatMs =
+    Number.isFinite(rawHeartbeatMs) && rawHeartbeatMs > 0
+      ? Math.max(rawHeartbeatMs, 25)
+      : 2 * 60 * 1000;
+  const heartbeatInterval = setInterval(() => {
+    const port = currentPort();
+    if (!port) return;
+    for (const [sessionID, info] of trackedSessions) {
+      subscribeSession(sessionID, info.title, port);
+    }
+    // Retry sibling re-adoption until the registry shows our own session.
+    if (!readoptDone && activeSessionID) readoptSiblings(activeSessionID).catch(() => {});
+  }, heartbeatMs);
+  heartbeatInterval.unref?.();
 
   process.on("exit", () => {
     clearInterval(timer);
@@ -98,6 +155,22 @@ export default async (input: { serverUrl: URL }) => {
   });
 
   return {
+    config: (cfg: { mcp?: Record<string, unknown> } & Record<string, unknown>) => {
+      // Inject the envoy MCP entry into the OpenCode config when
+      // dispatch is enabled. Centralizing this in the plugin (instead of
+      // each user's opencode.json) means:
+      //   1. Registration is gated by `dispatch.enabled`
+      //   2. The bearer token is sourced per-CWD via the user's gh shim
+      //      (no env coordination needed)
+      //   3. Token rotation happens transparently inside the shim
+      //      subprocess — OpenCode never sees an expired token
+      const entry = buildDispatchMcpEntry({
+        dispatch: config.dispatch,
+      });
+      if (!entry) return;
+      const { warning } = injectEnvoyMcp(cfg, entry);
+      if (warning) logger.warn(warning);
+    },
     event: async ({
       event,
     }: {
@@ -113,6 +186,9 @@ export default async (input: { serverUrl: URL }) => {
         if (sessionID && sessionID !== activeSessionID) {
           activeSessionID = sessionID;
           activeSessionTitle = null;
+          if (!trackedSessions.has(sessionID)) {
+            trackedSessions.set(sessionID, { title: null });
+          }
           await syncPort();
           const port = currentPort();
           // Fetch title — best-effort, non-blocking for initial subscribe
@@ -122,37 +198,84 @@ export default async (input: { serverUrl: URL }) => {
             return t;
           });
           if (port) {
-            call("/v1/interests/subscribe", {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                session_id: sessionID,
-                dir: process.cwd(),
-                topics: [`notifications.agent.${sessionID}`],
-                port,
-                title: activeSessionTitle ?? "",
-              }),
-            }).catch(() => {});
-            // After title arrives, send one follow-up subscribe with title populated
+            // Await so our own session is persisted in the registry before
+            // readoptSiblings reads it back (otherwise self may be absent and
+            // re-adoption would be skipped).
+            await subscribeSession(sessionID, activeSessionTitle, port);
+            // After the title arrives, send one follow-up subscribe with it.
             titlePromise.then((title) => {
-              if (title && activeSessionID === sessionID) {
-                call("/v1/interests/subscribe", {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({
-                    session_id: sessionID,
-                    dir: process.cwd(),
-                    topics: [`notifications.agent.${sessionID}`],
-                    port: currentPort() ?? 0,
-                    title,
-                  }),
-                }).catch(() => {});
+              if (!title) return;
+              // Update tracked metadata even if this session is no longer the
+              // active one (another session may have become busy meanwhile).
+              if (trackedSessions.has(sessionID)) {
+                trackedSessions.set(sessionID, { title });
+                subscribeSession(sessionID, title, currentPort() ?? 0);
               }
+              if (activeSessionID === sessionID) activeSessionTitle = title;
             });
+            // Recover idle siblings orphaned by a serve restart (retries from the
+            // heartbeat until the registry shows our own session).
+            readoptSiblings(sessionID).catch(() => {});
+          }
+        }
+      }
+
+      if (event.type === "session.deleted") {
+        const props = event.properties ?? {};
+        const deletedID =
+          (props.sessionID as string | undefined) ??
+          (props.info as { id?: string } | undefined)?.id;
+        if (deletedID) {
+          // Stop heartbeating a session that no longer exists, so its 5-min
+          // envoy_sessions entry expires instead of being kept alive (which would
+          // cause delivery attempts to a dead session id on the current port).
+          trackedSessions.delete(deletedID);
+          if (activeSessionID === deletedID) {
+            activeSessionID = null;
+            activeSessionTitle = null;
           }
+          // Best-effort: drop the deleted session's interests so routing stops.
+          call("/v1/interests/unsubscribe", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ session_id: deletedID, topics: [] }),
+          }).catch(() => {});
         }
       }
     },
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string; args: unknown },
+      output: { title: string; output: string; metadata: unknown }
+    ) => {
+      // Dispatch AC#4: when this session opens a Dispatch thread via the
+      // envoy_dispatch MCP tool, auto-subscribe it to the thread's GitHub topic
+      // so the human's reply is delivered back through Envoy. Best-effort — a
+      // subscribe failure must never surface to the model or fail the tool call.
+      const topic = dispatchSubscriptionTopic(input.tool, output.output);
+      if (!topic) return;
+      try {
+        await call("/v1/interests/subscribe", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            session_id: input.sessionID,
+            dir: cwd,
+            topics: [topic],
+            port: currentPort() ?? 0,
+            title: activeSessionTitle ?? "",
+          }),
+        });
+      } catch (err) {
+        logger.warn(
+          `[envoy-plugin] dispatch auto-subscribe failed: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    },
+    // Cleanup hook (used by tests; production relies on process 'exit').
+    dispose: () => {
+      clearInterval(timer);
+      clearInterval(heartbeatInterval);
+    },
     tool: {
       envoy_subscribe: tool({
         description:

package/src/tui-port.ts

@@ -0,0 +1,83 @@
+import { execFileSync } from "node:child_process";
+
+type ExecSyncFn = (command: string, args: string[], options: { encoding: string }) => string;
+
+/**
+ * Parse the port from an OpenCode serve baseUrl.
+ *
+ * Synchronous and URL-only: the TUI plugin runs in-process with the
+ * OpenCode TUI, which always knows the baseUrl of its serve daemon.
+ * This is separate from the server-side `resolvePort` helper, which
+ * additionally consults `ss(8)` by PID — irrelevant in the TUI process.
+ *
+ * Returns null when input is missing, malformed, or has no explicit
+ * numeric port.
+ */
+export function parsePort(baseUrl: string | undefined): number | null {
+  if (!baseUrl) return null;
+  let parsed: URL;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return null;
+  }
+  if (!parsed.port) return null;
+  const port = Number.parseInt(parsed.port, 10);
+  if (!Number.isFinite(port) || port <= 0) return null;
+  return port;
+}
+
+const defaultExecSync: ExecSyncFn = (command, args, options) =>
+  execFileSync(command, args, { encoding: options.encoding as BufferEncoding }) as string;
+
+export function resolveCurrentProcessPort(exec: ExecSyncFn = defaultExecSync): number | null {
+  return resolveProcessPort(process.pid, exec);
+}
+
+function resolveProcessPort(pid: number, exec: ExecSyncFn = defaultExecSync): number | null {
+  try {
+    const output = exec("ss", ["-tlnp"], { encoding: "utf-8" });
+    for (const line of output.split("\n")) {
+      if (!line.includes(`pid=${pid}`)) continue;
+      const parts = line.trim().split(/\s+/);
+      const local = parts[3];
+      const match = local?.match(/:(\d+)$/);
+      if (!match) continue;
+      const port = Number.parseInt(match[1], 10);
+      if (Number.isFinite(port) && port > 0) return port;
+    }
+  } catch {}
+
+  return null;
+}
+
+export function resolveSessionProcessPort(
+  sessionID: string,
+  exec: ExecSyncFn = defaultExecSync
+): number | null {
+  try {
+    const output = exec("ps", ["-eo", "pid=,args="], { encoding: "utf-8" });
+    for (const line of output.split("\n")) {
+      if (!line.includes(sessionID)) continue;
+      if (!/(^|\s)-s\s+/.test(line)) continue;
+      const pid = Number.parseInt(line.trim().split(/\s+/, 1)[0] ?? "", 10);
+      if (!Number.isFinite(pid) || pid <= 0) continue;
+      const port = resolveProcessPort(pid, exec);
+      if (port !== null) return port;
+    }
+  } catch {}
+
+  return null;
+}
+
+export function resolveTuiPort(
+  baseUrl: string | undefined,
+  sessionID?: string,
+  exec: ExecSyncFn = defaultExecSync
+): number | null {
+  return (
+    parsePort(baseUrl) ??
+    (sessionID ? resolveSessionProcessPort(sessionID, exec) : null) ??
+    resolveCurrentProcessPort(exec)
+  );
+}

package/src/tui.tsx

@@ -0,0 +1,122 @@
+/** @jsxImportSource @opentui/solid */
+import type {
+  TuiPlugin,
+  TuiPluginApi,
+  TuiPluginModule,
+  TuiSlotPlugin,
+} from "@opencode-ai/plugin/tui";
+import { createSignal } from "solid-js";
+import { copyToClipboard } from "./clipboard";
+import { resolveTuiPort } from "./tui-port";
+
+function currentSessionID(api: TuiPluginApi): string | undefined {
+  const route = api.route.current;
+  if (route.name !== "session") return undefined;
+  return (route.params as { sessionID?: string } | undefined)?.sessionID;
+}
+
+function copyWithToast(api: TuiPluginApi, text: string, successMessage: string) {
+  if (copyToClipboard(text, api.renderer)) {
+    api.ui.toast({ message: successMessage, variant: "success" });
+  } else {
+    api.ui.toast({ message: `Failed: ${successMessage}`, variant: "error" });
+  }
+}
+
+type ClientWithConfig = TuiPluginApi["client"] & {
+  client: { getConfig(): { baseUrl?: string } };
+};
+
+function baseUrl(api: TuiPluginApi): string | undefined {
+  const url = (api.client as ClientWithConfig).client.getConfig().baseUrl;
+  return url;
+}
+
+function ClickableRow(props: {
+  text: string;
+  onCopy: () => void;
+  mutedColor: TuiPluginApi["theme"]["current"]["textMuted"];
+  textColor: TuiPluginApi["theme"]["current"]["text"];
+}) {
+  const [hover, setHover] = createSignal(false);
+  return (
+    // biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box supports mouse events.
+    // biome-ignore lint/a11y/useKeyWithMouseEvents: This row is mouse-only in the TUI sidebar.
+    <box
+      flexDirection="row"
+      onMouseOver={() => setHover(true)}
+      onMouseOut={() => setHover(false)}
+      onMouseDown={() => props.onCopy()}
+    >
+      <text fg={hover() ? props.textColor : props.mutedColor} wrapMode="none">
+        {props.text}
+      </text>
+    </box>
+  );
+}
+
+function EnvoySidebar(props: { api: TuiPluginApi; sessionID: string }) {
+  const theme = () => props.api.theme.current;
+  const port = resolveTuiPort(baseUrl(props.api), props.sessionID);
+
+  return (
+    <box>
+      <ClickableRow
+        text={props.sessionID}
+        mutedColor={theme().textMuted}
+        textColor={theme().text}
+        onCopy={() => copyWithToast(props.api, props.sessionID, "Session ID copied")}
+      />
+      {port !== null ? (
+        <ClickableRow
+          text={`port ${port}`}
+          mutedColor={theme().textMuted}
+          textColor={theme().text}
+          onCopy={() => copyWithToast(props.api, String(port), "Port copied")}
+        />
+      ) : null}
+    </box>
+  );
+}
+
+const tui: TuiPlugin = async (api) => {
+  // Slash command
+  api.keymap.registerLayer({
+    commands: [
+      {
+        name: "envoy.whoami.copy",
+        title: "Copy session ID",
+        category: "Envoy",
+        namespace: "palette",
+        slashName: "whoami",
+        run() {
+          const sessionID = currentSessionID(api);
+          if (!sessionID) {
+            api.ui.toast({ message: "No active session", variant: "warning" });
+            return;
+          }
+          copyWithToast(api, sessionID, "Session ID copied");
+        },
+      },
+    ],
+  });
+
+  // Sidebar: clickable session ID row
+  const slot: TuiSlotPlugin = {
+    order: 10,
+    slots: {
+      sidebar_content(_ctx, value) {
+        if (!value.session_id) return null;
+        return <EnvoySidebar api={api} sessionID={value.session_id} />;
+      },
+    },
+  };
+  api.slots.register(slot);
+};
+
+const plugin: TuiPluginModule = {
+  id: "envoy-tui",
+  tui,
+};
+
+export default plugin;

package/tsconfig.json

@@ -5,7 +5,9 @@
     "moduleResolution": "Bundler",
     "strict": true,
     "noEmit": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
     "types": ["bun"]
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
 }