npm - @spikelabs/lobster-shell-plugin - Versions diffs - 0.2.2 - Mend

@spikelabs/lobster-shell-plugin 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md +80 -0
package/dist/chunk-RNTMVHEF.js +202 -0
package/dist/index.d.ts +191 -0
package/dist/index.js +905 -0
package/dist/oauth-flow-O6AKA5CZ.js +6 -0
package/openclaw.plugin.json +22 -0
package/package.json +63 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,905 @@
+import {
+  OAuthFlow
+} from "./chunk-RNTMVHEF.js";
+// src/index.ts
+import { hostname, platform } from "os";
+// src/setup-page.ts
+function renderSetupPage(opts) {
+  const statusColor = opts.connected ? "#22c55e" : "#ef4444";
+  const statusText = opts.connected ? "Connected" : "Disconnected";
+  return (
+    /* html */
+    `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Lobster Shell \u2014 Setup</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+      background: #0a0a0a;
+      color: #e5e5e5;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    .card {
+      background: #171717;
+      border: 1px solid #262626;
+      border-radius: 12px;
+      padding: 2rem;
+      max-width: 420px;
+      width: 100%;
+    }
+    h1 { font-size: 1.25rem; margin-bottom: 0.5rem; }
+    .status {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin: 1rem 0;
+      font-size: 0.9rem;
+    }
+    .dot {
+      width: 10px;
+      height: 10px;
+      border-radius: 50%;
+      background: ${statusColor};
+    }
+    .info {
+      background: #1a1a2e;
+      border-radius: 8px;
+      padding: 0.75rem 1rem;
+      font-size: 0.8rem;
+      color: #a1a1aa;
+      margin: 1rem 0;
+      word-break: break-all;
+    }
+    .info strong { color: #e5e5e5; }
+    .btn {
+      display: inline-block;
+      padding: 0.6rem 1.2rem;
+      border-radius: 8px;
+      border: none;
+      font-size: 0.9rem;
+      cursor: pointer;
+      text-decoration: none;
+      font-weight: 500;
+    }
+    .btn-primary {
+      background: #6366f1;
+      color: white;
+    }
+    .btn-primary:hover { background: #4f46e5; }
+    .btn-danger {
+      background: #dc2626;
+      color: white;
+      margin-left: 0.5rem;
+    }
+    .btn-danger:hover { background: #b91c1c; }
+    .message {
+      background: #1a2e1a;
+      border: 1px solid #22c55e33;
+      color: #86efac;
+      padding: 0.5rem 0.75rem;
+      border-radius: 6px;
+      font-size: 0.8rem;
+      margin-bottom: 1rem;
+    }
+    .error {
+      background: #2e1a1a;
+      border: 1px solid #ef444433;
+      color: #fca5a5;
+      padding: 0.5rem 0.75rem;
+      border-radius: 6px;
+      font-size: 0.8rem;
+      margin-bottom: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>Lobster Shell</h1>
+    <p style="color: #a1a1aa; font-size: 0.85rem;">Connect your OpenClaw agent to Lobster Shell cloud.</p>
+    ${opts.message ? `<div class="message">${opts.message}</div>` : ""}
+    ${opts.error ? `<div class="error">${opts.error}</div>` : ""}
+    <div class="status">
+      <span class="dot"></span>
+      <span>${statusText}</span>
+      ${opts.bridgeStatus && opts.bridgeStatus !== statusText.toLowerCase() ? `<span style="color:#a1a1aa">(bridge: ${opts.bridgeStatus})</span>` : ""}
+    </div>
+    ${opts.connected ? `
+    <div class="info">
+      <div><strong>Gateway ID:</strong> ${opts.gatewayPublicId}</div>
+      <div><strong>Channel:</strong> ${opts.channelName}</div>
+    </div>
+    ` : ""}
+    <div style="margin-top: 1rem;">
+      ${opts.connected ? `<span style="color: #a1a1aa; font-size: 0.85rem;">Gateway is connected to Lobster Shell cloud.</span>` : `<a href="/lobster/connect" class="btn btn-primary">Connect to Lobster Shell</a>`}
+    </div>
+  </div>
+</body>
+</html>`
+  );
+}
+// src/cloud-bridge.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+// src/bridge-protocol.ts
+var ABLY_EVENT = {
+  PLUGIN: "plugin-event",
+  COMMAND: "cloud-command"
+};
+// src/cloud-bridge.ts
+var CloudBridge = class {
+  cloudUrl;
+  stateDir;
+  logger;
+  _status = "disconnected";
+  ably = null;
+  channel = null;
+  heartbeatTimer = null;
+  commandHandlers = [];
+  constructor(opts) {
+    this.cloudUrl = opts.cloudUrl;
+    this.stateDir = opts.stateDir;
+    this.logger = opts.logger;
+  }
+  get status() {
+    return this._status;
+  }
+  onCommand(handler) {
+    this.commandHandlers.push(handler);
+  }
+  // -------------------------------------------------------------------------
+  // Connect
+  // -------------------------------------------------------------------------
+  async connect() {
+    const auth = await this.loadAuth();
+    if (!auth) {
+      this.logger.info("[lobster:bridge] No auth credentials \u2014 skipping connection");
+      return;
+    }
+    this._status = "connecting";
+    this.logger.info("[lobster:bridge] Connecting to Ably\u2026");
+    try {
+      const Ably = await import("ably");
+      this.ably = new Ably.Realtime({
+        authCallback: async (_params, callback) => {
+          try {
+            const tokenResponse = await this.fetchAblyToken(auth);
+            callback(null, tokenResponse.tokenRequest);
+          } catch (err) {
+            this.logger.error(`[lobster:bridge] Ably auth failed: ${err}`);
+            callback(err instanceof Error ? err.message : String(err), null);
+          }
+        },
+        autoConnect: true,
+        disconnectedRetryTimeout: 1e3,
+        suspendedRetryTimeout: 5e3
+      });
+      this.ably.connection.on("connected", () => {
+        this._status = "connected";
+        this.logger.info("[lobster:bridge] Connected to Ably");
+        this.startHeartbeat();
+      });
+      this.ably.connection.on("disconnected", () => {
+        this._status = "disconnected";
+        this.logger.warn("[lobster:bridge] Disconnected from Ably, will retry\u2026");
+      });
+      this.ably.connection.on("failed", () => {
+        this._status = "error";
+        this.logger.error("[lobster:bridge] Ably connection failed");
+      });
+      this.channel = this.ably.channels.get(auth.channelName);
+      this.channel.on("failed", (stateChange) => {
+        this._status = "error";
+        this.logger.error(
+          `[lobster:bridge] Channel failed: ${stateChange.reason?.message ?? "unknown"}`
+        );
+      });
+      try {
+        await this.channel.subscribe(ABLY_EVENT.COMMAND, (message) => {
+          const cmd = message.data;
+          this.logger.info(`[lobster:bridge] Received command: ${cmd.type}`);
+          for (const handler of this.commandHandlers) {
+            try {
+              handler(cmd);
+            } catch (err) {
+              this.logger.error(`[lobster:bridge] Command handler error: ${err}`);
+            }
+          }
+        });
+      } catch (err) {
+        this.logger.error(`[lobster:bridge] Channel subscribe failed: ${err}`);
+        this._status = "error";
+        return;
+      }
+      try {
+        await this.channel.presence.enter({ status: "online" });
+      } catch (err) {
+        this.logger.warn(`[lobster:bridge] Presence enter failed: ${err}`);
+      }
+    } catch (err) {
+      this._status = "error";
+      this.logger.error(`[lobster:bridge] Connection error: ${err}`);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Disconnect
+  // -------------------------------------------------------------------------
+  async disconnect() {
+    this.stopHeartbeat();
+    if (this.channel) {
+      try {
+        await this.channel.presence.leave();
+      } catch {
+      }
+      this.channel.unsubscribe();
+      this.channel = null;
+    }
+    if (this.ably) {
+      this.ably.close();
+      this.ably = null;
+    }
+    this._status = "disconnected";
+    this.logger.info("[lobster:bridge] Disconnected");
+  }
+  // -------------------------------------------------------------------------
+  // Publish (fire-and-forget)
+  // -------------------------------------------------------------------------
+  publish(event) {
+    if (!this.channel || this._status !== "connected") return;
+    this.channel.publish(ABLY_EVENT.PLUGIN, event).catch((err) => {
+      this.logger.warn(`[lobster:bridge] Publish failed: ${err}`);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Tenant JWT
+  // -------------------------------------------------------------------------
+  /**
+   * Get a valid tenant JWT, refreshing from cloud if expired or near-expiry.
+   * Returns null if not authenticated.
+   */
+  async getTenantToken() {
+    const auth = await this.loadAuth();
+    if (!auth?.tenantToken) return null;
+    const expiresAt = auth.tenantTokenExpiresAt ? new Date(auth.tenantTokenExpiresAt).getTime() : 0;
+    if (Date.now() > expiresAt - 5 * 60 * 1e3) {
+      const refreshed = await this.refreshTenantToken(auth);
+      return refreshed;
+    }
+    return auth.tenantToken;
+  }
+  async refreshTenantToken(auth) {
+    this.logger.info("[lobster:bridge] Refreshing tenant JWT\u2026");
+    try {
+      const res = await fetch(`${this.cloudUrl}/api/plugin/token`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${auth.accessToken}`
+        }
+      });
+      if (!res.ok) {
+        this.logger.warn(`[lobster:bridge] Tenant token refresh failed: ${res.status}`);
+        return null;
+      }
+      const data = await res.json();
+      const updated = {
+        ...auth,
+        tenantToken: data.token,
+        tenantTokenExpiresAt: data.expiresAt
+      };
+      await mkdir(this.stateDir, { recursive: true });
+      await writeFile(
+        join(this.stateDir, "auth.json"),
+        JSON.stringify(updated, null, 2)
+      );
+      this.logger.info("[lobster:bridge] Tenant JWT refreshed");
+      return data.token;
+    } catch (err) {
+      this.logger.error(`[lobster:bridge] Tenant token refresh error: ${err}`);
+      return null;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  async loadAuth() {
+    try {
+      const raw = await readFile(join(this.stateDir, "auth.json"), "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async fetchAblyToken(auth) {
+    const res = await fetch(`${this.cloudUrl}/api/plugin/ably-token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.accessToken}`
+      },
+      body: JSON.stringify({ gatewayPublicId: auth.gatewayPublicId })
+    });
+    if (res.status === 401 && auth.refreshToken) {
+      this.logger.info("[lobster:bridge] Access token expired, refreshing\u2026");
+      const { OAuthFlow: OAuthFlow2 } = await import("./oauth-flow-O6AKA5CZ.js");
+      const oauthFlow2 = new OAuthFlow2({
+        stateDir: this.stateDir,
+        cloudUrl: this.cloudUrl,
+        logger: this.logger
+      });
+      const refreshed = await oauthFlow2.refreshAccessToken();
+      if (!refreshed) {
+        throw new Error("Access token expired and refresh failed \u2014 re-authenticate at /lobster/connect");
+      }
+      const retryRes = await fetch(`${this.cloudUrl}/api/plugin/ably-token`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${refreshed.accessToken}`
+        },
+        body: JSON.stringify({ gatewayPublicId: refreshed.gatewayPublicId })
+      });
+      if (!retryRes.ok) {
+        throw new Error(`Ably token request failed after refresh: ${retryRes.status}`);
+      }
+      return await retryRes.json();
+    }
+    if (!res.ok) {
+      throw new Error(`Ably token request failed: ${res.status}`);
+    }
+    return await res.json();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.publish({ type: "heartbeat", timestamp: Date.now() });
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+};
+// src/gateway-ws-client.ts
+import { randomUUID } from "crypto";
+var GatewayWsClient = class {
+  port;
+  token;
+  logger;
+  ws = null;
+  pending = /* @__PURE__ */ new Map();
+  _connected = false;
+  chatHandler = null;
+  constructor(opts) {
+    this.port = opts.port;
+    this.token = opts.token;
+    this.logger = opts.logger;
+  }
+  get connected() {
+    return this._connected;
+  }
+  onChat(handler) {
+    this.chatHandler = handler;
+  }
+  // -------------------------------------------------------------------------
+  // Connect
+  // -------------------------------------------------------------------------
+  async connect() {
+    const WebSocket = (await import("ws")).default;
+    return new Promise((resolve, reject) => {
+      const url = `ws://127.0.0.1:${this.port}`;
+      this.logger.info(`[lobster:ws] Connecting to gateway at ${url}`);
+      this.ws = new WebSocket(url, { handshakeTimeout: 8e3 });
+      const openTimeout = setTimeout(() => {
+        reject(new Error("WS open timeout"));
+        this.ws?.close();
+      }, 1e4);
+      this.ws.once("open", () => {
+        clearTimeout(openTimeout);
+        this.setupMessageHandler();
+        this.handshake().then(resolve).catch(reject);
+      });
+      this.ws.once("error", (err) => {
+        clearTimeout(openTimeout);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+      this.ws.on("close", () => {
+        this._connected = false;
+        this.logger.warn("[lobster:ws] Gateway WebSocket closed");
+      });
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Send message to agent
+  // -------------------------------------------------------------------------
+  async sendMessage(text, sessionKey) {
+    if (!this._connected) {
+      this.logger.warn("[lobster:ws] Cannot send \u2014 not connected to gateway");
+      return;
+    }
+    this.logger.info(`[lobster:ws] \u2192 Sending to gateway: text="${text.slice(0, 100)}" sessionKey=${sessionKey ?? "main"}`);
+    const res = await this.request("chat.send", {
+      sessionKey: sessionKey ?? "main",
+      message: text,
+      idempotencyKey: randomUUID()
+    });
+    if (!res.ok) {
+      this.logger.error(`[lobster:ws] chat.send failed: ${JSON.stringify(res.error)}`);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Disconnect
+  // -------------------------------------------------------------------------
+  disconnect() {
+    for (const waiter of this.pending.values()) {
+      clearTimeout(waiter.timeout);
+    }
+    this.pending.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this._connected = false;
+  }
+  // -------------------------------------------------------------------------
+  // Internals
+  // -------------------------------------------------------------------------
+  async handshake() {
+    const res = await this.request("connect", {
+      minProtocol: 3,
+      maxProtocol: 3,
+      client: {
+        id: "cli",
+        displayName: "Lobster Shell Plugin",
+        version: "0.1.0",
+        platform: "node",
+        mode: "cli",
+        instanceId: "lobster-shell-bridge"
+      },
+      role: "operator",
+      scopes: ["operator.read", "operator.write"],
+      auth: { token: this.token }
+    });
+    if (!res.ok) {
+      throw new Error(`Gateway handshake failed: ${JSON.stringify(res.error)}`);
+    }
+    this._connected = true;
+    this.logger.info("[lobster:ws] Connected to gateway as operator");
+  }
+  request(method, params, timeoutMs = 15e3) {
+    return new Promise((resolve, reject) => {
+      if (!this.ws || this.ws.readyState !== 1) {
+        reject(new Error("WebSocket not open"));
+        return;
+      }
+      const id = randomUUID();
+      const frame = { type: "req", id, method, params };
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timeout waiting for ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timeout });
+      this.ws.send(JSON.stringify(frame));
+    });
+  }
+  setupMessageHandler() {
+    if (!this.ws) return;
+    this.ws.on("message", (data) => {
+      const text = typeof data === "string" ? data : Buffer.from(data).toString("utf8");
+      let frame;
+      try {
+        frame = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (frame.type === "res") {
+        const waiter = this.pending.get(frame.id);
+        if (waiter) {
+          this.pending.delete(frame.id);
+          clearTimeout(waiter.timeout);
+          waiter.resolve(frame);
+        }
+      } else if (frame.type === "event" && frame.event === "chat") {
+        const payload = frame.payload;
+        const contentPreview = payload.message?.content ? typeof payload.message.content === "string" ? payload.message.content.slice(0, 80) : JSON.stringify(payload.message.content).slice(0, 80) : "(none)";
+        this.logger.info(
+          `[lobster:ws] \u2190 Gateway chat event: state=${payload.state} role=${payload.message?.role ?? "?"} sessionKey=${payload.sessionKey} content="${contentPreview}"`
+        );
+        if (this.chatHandler) {
+          this.chatHandler(payload);
+        }
+      }
+    });
+  }
+};
+// src/api-client.ts
+var bridge = null;
+function initApiClient(cloudBridge) {
+  bridge = cloudBridge;
+}
+// src/index.ts
+var PLUGIN_ID = "lobster-shell";
+var CHANNEL_ID = "lobster-shell";
+var PLUGIN_VERSION = "0.2.2";
+var DEFAULT_CLOUD_URL = "https://www.lobstershell.ai";
+var gatewayPort;
+var bridge2 = null;
+var oauthFlow = null;
+var serviceCtx = null;
+var gatewayWs = null;
+function getCloudUrl(api) {
+  const cfg = api.pluginConfig ?? {};
+  return cfg["cloudUrl"] ?? DEFAULT_CLOUD_URL;
+}
+function buildGatewayInfo() {
+  return {
+    pluginVersion: PLUGIN_VERSION,
+    gatewayPort: gatewayPort ?? 18789,
+    os: `${platform()} ${process.arch}`,
+    hostname: hostname()
+  };
+}
+function parseQuery(req) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const query = {};
+  for (const [key, value] of url.searchParams) {
+    query[key] = value;
+  }
+  return query;
+}
+function sendHtml(res, statusCode, html) {
+  res.writeHead(statusCode, { "Content-Type": "text/html; charset=utf-8" });
+  res.end(html);
+}
+function sendRedirect(res, location) {
+  res.writeHead(302, { Location: location });
+  res.end();
+}
+function sendText(res, statusCode, text) {
+  res.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end(text);
+}
+var plugin = {
+  id: PLUGIN_ID,
+  name: "Lobster Shell",
+  description: "Connect your OpenClaw agent to Lobster Shell cloud",
+  version: PLUGIN_VERSION,
+  register(api) {
+    const { logger } = api;
+    logger.info("Lobster Shell plugin loading\u2026");
+    const cloudUrl = getCloudUrl(api);
+    api.registerChannel({
+      id: CHANNEL_ID,
+      meta: {
+        id: CHANNEL_ID,
+        label: "Lobster Shell",
+        selectionLabel: "Lobster Shell",
+        docsPath: "/plugins/lobster-shell",
+        blurb: "AI avatar powered by Lobster Shell"
+      },
+      capabilities: {
+        chatTypes: ["direct"],
+        media: true
+      },
+      config: {
+        listAccountIds: () => ["default"],
+        resolveAccount: () => ({ accountId: "default", enabled: true })
+      },
+      outbound: {
+        deliveryMode: "direct",
+        async sendText(ctx) {
+          logger.info(
+            `[lobster:outbound] to=${ctx.to} text=${ctx.text.slice(0, 120)}\u2026`
+          );
+          bridge2?.publish({
+            type: "agent_response",
+            channelId: CHANNEL_ID,
+            to: ctx.to,
+            text: ctx.text
+          });
+          return { ok: true, messageId: `spike-${Date.now()}` };
+        },
+        async sendMedia(ctx) {
+          logger.info(
+            `[lobster:outbound] media to=${ctx.to} url=${ctx.mediaUrl ?? "none"}`
+          );
+          return { ok: true, messageId: `spike-media-${Date.now()}` };
+        }
+      }
+    });
+    api.on("message_sent", (event, ctx) => {
+      logger.info(
+        `[lobster:hook] message_sent ch=${ctx.channelId} to=${event.to} ok=${event.success}`
+      );
+      bridge2?.publish({
+        type: "agent_response",
+        channelId: ctx.channelId,
+        to: event.to,
+        text: event.content ?? "",
+        conversationId: ctx.conversationId
+      });
+    });
+    api.on(
+      "message_received",
+      (event, ctx) => {
+        logger.info(
+          `[lobster:hook] message_received ch=${ctx.channelId} from=${event.from}`
+        );
+        bridge2?.publish({
+          type: "message_received",
+          channelId: ctx.channelId,
+          from: event.from,
+          content: event.content,
+          conversationId: ctx.conversationId,
+          timestamp: event.timestamp
+        });
+      }
+    );
+    api.on("gateway_start", (event, _ctx) => {
+      gatewayPort = event.port;
+      logger.info(`[lobster:hook] gateway started on port ${gatewayPort}`);
+      bridge2?.publish({ type: "gateway_start", port: gatewayPort });
+    });
+    api.registerHttpRoute({
+      path: "/lobster/setup",
+      auth: "plugin",
+      async handler(req, res) {
+        if (req.method !== "GET") {
+          sendText(res, 405, "Method Not Allowed");
+          return;
+        }
+        const query = parseQuery(req);
+        const flow = oauthFlow;
+        const auth = flow ? await flow.loadAuth() : null;
+        sendHtml(
+          res,
+          200,
+          renderSetupPage({
+            connected: !!auth,
+            gatewayPublicId: auth?.gatewayPublicId,
+            channelName: auth?.channelName,
+            bridgeStatus: bridge2?.status ?? "not started",
+            message: query["success"] ? "Connected to Lobster Shell!" : void 0
+          })
+        );
+      }
+    });
+    api.registerHttpRoute({
+      path: "/lobster/connect",
+      auth: "plugin",
+      async handler(req, res) {
+        if (req.method !== "GET") {
+          sendText(res, 405, "Method Not Allowed");
+          return;
+        }
+        if (!oauthFlow) {
+          sendText(res, 500, "Plugin not initialized yet");
+          return;
+        }
+        const host = req.headers.host ?? `localhost:${gatewayPort ?? 18789}`;
+        const proto = req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+        const redirectUri = `${proto}://${host}/lobster/oauth/callback`;
+        try {
+          const authUrl = await oauthFlow.initiateFlow(redirectUri);
+          sendRedirect(res, authUrl);
+        } catch (err) {
+          logger.error(`[lobster:oauth] Failed to initiate flow: ${err}`);
+          sendHtml(
+            res,
+            200,
+            renderSetupPage({
+              connected: false,
+              error: `OAuth initiation failed: ${err instanceof Error ? err.message : String(err)}`
+            })
+          );
+        }
+      }
+    });
+    api.registerHttpRoute({
+      path: "/lobster/oauth/callback",
+      auth: "plugin",
+      async handler(req, res) {
+        if (req.method !== "GET") {
+          sendText(res, 405, "Method Not Allowed");
+          return;
+        }
+        if (!oauthFlow) {
+          sendText(res, 500, "Plugin not initialized yet");
+          return;
+        }
+        const query = parseQuery(req);
+        try {
+          await oauthFlow.handleCallback(query, buildGatewayInfo());
+          if (bridge2 && serviceCtx) {
+            await bridge2.disconnect();
+            await bridge2.connect();
+          }
+          sendRedirect(res, "/lobster/setup?success=1");
+        } catch (err) {
+          logger.error(`[lobster:oauth] Callback failed: ${err}`);
+          sendHtml(
+            res,
+            200,
+            renderSetupPage({
+              connected: false,
+              error: `OAuth callback failed: ${err instanceof Error ? err.message : String(err)}`
+            })
+          );
+        }
+      }
+    });
+    api.registerService({
+      id: `${PLUGIN_ID}-bridge`,
+      async start(ctx) {
+        serviceCtx = ctx;
+        ctx.logger.info("[lobster:bridge] service starting\u2026");
+        ctx.logger.info(`[lobster:bridge] state dir: ${ctx.stateDir}`);
+        oauthFlow = new OAuthFlow({
+          stateDir: ctx.stateDir,
+          cloudUrl,
+          logger: ctx.logger
+        });
+        bridge2 = new CloudBridge({
+          cloudUrl,
+          stateDir: ctx.stateDir,
+          logger: ctx.logger
+        });
+        bridge2.onCommand((cmd) => {
+          if (cmd.type === "ping") {
+            ctx.logger.info("[lobster:bridge] Received ping, publishing heartbeat");
+            bridge2?.publish({ type: "heartbeat", timestamp: Date.now() });
+          } else if (cmd.type === "send_message") {
+            ctx.logger.info(`[lobster:bridge] \u2190 Received send_message from cloud: text="${cmd.text.slice(0, 100)}" sessionKey=${cmd.sessionKey}`);
+            bridge2?.publish({
+              type: "message_received",
+              channelId: "cloud",
+              from: "cloud",
+              content: cmd.text,
+              sessionKey: cmd.sessionKey
+            });
+            if (cmd.sessionKey) {
+              const gatewayKey = `agent:main:${cmd.sessionKey}`;
+              sessionKeyMap.set(gatewayKey, cmd.sessionKey);
+              ctx.logger.info(`[lobster:bridge] sessionKey mapping: ${gatewayKey} \u2192 ${cmd.sessionKey}`);
+            }
+            gatewayWs?.sendMessage(cmd.text, cmd.sessionKey);
+          } else if (cmd.type === "avatar_config") {
+            ctx.logger.info(`[lobster:bridge] Avatar config received: ${cmd.avatarId}`);
+          } else if (cmd.type === "update_settings") {
+            ctx.logger.info("[lobster:bridge] Settings update received");
+          }
+        });
+        await bridge2.connect();
+        const port = gatewayPort ?? 18789;
+        const token = process.env["OPENCLAW_GATEWAY_TOKEN"] ?? "dev-token-1234";
+        gatewayWs = new GatewayWsClient({ port, token, logger: ctx.logger });
+        const thinkingPublished = /* @__PURE__ */ new Set();
+        const sessionContentLen = /* @__PURE__ */ new Map();
+        const sessionKeyMap = /* @__PURE__ */ new Map();
+        gatewayWs.onChat((payload) => {
+          const gatewaySessionKey = payload.sessionKey ?? "__default__";
+          const cloudSessionKey = sessionKeyMap.get(gatewaySessionKey) ?? gatewaySessionKey;
+          if (payload.state === "final" && payload.message?.role === "assistant") {
+            thinkingPublished.delete(gatewaySessionKey);
+            sessionContentLen.delete(gatewaySessionKey);
+            sessionKeyMap.delete(gatewaySessionKey);
+            const raw = payload.message.content;
+            let text;
+            if (typeof raw === "string") {
+              text = raw;
+            } else if (Array.isArray(raw)) {
+              text = raw.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+            } else {
+              text = String(raw ?? "");
+            }
+            ctx.logger.info(`[lobster:ws] \u2713 Agent final response (${text.length} chars, sessionKey=${cloudSessionKey}): "${text.slice(0, 120)}"`);
+            bridge2?.publish({
+              type: "agent_response",
+              channelId: "webchat",
+              to: "cloud",
+              text,
+              runId: payload.runId,
+              sessionKey: cloudSessionKey
+            });
+          } else if (payload.state !== "final" && payload.message?.role === "assistant") {
+            if (!thinkingPublished.has(gatewaySessionKey)) {
+              thinkingPublished.add(gatewaySessionKey);
+              ctx.logger.info(`[lobster:ws] \u25C6 Agent thinking (gatewayKey=${gatewaySessionKey}, cloudKey=${cloudSessionKey})`);
+              bridge2?.publish({
+                type: "agent_thinking",
+                runId: payload.runId,
+                sessionKey: cloudSessionKey
+              });
+            }
+            const rawDelta = payload.message.content;
+            let fullText;
+            if (typeof rawDelta === "string" && rawDelta.length > 0) {
+              fullText = rawDelta;
+            } else if (Array.isArray(rawDelta)) {
+              const joined = rawDelta.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+              if (joined.length > 0) fullText = joined;
+            }
+            if (fullText) {
+              const prevLen = sessionContentLen.get(gatewaySessionKey) ?? 0;
+              const deltaText = fullText.slice(prevLen);
+              sessionContentLen.set(gatewaySessionKey, fullText.length);
+              if (deltaText.length > 0) {
+                ctx.logger.info(`[lobster:ws] \u25C6 Delta (${deltaText.length} new chars, cumulative=${fullText.length}, sessionKey=${cloudSessionKey}): "${deltaText.slice(0, 60)}"`);
+                bridge2?.publish({
+                  type: "agent_response_delta",
+                  text: deltaText,
+                  runId: payload.runId,
+                  sessionKey: cloudSessionKey
+                });
+              }
+            }
+          }
+        });
+        try {
+          await gatewayWs.connect();
+        } catch (err) {
+          ctx.logger.warn(`[lobster:ws] Gateway WS connection failed: ${err}`);
+        }
+        initApiClient(bridge2);
+      },
+      async stop(ctx) {
+        ctx.logger.info("[lobster:bridge] service stopping\u2026");
+        gatewayWs?.disconnect();
+        gatewayWs = null;
+        bridge2?.publish({ type: "gateway_stop" });
+        await bridge2?.disconnect();
+        bridge2 = null;
+        oauthFlow = null;
+        serviceCtx = null;
+      }
+    });
+    api.registerCommand({
+      name: "lobster-status",
+      description: "Show Lobster Shell plugin status",
+      requireAuth: true,
+      handler(_ctx) {
+        const status = {
+          plugin: PLUGIN_ID,
+          version: PLUGIN_VERSION,
+          gatewayPort: gatewayPort ?? "unknown",
+          cloudBridge: bridge2?.status ?? "not started",
+          channel: CHANNEL_ID
+        };
+        return {
+          text: [
+            "**Lobster Shell Status**",
+            `Plugin: ${status.plugin} v${status.version}`,
+            `Gateway: port ${status.gatewayPort}`,
+            `Cloud Bridge: ${status.cloudBridge}`,
+            `Channel: ${status.channel}`
+          ].join("\n")
+        };
+      }
+    });
+    logger.info("Lobster Shell plugin registered successfully");
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};