@ericsanchezok/meta-synergy 1.1.7 → 1.1.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@ericsanchezok/meta-synergy",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "type": "module",
   "license": "MIT",
   "bin": {

package/src/holos/client.ts

@@ -12,13 +12,19 @@ const HOLOS_WS_URL = `wss://${HOLOS_HOST}`
 export class MetaSynergyHolosClient {
   #ws: WebSocket | null = null
   #heartbeat: ReturnType<typeof setInterval> | null = null
+  #disconnecting = false
 
   constructor(
     readonly auth: { agentID: string; agentSecret: string },
     readonly inbound: MetaSynergyInboundHandler,
+    readonly hooks?: {
+      onOpen?: () => void | Promise<void>
+      onClose?: (input: { opened: boolean; intentional: boolean }) => void | Promise<void>
+    },
   ) {}
 
   async connect() {
+    this.#disconnecting = false
     const token = await fetchWsToken(this.auth.agentSecret)
     const endpoint = `${HOLOS_WS_URL}/api/v1/holos/agent_tunnel/ws?token=${token}`
     MetaSynergyLog.info("holos.connect.begin", {
@@ -35,6 +41,7 @@ export class MetaSynergyHolosClient {
         MetaSynergyLog.info("holos.connect.open", {
           agentID: this.auth.agentID,
         })
+        void this.hooks?.onOpen?.()
         resolve()
       })
       ws.addEventListener("error", (error) => {
@@ -58,10 +65,14 @@ export class MetaSynergyHolosClient {
     ws.addEventListener("close", () => {
       MetaSynergyLog.warn("holos.socket.closed", {
         agentID: this.auth.agentID,
+        intentional: this.#disconnecting,
       })
       if (this.#heartbeat) clearInterval(this.#heartbeat)
       this.#heartbeat = null
       this.#ws = null
+      const intentional = this.#disconnecting
+      this.#disconnecting = false
+      void this.hooks?.onClose?.({ opened: true, intentional })
     })
 
     this.#heartbeat = setInterval(() => {
@@ -78,6 +89,7 @@ export class MetaSynergyHolosClient {
     })
     if (this.#heartbeat) clearInterval(this.#heartbeat)
     this.#heartbeat = null
+    this.#disconnecting = true
     this.#ws?.close()
     this.#ws = null
   }

package/src/holos/login.ts

@@ -22,7 +22,7 @@ export namespace MetaSynergyHolosLogin {
     })
     const body = MetaSynergyHolosProtocol.WsTokenResponse.safeParse(await response.json())
     if (!body.success || !response.ok || body.data.code !== 0) {
-      return { valid: false, reason: body.success ? body.data.message ?? "Invalid response" : "Invalid response" }
+      return { valid: false, reason: body.success ? (body.data.message ?? "Invalid response") : "Invalid response" }
     }
     return { valid: true }
   }
@@ -47,12 +47,28 @@ export namespace MetaSynergyHolosLogin {
         if (!params.code || !params.state) {
           reject(new Error("Missing login callback parameters."))
           response.statusCode = 400
-          response.end("Login failed.")
+          response.setHeader("Content-Type", "text/html; charset=utf-8")
+          response.end(
+            htmlPage({
+              title: "MetaSynergy Login",
+              status: "failed",
+              heading: "Login failed",
+              message: "Missing callback parameters. Please return to MetaSynergy and try again.",
+            }),
+          )
           return
         }
 
         resolve({ code: params.code, state: params.state })
-        response.end("Login successful. You can close this window.")
+        response.setHeader("Content-Type", "text/html; charset=utf-8")
+        response.end(
+          htmlPage({
+            title: "MetaSynergy Login",
+            status: "success",
+            heading: "MetaSynergy is ready",
+            message: "Login successful. You can close this page and return to the app.",
+          }),
+        )
       })
       server.listen(port, "127.0.0.1")
 
@@ -126,3 +142,163 @@ async function launchBrowser(url: string): Promise<void> {
   const child = spawn(command[0], command.slice(1), { stdio: "ignore", detached: true })
   child.unref()
 }
+
+function htmlPage(input: { title: string; status: "success" | "failed"; heading: string; message: string }): string {
+  const accent = input.status === "success" ? "#86efac" : "#fca5a5"
+  const badge = input.status === "success" ? "Connected" : "Error"
+  const symbol = input.status === "success" ? "✓" : "!"
+
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(input.title)}</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #050816;
+        --panel: rgba(12, 18, 38, 0.82);
+        --panel-border: rgba(255, 255, 255, 0.12);
+        --text: #f8fafc;
+        --text-dim: rgba(226, 232, 240, 0.72);
+        --accent: ${accent};
+      }
+
+      * { box-sizing: border-box; }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+        font-family:
+          Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI",
+          sans-serif;
+        color: var(--text);
+        background:
+          radial-gradient(circle at top, rgba(79, 70, 229, 0.28), transparent 34%),
+          radial-gradient(circle at bottom right, rgba(34, 197, 94, 0.18), transparent 30%),
+          linear-gradient(180deg, #030712 0%, var(--bg) 100%);
+      }
+
+      .shell {
+        width: min(100%, 560px);
+        border-radius: 24px;
+        border: 1px solid var(--panel-border);
+        background: var(--panel);
+        backdrop-filter: blur(22px);
+        box-shadow:
+          0 24px 80px rgba(0, 0, 0, 0.42),
+          inset 0 1px 0 rgba(255, 255, 255, 0.06);
+        overflow: hidden;
+      }
+
+      .masthead {
+        padding: 20px 24px 0;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+      }
+
+      .brand {
+        font-size: 13px;
+        letter-spacing: 0.14em;
+        text-transform: uppercase;
+        color: var(--text-dim);
+      }
+
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        padding: 7px 12px;
+        border-radius: 999px;
+        background: rgba(255, 255, 255, 0.05);
+        border: 1px solid rgba(255, 255, 255, 0.08);
+        color: var(--text);
+        font-size: 12px;
+      }
+
+      .badge::before {
+        content: "";
+        width: 8px;
+        height: 8px;
+        border-radius: 999px;
+        background: var(--accent);
+        box-shadow: 0 0 16px var(--accent);
+      }
+
+      .content {
+        padding: 28px 24px 30px;
+        text-align: center;
+      }
+
+      .mark {
+        width: 72px;
+        height: 72px;
+        margin: 0 auto 18px;
+        border-radius: 22px;
+        display: grid;
+        place-items: center;
+        font-size: 34px;
+        font-weight: 700;
+        color: #04111f;
+        background: linear-gradient(180deg, rgba(255,255,255,0.92), rgba(255,255,255,0.8));
+        box-shadow:
+          0 12px 30px rgba(0, 0, 0, 0.24),
+          0 0 0 6px rgba(255, 255, 255, 0.03);
+      }
+
+      h1 {
+        margin: 0 0 10px;
+        font-size: clamp(28px, 6vw, 36px);
+        line-height: 1.05;
+      }
+
+      p {
+        margin: 0 auto;
+        max-width: 34ch;
+        color: var(--text-dim);
+        font-size: 15px;
+        line-height: 1.6;
+      }
+
+      .footer {
+        margin-top: 24px;
+        padding-top: 18px;
+        border-top: 1px solid rgba(255, 255, 255, 0.08);
+        color: rgba(226, 232, 240, 0.58);
+        font-size: 12px;
+        letter-spacing: 0.06em;
+        text-transform: uppercase;
+      }
+    </style>
+  </head>
+  <body>
+    <main class="shell">
+      <div class="masthead">
+        <div class="brand">MetaSynergy</div>
+        <div class="badge">${badge}</div>
+      </div>
+      <section class="content">
+        <div class="mark">${symbol}</div>
+        <h1>${escapeHtml(input.heading)}</h1>
+        <p>${escapeHtml(input.message)}</p>
+        <div class="footer">Holos agent tunnel</div>
+      </section>
+    </main>
+  </body>
+</html>`
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;")
+}

package/src/inbound/handler.ts

@@ -85,11 +85,7 @@ export class MetaSynergyInboundHandler {
         callerAgentID: input.caller.agentID,
         error: error instanceof Error ? error.message : String(error),
       })
-      return errorResult(
-        undefined,
-        "host_internal_error",
-        error instanceof Error ? error.message : String(error),
-      )
+      return errorResult(undefined, "host_internal_error", error instanceof Error ? error.message : String(error))
     }
   }
 
@@ -192,9 +188,7 @@ function errorResult(
   }
 }
 
-function isEnvelopeError(
-  error: unknown,
-): error is {
+function isEnvelopeError(error: unknown): error is {
   requestID?: string
   tool?: MetaProtocolEnvelope.Tool
   action?: string

package/src/rpc/handler.ts

@@ -136,9 +136,7 @@ function errorResult(
   }
 }
 
-function isEnvelopeError(
-  error: unknown,
-): error is {
+function isEnvelopeError(error: unknown): error is {
   requestID?: string
   tool?: MetaProtocolEnvelope.Tool
   action?: string

package/src/rpc/schema.ts

@@ -1,5 +1,10 @@
 import z from "zod"
-import { MetaProtocolBash, MetaProtocolEnvelope, MetaProtocolProcess, MetaProtocolSession } from "@ericsanchezok/meta-protocol"
+import {
+  MetaProtocolBash,
+  MetaProtocolEnvelope,
+  MetaProtocolProcess,
+  MetaProtocolSession,
+} from "@ericsanchezok/meta-protocol"
 
 export const RPCRequestSchema = z.discriminatedUnion("tool", [
   MetaProtocolBash.ExecuteRequest,

package/src/runtime.ts

@@ -19,6 +19,10 @@ export class MetaSynergyRuntime {
   #client: MetaSynergyHolosClient | null = null
   #timers: Array<ReturnType<typeof setInterval>> = []
   #lastControlRequestID?: string
+  #reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  #reconnectAttempt = 0
+  #stopping = false
+  #manualReconnectInFlight = false
 
   private constructor(
     host: MetaSynergyHost,
@@ -82,6 +86,7 @@ export class MetaSynergyRuntime {
 
   async start() {
     const state = requireState(this)
+    this.#stopping = false
     state.connectionStatus = "connecting"
     await MetaSynergyStore.saveState(state)
 
@@ -96,15 +101,26 @@ export class MetaSynergyRuntime {
       throw new Error("Meta Synergy could not load credentials after login.")
     }
 
-    this.#client = new MetaSynergyHolosClient(nextAuth, this.inbound)
-    await this.#connectClient()
     this.#startLoops()
+    this.#ensureClient(nextAuth)
+    try {
+      await this.#connectClient()
+    } catch (error) {
+      MetaSynergyLog.error("runtime.connection.initial_connect_failed", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+      await this.#setConnectionStatus("disconnected")
+      this.#scheduleReconnect("initial_connect_failed")
+    }
 
-    console.log(`Connected to Holos as ${nextAuth.agentID}`)
+    console.log(`MetaSynergy running as ${nextAuth.agentID}`)
     console.log(`envID: ${this.host.envID}`)
+    console.log(`Holos: ${this.state?.connectionStatus ?? "disconnected"}`)
     console.log(`Status: ${this.sessions.current() ? "busy" : "idle"}`)
 
     const stop = async () => {
+      this.#stopping = true
+      this.#clearReconnectTimer()
       this.#stopLoops()
       if (this.state) {
         this.state.connectionStatus = "disconnected"
@@ -132,6 +148,8 @@ export class MetaSynergyRuntime {
   }
 
   async logout() {
+    this.#stopping = true
+    this.#clearReconnectTimer()
     this.#stopLoops()
     if (this.state) {
       this.state.connectionStatus = "disconnected"
@@ -226,7 +244,10 @@ export class MetaSynergyRuntime {
         this.sessions.kickCurrent(disk.controlRequest.block ?? false)
       }
       if (disk.controlRequest.kind === "reconnect") {
-        await this.#reconnectClient()
+        const succeeded = await this.#reconnectClient()
+        if (!succeeded) {
+          this.#scheduleReconnect("manual_reconnect_failed")
+        }
       }
       this.state.controlRequest = undefined
       await MetaSynergyStore.saveState(this.state)
@@ -242,35 +263,112 @@ export class MetaSynergyRuntime {
       throw new Error("Meta Synergy could not load credentials.")
     }
 
-    if (!this.#client) {
-      this.#client = new MetaSynergyHolosClient(auth, this.inbound)
+    this.#ensureClient(auth)
+    const client = this.#client
+    if (!client) {
+      throw new Error("Meta Synergy could not create Holos client.")
     }
 
-    this.state.connectionStatus = "connecting"
-    await MetaSynergyStore.saveState(this.state)
+    await this.#setConnectionStatus("connecting")
     try {
-      await this.#client.connect()
-      this.state.connectionStatus = "connected"
-      await MetaSynergyStore.saveState(this.state)
+      await client.connect()
+      this.#reconnectAttempt = 0
+      this.#clearReconnectTimer()
+      await this.#setConnectionStatus("connected")
     } catch (error) {
-      this.state.connectionStatus = "disconnected"
-      await MetaSynergyStore.saveState(this.state)
+      await this.#setConnectionStatus("disconnected")
       throw error
     }
   }
 
   async #reconnectClient() {
     MetaSynergyLog.info("runtime.connection.reconnect.begin")
+    this.#manualReconnectInFlight = true
+    this.#clearReconnectTimer()
     await this.#client?.disconnect().catch(() => undefined)
     this.#client = null
+    let succeeded = false
     try {
       await this.#connectClient()
+      succeeded = true
       MetaSynergyLog.info("runtime.connection.reconnect.completed")
     } catch (error) {
       MetaSynergyLog.error("runtime.connection.reconnect.failed", {
         error: error instanceof Error ? error.message : String(error),
       })
+    } finally {
+      this.#manualReconnectInFlight = false
     }
+    return succeeded
+  }
+
+  #ensureClient(auth: { agentID: string; agentSecret: string }) {
+    if (this.#client?.auth.agentID === auth.agentID && this.#client?.auth.agentSecret === auth.agentSecret) {
+      return
+    }
+    let client!: MetaSynergyHolosClient
+    client = new MetaSynergyHolosClient(auth, this.inbound, {
+      onClose: ({ intentional }) => {
+        if (this.#client !== client) return
+        void this.#handleClientClosed({ intentional })
+      },
+    })
+    this.#client = client
+  }
+
+  async #handleClientClosed(input: { intentional: boolean }) {
+    await this.#setConnectionStatus("disconnected")
+    if (input.intentional || this.#stopping || this.#manualReconnectInFlight) {
+      return
+    }
+    this.#scheduleReconnect("socket_closed")
+  }
+
+  #scheduleReconnect(reason: string) {
+    if (this.#stopping || this.#manualReconnectInFlight || this.#reconnectTimer) return
+
+    const attempt = this.#reconnectAttempt + 1
+    const delayMs = Math.min(60_000, 2_000 * 2 ** (attempt - 1))
+    this.#reconnectAttempt = attempt
+    MetaSynergyLog.warn("runtime.connection.reconnect.scheduled", {
+      reason,
+      attempt,
+      delayMs,
+    })
+
+    const timer = setTimeout(() => {
+      this.#reconnectTimer = null
+      void this.#performScheduledReconnect()
+    }, delayMs)
+    timer.unref?.()
+    this.#reconnectTimer = timer
+  }
+
+  async #performScheduledReconnect() {
+    if (this.#stopping || this.#manualReconnectInFlight) return
+    try {
+      const succeeded = await this.#reconnectClient()
+      if (!succeeded) {
+        this.#scheduleReconnect("scheduled_reconnect_failed")
+      }
+    } catch (error) {
+      MetaSynergyLog.error("runtime.connection.reconnect.unexpected", {
+        error: error instanceof Error ? error.message : String(error),
+      })
+      this.#scheduleReconnect("scheduled_reconnect_failed")
+    }
+  }
+
+  #clearReconnectTimer() {
+    if (!this.#reconnectTimer) return
+    clearTimeout(this.#reconnectTimer)
+    this.#reconnectTimer = null
+  }
+
+  async #setConnectionStatus(status: "disconnected" | "connecting" | "connected") {
+    if (!this.state) return
+    this.state.connectionStatus = status
+    await MetaSynergyStore.saveState(this.state)
   }
 
   async confirmCollaboration(input: { caller: { agentID: string }; label?: string }) {
@@ -314,5 +412,5 @@ function requireState(runtime: MetaSynergyRuntime) {
 }
 
 function escapeAppleScript(input: string) {
-  return input.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")
+  return input.replaceAll("\\", "\\\\").replaceAll('"', '\\"')
 }

package/src/session/manager.ts

@@ -244,6 +244,9 @@ export class SessionManager {
   }
 }
 
-function envelopeError(code: MetaProtocolError.Code, message: string): { code: MetaProtocolError.Code; message: string } {
+function envelopeError(
+  code: MetaProtocolError.Code,
+  message: string,
+): { code: MetaProtocolError.Code; message: string } {
   return { code, message }
 }