@termfleet/lucarne 0.1.0 → 0.2.0

package/dist/index.js

@@ -9,6 +9,8 @@
 //   • /sessions/:id/view*          → reverse-proxied to lucarne's porthole
 //                                    (so the console can proxy it over the tunnel)
 import http from "node:http";
+import net from "node:net";
+import { Server as IOServer } from "socket.io";
 const LUCARNE_URL = process.env.LUCARNE_URL ?? "http://127.0.0.1:7800";
 const LUCARNE_TOKEN = process.env.LUCARNE_TOKEN;
 const CONSOLE_URL = process.env.TERMFLEET_CONSOLE_URL ?? "http://127.0.0.1:7373";
@@ -19,6 +21,12 @@ const PROVIDER_KEY = encodeURIComponent(PUBLIC_URL);
 const windowIds = new Map();
 let nextWindowId = 1;
 let revision = 0;
+function sessionIdForWindow(wid) {
+    for (const [sid, id] of windowIds)
+        if (id === wid)
+            return sid;
+    return undefined;
+}
 async function lucarne(path) {
     const headers = {};
     if (LUCARNE_TOKEN)
@@ -67,12 +75,18 @@ async function snapshot() {
     return {
         epoch: "lucarne-bridge",
         instanceId: "lucarne-bridge",
-        provider: "lucarne",
+        // termfleet's snapshot `provider` is a CLOSED enum (iterm|virtual-tmux|wezterm)
+        // validated by @termfleet/core — an unknown value is rejected ("unsupported
+        // provider") and the provider shows offline. There's no "browser"/"external"
+        // kind yet, so we present a valid one; the board still shows the "lucarne"
+        // label (from registration) and renders our iframe windows regardless of kind.
+        provider: "virtual-tmux",
         revision: ++revision,
         observedAt: new Date().toISOString(),
         displayBounds: { left: 0, top: 0, right: 1920, bottom: 1080, width: 1920, height: 1080 },
         windows,
-        lifecycle: { pid: process.pid, panes: [] },
+        // @termfleet/core parseProviderSnapshot requires lifecycle with BOTH arrays
+        lifecycle: { panes: [], sessions: [] },
     };
 }
 // reverse-proxy /sessions/:id/view* → lucarne (inject the lucarne token here)
@@ -122,6 +136,62 @@ const server = http.createServer(async (req, res) => {
         res.end(JSON.stringify({ error: String(e.message ?? e) }));
     }
 });
+// termfleet provider control channel. The frontend marks a provider "connected"
+// only once its socket.io connection (path /control/socket.io) is up AND it has
+// received a `provider:snapshot` with displayBounds — without this the provider
+// shows offline / 0 windows. (Protocol owned by termfleet; see @termfleet/core.)
+const io = new IOServer(server, {
+    path: "/control/socket.io",
+    transports: ["websocket"],
+    cors: { origin: true }, // access control is the console proxy's job
+});
+io.on("connection", (socket) => {
+    void snapshot().then((s) => socket.emit("provider:snapshot", s)).catch(() => { });
+    // closing a window destroys the underlying lucarne session
+    socket.on("window:close", async (p, ack) => {
+        const sid = typeof p?.id === "number" ? sessionIdForWindow(p.id) : undefined;
+        if (sid) {
+            const headers = {};
+            if (LUCARNE_TOKEN)
+                headers["authorization"] = `Bearer ${LUCARNE_TOKEN}`;
+            await fetch(`${LUCARNE_URL}/sessions/${sid}`, { method: "DELETE", headers }).catch(() => { });
+        }
+        ack?.({ ok: true });
+    });
+    // read-only for the rest: acknowledge so the UI never hangs on a command
+    for (const ev of ["window:create", "window:move", "display:resize", "terminal:input",
+        "agent:create", "agent-session:input", "agent-session:close",
+        "agent-session:subscribe", "agent-session:unsubscribe", "terminal:effect"]) {
+        socket.on(ev, (_p, ack) => ack?.({ ok: true }));
+    }
+});
+// push live snapshots so new/closed sessions appear on the board
+setInterval(() => { void snapshot().then((s) => io.emit("provider:snapshot", s)).catch(() => { }); }, 3000);
+// Proxy the porthole WebSocket (/sessions/:id/view/ws) through to lucarne, raw.
+// socket.io owns /control/socket.io; we only act on the porthole ws path.
+server.on("upgrade", (req, socket, head) => {
+    const pathname = new URL(req.url ?? "/", "http://x").pathname;
+    if (!/^\/sessions\/.+\/view\/ws$/.test(pathname))
+        return; // leave /control/socket.io to socket.io
+    const target = new URL(LUCARNE_URL);
+    const qs = LUCARNE_TOKEN ? `?token=${encodeURIComponent(LUCARNE_TOKEN)}` : "";
+    const upstream = net.connect(Number(target.port || 80), target.hostname, () => {
+        const lines = [`GET ${pathname}${qs} HTTP/1.1`];
+        for (const [k, v] of Object.entries(req.headers)) {
+            if (k.toLowerCase() === "host")
+                continue;
+            lines.push(`${k}: ${Array.isArray(v) ? v.join(", ") : v}`);
+        }
+        lines.push(`host: ${target.host}`, "", "");
+        upstream.write(lines.join("\r\n"));
+        if (head?.length)
+            upstream.write(head);
+        socket.pipe(upstream);
+        upstream.pipe(socket);
+    });
+    upstream.on("error", () => socket.destroy());
+    socket.on("error", () => upstream.destroy());
+});
 async function registerWithConsole() {
     for (let i = 0; i < 5; i++) {
         try {

package/package.json

@@ -1,26 +1,39 @@
 {
   "name": "@termfleet/lucarne",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Optional bridge that surfaces a lucarne browser-session engine inside a termfleet console as iframe-porthole windows. termfleet and lucarne stay independent; this is the only module that knows both.",
   "type": "module",
   "license": "MIT",
   "author": "Aaron Volter",
-  "engines": { "node": ">=22" },
-  "bin": { "termfleet-lucarne": "dist/index.js" },
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "termfleet-lucarne": "dist/index.js"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist", "README.md"],
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"
   },
+  "dependencies": {
+    "socket.io": "^4.8.0"
+  },
   "peerDependencies": {
     "lucarne": ">=0.3.0"
   },
   "peerDependenciesMeta": {
-    "lucarne": { "optional": true }
+    "lucarne": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@termfleet/core": "^0.1.0",
     "@types/node": "^22.10.0",
     "typescript": "^5.7.0"
   }