@wingman-ai/gateway 0.3.2 → 0.4.1

package/dist/gateway/http/nodes.js

@@ -0,0 +1,210 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const CLIENT_ID_PATTERN = /^[a-zA-Z0-9._:-]{1,128}$/;
+const normalizeClientId = (raw)=>{
+    let decoded;
+    try {
+        decoded = decodeURIComponent(raw);
+    } catch  {
+        return null;
+    }
+    const trimmed = decoded.trim();
+    if (!trimmed) return null;
+    if (!CLIENT_ID_PATTERN.test(trimmed)) return null;
+    return trimmed;
+};
+const createNodeApprovalStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        return join(configDir, "nodes.json");
+    };
+    const readRecords = ()=>{
+        const path = resolvePath();
+        if (!existsSync(path)) return [];
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) return [];
+            const records = [];
+            for (const entry of parsed){
+                if (!entry || "object" != typeof entry) continue;
+                const typed = entry;
+                const clientId = "string" == typeof typed.clientId ? typed.clientId : "";
+                if (clientId.trim()) records.push({
+                    clientId: clientId.trim(),
+                    name: "string" == typeof typed.name && typed.name.trim() ? typed.name.trim() : void 0,
+                    enabled: false !== typed.enabled,
+                    createdAt: "number" == typeof typed.createdAt ? typed.createdAt : Date.now(),
+                    updatedAt: "number" == typeof typed.updatedAt ? typed.updatedAt : Date.now(),
+                    lastSeenAt: "number" == typeof typed.lastSeenAt ? typed.lastSeenAt : void 0
+                });
+            }
+            return records;
+        } catch  {
+            return [];
+        }
+    };
+    const writeRecords = (records)=>{
+        const path = resolvePath();
+        writeFileSync(path, JSON.stringify(records, null, 2));
+    };
+    const replaceRecord = (records, nextRecord)=>{
+        const index = records.findIndex((record)=>record.clientId === nextRecord.clientId);
+        if (index >= 0) records[index] = nextRecord;
+        else records.unshift(nextRecord);
+        return records;
+    };
+    return {
+        load: ()=>readRecords(),
+        save: (records)=>writeRecords(records),
+        isEnabled: (clientId)=>{
+            const trimmed = clientId.trim();
+            if (!trimmed) return false;
+            return readRecords().some((record)=>record.clientId === trimmed && record.enabled);
+        },
+        setEnabled: (clientId, enabled, name, lastSeenAt)=>{
+            const trimmed = clientId.trim();
+            const now = Date.now();
+            const records = readRecords();
+            const existing = records.find((record)=>record.clientId === trimmed);
+            const nextRecord = {
+                clientId: trimmed,
+                name: "string" == typeof name && name.trim() ? name.trim() : existing?.name,
+                enabled,
+                createdAt: existing?.createdAt ?? now,
+                updatedAt: now,
+                lastSeenAt: "number" == typeof lastSeenAt ? lastSeenAt : existing?.lastSeenAt
+            };
+            writeRecords(replaceRecord(records, nextRecord));
+            return nextRecord;
+        },
+        markSeen: (clientId, name)=>{
+            const trimmed = clientId.trim();
+            if (!trimmed) return null;
+            const records = readRecords();
+            const existing = records.find((record)=>record.clientId === trimmed);
+            if (!existing) return null;
+            const now = Date.now();
+            const nextRecord = {
+                ...existing,
+                name: "string" == typeof name && name.trim() ? name.trim() : existing.name,
+                updatedAt: now,
+                lastSeenAt: now
+            };
+            writeRecords(replaceRecord(records, nextRecord));
+            return nextRecord;
+        }
+    };
+};
+const handleNodesApi = async (_ctx, nodeManager, store, req, url)=>{
+    if ("/api/nodes" === url.pathname && "GET" === req.method) {
+        const approvals = store.load();
+        const connectedNodes = nodeManager.getAllNodes();
+        const connectedByClientId = new Map();
+        for (const node of connectedNodes){
+            if (!node.clientId) continue;
+            const bucket = connectedByClientId.get(node.clientId) || [];
+            bucket.push(node);
+            connectedByClientId.set(node.clientId, bucket);
+        }
+        const clientIds = new Set([
+            ...approvals.map((record)=>record.clientId),
+            ...connectedByClientId.keys()
+        ]);
+        const nodes = Array.from(clientIds).map((clientId)=>{
+            const approval = approvals.find((record)=>record.clientId === clientId);
+            const connected = connectedByClientId.get(clientId) || [];
+            const capabilities = Array.from(new Set(connected.flatMap((node)=>Array.isArray(node.capabilities) ? node.capabilities : [])));
+            return {
+                clientId,
+                name: approval?.name || connected[0]?.name || clientId,
+                enabled: approval?.enabled ?? false,
+                createdAt: approval?.createdAt,
+                updatedAt: approval?.updatedAt,
+                lastSeenAt: approval?.lastSeenAt,
+                connected: connected.length > 0,
+                nodeIds: connected.map((node)=>node.id),
+                capabilities
+            };
+        }).sort((a, b)=>{
+            const aTime = a.updatedAt || 0;
+            const bTime = b.updatedAt || 0;
+            return bTime - aTime;
+        });
+        return new Response(JSON.stringify({
+            nodes
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    const clientMatch = url.pathname.match(/^\/api\/nodes\/([^/]+)$/);
+    if (!clientMatch) return null;
+    const clientId = normalizeClientId(clientMatch[1]);
+    if (!clientId) return new Response("valid clientId required", {
+        status: 400
+    });
+    if ("PUT" === req.method) {
+        let body;
+        try {
+            body = await req.json();
+        } catch  {
+            return new Response("Invalid JSON body", {
+                status: 400
+            });
+        }
+        if ("boolean" != typeof body.enabled) return new Response("enabled boolean required", {
+            status: 400
+        });
+        const nextRecord = store.setEnabled(clientId, body.enabled, body.name, body.enabled ? Date.now() : void 0);
+        if (!nextRecord.enabled) {
+            const activeNodes = nodeManager.getNodesByClientId(clientId);
+            for (const node of activeNodes)nodeManager.unregisterNode(node.id);
+        }
+        return new Response(JSON.stringify(nextRecord, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        const nextRecord = store.setEnabled(clientId, false);
+        const activeNodes = nodeManager.getNodesByClientId(clientId);
+        for (const node of activeNodes)nodeManager.unregisterNode(node.id);
+        return new Response(JSON.stringify(nextRecord, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("GET" === req.method) {
+        const approvals = store.load();
+        const approval = approvals.find((record)=>record.clientId === clientId);
+        const connected = nodeManager.getNodesByClientId(clientId);
+        if (!approval && 0 === connected.length) return new Response("Node not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify({
+            clientId,
+            name: approval?.name || connected[0]?.name || clientId,
+            enabled: approval?.enabled ?? false,
+            createdAt: approval?.createdAt,
+            updatedAt: approval?.updatedAt,
+            lastSeenAt: approval?.lastSeenAt,
+            connected: connected.length > 0,
+            nodeIds: connected.map((node)=>node.id)
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+export { createNodeApprovalStore, handleNodesApi };

package/dist/gateway/node.cjs

@@ -40,12 +40,13 @@ function _define_property(obj, key, value) {
 }
 const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
 class NodeManager {
-    registerNode(ws, name, capabilities, sessionId, agentName) {
+    registerNode(ws, name, capabilities, sessionId, agentName, clientId) {
         if (this.nodes.size >= this.maxNodes) return null;
         const id = this.generateNodeId();
         const node = {
             id,
             name,
+            clientId,
             capabilities,
             groups: new Set(),
             connectedAt: Date.now(),
@@ -54,6 +55,7 @@ class NodeManager {
             agentName
         };
         ws.data = {
+            ...ws.data,
             nodeId: id
         };
         this.nodes.set(id, node);
@@ -73,12 +75,18 @@ class NodeManager {
     getAllNodes() {
         return Array.from(this.nodes.values());
     }
+    getNodesByClientId(clientId) {
+        const trimmed = clientId.trim();
+        if (!trimmed) return [];
+        return Array.from(this.nodes.values()).filter((node)=>node.clientId === trimmed);
+    }
     getNodeMetadata(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node) return;
         return {
             id: node.id,
             name: node.name,
+            clientId: node.clientId,
             capabilities: node.capabilities,
             groups: node.groups,
             connectedAt: node.connectedAt,
@@ -190,6 +198,7 @@ class NodeManager {
             nodes: Array.from(this.nodes.values()).map((n)=>({
                     id: n.id,
                     name: n.name,
+                    clientId: n.clientId,
                     groupCount: n.groups.size,
                     connectedAt: n.connectedAt,
                     lastPing: n.lastPing,

package/dist/gateway/node.d.ts

@@ -14,7 +14,11 @@ export declare class NodeManager {
      */
     registerNode(ws: ServerWebSocket<{
         nodeId: string;
-    }>, name: string, capabilities?: string[], sessionId?: string, agentName?: string): Node | null;
+        clientId?: string;
+        clientType?: string;
+        authenticated?: boolean;
+        tailscaleUser?: string;
+    }>, name: string, capabilities?: string[], sessionId?: string, agentName?: string, clientId?: string): Node | null;
     /**
      * Unregister a node
      */
@@ -27,6 +31,10 @@ export declare class NodeManager {
      * Get all nodes
      */
     getAllNodes(): Node[];
+    /**
+     * Get all nodes for a stable client ID
+     */
+    getNodesByClientId(clientId: string): Node[];
     /**
      * Get node metadata (without WebSocket)
      */
@@ -102,6 +110,7 @@ export declare class NodeManager {
         nodes: {
             id: string;
             name: string;
+            clientId: string | undefined;
             groupCount: number;
             connectedAt: number;
             lastPing: number | undefined;

package/dist/gateway/node.js

@@ -12,12 +12,13 @@ function _define_property(obj, key, value) {
 }
 const logger = createLogger();
 class NodeManager {
-    registerNode(ws, name, capabilities, sessionId, agentName) {
+    registerNode(ws, name, capabilities, sessionId, agentName, clientId) {
         if (this.nodes.size >= this.maxNodes) return null;
         const id = this.generateNodeId();
         const node = {
             id,
             name,
+            clientId,
             capabilities,
             groups: new Set(),
             connectedAt: Date.now(),
@@ -26,6 +27,7 @@ class NodeManager {
             agentName
         };
         ws.data = {
+            ...ws.data,
             nodeId: id
         };
         this.nodes.set(id, node);
@@ -45,12 +47,18 @@ class NodeManager {
     getAllNodes() {
         return Array.from(this.nodes.values());
     }
+    getNodesByClientId(clientId) {
+        const trimmed = clientId.trim();
+        if (!trimmed) return [];
+        return Array.from(this.nodes.values()).filter((node)=>node.clientId === trimmed);
+    }
     getNodeMetadata(nodeId) {
         const node = this.nodes.get(nodeId);
         if (!node) return;
         return {
             id: node.id,
             name: node.name,
+            clientId: node.clientId,
             capabilities: node.capabilities,
             groups: node.groups,
             connectedAt: node.connectedAt,
@@ -162,6 +170,7 @@ class NodeManager {
             nodes: Array.from(this.nodes.values()).map((n)=>({
                     id: n.id,
                     name: n.name,
+                    clientId: n.clientId,
                     groupCount: n.groups.size,
                     connectedAt: n.connectedAt,
                     lastPing: n.lastPing,