@opengate/openclaw 0.1.8 → 0.2.0

package/dist/index.d.ts

@@ -1,94 +1,5 @@
-/**
- * Formats OpenGate events into human-readable messages with MCP tool instructions.
- */
-interface OpenGateEvent {
-    type: string;
-    task_id?: string;
-    task_title?: string;
-    project_id?: string;
-    from_agent?: string;
-    reason?: string;
-    summary?: string;
-    content?: string;
-    priority?: string;
-    tags?: string[];
-    [key: string]: unknown;
-}
-interface Notification {
-    id: string;
-    event_type: string;
-    payload: OpenGateEvent;
-    read: boolean;
-    created_at: string;
-}
-/**
- * Format a single OpenGate event into a readable message for the agent.
- */
-declare function formatEvent(event: OpenGateEvent): string;
-/**
- * Format a list of notifications into a summary message.
- */
-declare function formatNotificationSummary(notifications: Notification[]): string;
+import { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 
-/**
- * HTTP polling client for OpenGate notifications.
- * Polls GET /api/agents/me/notifications?unread=true at a configurable interval.
- */
+declare function register(api: OpenClawPluginApi): void;
 
-interface PollerConfig {
-    url: string;
-    apiKey: string;
-    pollIntervalMs: number;
-    projectId?: string;
-}
-
-/**
- * WebSocket client for OpenGate real-time notifications.
- * Connects to /api/ws, authenticates, and subscribes to agent events.
- * Features auto-reconnect with exponential backoff (1s -> 2s -> 4s -> ... -> max 60s).
- */
-
-interface WsClientConfig {
-    url: string;
-    apiKey: string;
-    projectId?: string;
-}
-
-/**
- * @opengate/openclaw — OpenClaw plugin for OpenGate agent notifications.
- *
- * Provides real-time push notifications from OpenGate to agents via
- * HTTP polling (default) or WebSocket.
- *
- * Registers a service "opengate-bridge" that:
- * - Connects to an OpenGate instance
- * - Listens for agent events (task assignments, comments, unblocks, etc.)
- * - Injects formatted messages into the agent's session via sessions.send()
- */
-interface PluginConfig {
-    url: string;
-    apiKey: string;
-    mode?: "polling" | "websocket";
-    pollIntervalMs?: number;
-    projectId?: string;
-}
-/**
- * OpenClaw Plugin API surface (subset relevant to this plugin).
- * These types represent what OpenClaw provides to plugins.
- */
-interface OpenClawPluginApi {
-    registerService(service: {
-        id: string;
-        start: () => void | Promise<void>;
-        stop: () => void | Promise<void>;
-    }): void;
-    gateway: {
-        rpc(method: string, params: Record<string, unknown>): Promise<unknown>;
-    };
-}
-/**
- * Plugin entry point. Called by OpenClaw when the plugin is loaded.
- */
-declare function register(api: OpenClawPluginApi, config: PluginConfig): void;
-
-export { type Notification, type OpenClawPluginApi, type OpenGateEvent, type PluginConfig, type PollerConfig, type WsClientConfig, register as default, formatEvent, formatNotificationSummary };
+export { register as default };

package/dist/index.js

@@ -1,381 +1,293 @@
-// src/poller.ts
-var Poller = class {
-  config;
-  handler;
-  timer = null;
-  running = false;
-  constructor(config, handler) {
-    this.config = config;
-    this.handler = handler;
+// src/config.ts
+function resolveConfig(raw) {
+  const url = typeof raw.url === "string" ? raw.url.replace(/\/$/, "") : "";
+  const apiKey = typeof raw.apiKey === "string" ? raw.apiKey : "";
+  if (!url) throw new Error("[opengate] plugin config missing: url");
+  if (!apiKey) throw new Error("[opengate] plugin config missing: apiKey");
+  return {
+    url,
+    apiKey,
+    agentId: typeof raw.agentId === "string" ? raw.agentId : "main",
+    model: typeof raw.model === "string" ? raw.model : void 0,
+    pollIntervalMs: typeof raw.pollIntervalMs === "number" ? raw.pollIntervalMs : 3e4,
+    maxConcurrent: typeof raw.maxConcurrent === "number" ? raw.maxConcurrent : 3
+  };
+}
+
+// src/bootstrap.ts
+function buildBootstrapPrompt(task, openGateUrl, apiKey) {
+  const tags = Array.isArray(task.tags) && task.tags.length > 0 ? task.tags.join(", ") : "none";
+  const contextBlock = task.context && Object.keys(task.context).length > 0 ? `
+## Task Context
+\`\`\`json
+${JSON.stringify(task.context, null, 2)}
+\`\`\`
+` : "";
+  return `You are an autonomous coding agent assigned a task via OpenGate.
+
+## Your Task
+**ID:** ${task.id}
+**Title:** ${task.title}
+**Priority:** ${task.priority ?? "medium"}
+**Tags:** ${tags}
+**Project ID:** ${task.project_id ?? "unknown"}
+
+**Description:**
+${task.description ?? "(no description provided)"}
+${contextBlock}
+## OpenGate API
+- **Base URL:** ${openGateUrl}
+- **Auth:** Bearer ${apiKey}
+
+## Protocol \u2014 Follow This Exactly
+You MUST follow these steps in order. Skipping any step is not acceptable.
+
+1. **Claim** \u2014 \`POST /api/tasks/${task.id}/claim\`
+2. **Post starting comment** \u2014 \`POST /api/tasks/${task.id}/activity\` with body: \`{"content": "Starting: <your plan in 1-2 sentences>"}\`
+3. **Do the work** \u2014 read relevant files, write code, run tests, commit to a branch
+4. **Post results comment** \u2014 \`POST /api/tasks/${task.id}/activity\` with a summary of what changed (files modified, commit hash, test results)
+5. **Complete** \u2014 \`POST /api/tasks/${task.id}/complete\` with body: \`{"summary": "<what was done>", "output": {"branch": "...", "commits": [...]}}\`
+
+If you encounter a blocker that requires human input:
+- Post a question: \`POST /api/tasks/${task.id}/activity\` with \`{"content": "BLOCKED: <question>"}\`
+- Block the task: \`POST /api/tasks/${task.id}/block\` with \`{"reason": "<reason>"}\`
+- Then stop \u2014 do NOT mark it complete.
+
+## Notes
+- Always work on a feature branch, never commit directly to main
+- Run tests before completing
+- If you discover something worth remembering (pattern, gotcha, decision), write it to a file in your workspace
+
+Now begin. Start by claiming the task.`;
+}
+
+// src/spawner.ts
+async function spawnTaskSession(taskId, message, pluginCfg, openclawCfg) {
+  const port = openclawCfg?.gateway?.port ?? 18789;
+  const hooksToken = openclawCfg?.hooks?.token;
+  if (!hooksToken) {
+    return {
+      ok: false,
+      error: "[opengate] hooks.token not configured in OpenClaw config. Add hooks.enabled=true and hooks.token=<secret> to enable task spawning."
+    };
   }
-  start() {
-    if (this.running) return;
-    this.running = true;
-    void this.poll();
-    this.timer = setInterval(() => {
-      void this.poll();
-    }, this.config.pollIntervalMs);
+  const sessionKey = `opengate-task:${taskId}`;
+  const agentId = pluginCfg.agentId ?? "main";
+  const payload = {
+    message,
+    agentId,
+    sessionKey,
+    wakeMode: "now",
+    deliver: false,
+    name: "OpenGate"
+  };
+  if (pluginCfg.model) {
+    payload.model = pluginCfg.model;
   }
-  stop() {
-    this.running = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/hooks/agent`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${hooksToken}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (resp.status === 202 || resp.status === 200) {
+      return { ok: true, sessionKey };
     }
+    const body = await resp.text().catch(() => "(no body)");
+    return {
+      ok: false,
+      error: `[opengate] hooks/agent returned HTTP ${resp.status}: ${body}`
+    };
+  } catch (e) {
+    return {
+      ok: false,
+      error: `[opengate] failed to reach hooks/agent: ${e instanceof Error ? e.message : String(e)}`
+    };
   }
-  async poll() {
-    if (!this.running) return;
+}
+
+// src/state.ts
+import fs from "fs";
+import path from "path";
+var TTL_MS = 24 * 60 * 60 * 1e3;
+var TaskState = class {
+  filePath;
+  data;
+  constructor(stateDir) {
+    this.filePath = path.join(stateDir, "opengate-spawned.json");
+    this.data = this.load();
+    this.cleanup();
+  }
+  load() {
     try {
-      const baseUrl = this.config.url.replace(/\/$/, "");
-      const params = new URLSearchParams({ unread: "true" });
-      if (this.config.projectId) {
-        params.set("project_id", this.config.projectId);
-      }
-      const response = await fetch(
-        `${baseUrl}/api/agents/me/notifications?${params.toString()}`,
-        {
-          headers: {
-            Authorization: `Bearer ${this.config.apiKey}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      if (!response.ok) {
-        console.error(
-          `[opengate-bridge] Poll failed: ${response.status} ${response.statusText}`
-        );
-        return;
-      }
-      const notifications = await response.json();
-      if (notifications.length > 0) {
-        this.handler(notifications);
-        await this.acknowledgeNotifications(
-          baseUrl,
-          notifications.map((n) => n.id)
-        );
-      }
-    } catch (err) {
-      console.error(`[opengate-bridge] Poll error:`, err);
+      const raw = fs.readFileSync(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { spawned: {} };
     }
   }
-  async acknowledgeNotifications(baseUrl, ids) {
+  save() {
     try {
-      for (const id of ids) {
-        await fetch(`${baseUrl}/api/agents/me/notifications/${id}/ack`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${this.config.apiKey}`,
-            "Content-Type": "application/json"
-          }
-        });
+      fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+      fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), "utf-8");
+    } catch (e) {
+      console.error("[opengate] failed to save state:", e);
+    }
+  }
+  cleanup() {
+    const cutoff = Date.now() - TTL_MS;
+    let changed = false;
+    for (const [id, entry] of Object.entries(this.data.spawned)) {
+      if (entry.spawnedAt < cutoff) {
+        delete this.data.spawned[id];
+        changed = true;
       }
-    } catch (err) {
-      console.error(`[opengate-bridge] Failed to acknowledge notifications:`, err);
     }
+    if (changed) this.save();
+  }
+  isSpawned(taskId) {
+    return taskId in this.data.spawned;
+  }
+  markSpawned(taskId, sessionKey) {
+    this.data.spawned[taskId] = { taskId, sessionKey, spawnedAt: Date.now() };
+    this.save();
+  }
+  remove(taskId) {
+    delete this.data.spawned[taskId];
+    this.save();
+  }
+  activeCount() {
+    return Object.keys(this.data.spawned).length;
   }
 };
 
-// src/ws-client.ts
-import WebSocket from "ws";
-var INITIAL_BACKOFF_MS = 1e3;
-var MAX_BACKOFF_MS = 6e4;
-var BACKOFF_MULTIPLIER = 2;
-var WsClient = class {
-  config;
-  handler;
-  ws = null;
-  running = false;
-  backoffMs = INITIAL_BACKOFF_MS;
-  reconnectTimer = null;
-  pingTimer = null;
-  constructor(config, handler) {
-    this.config = config;
-    this.handler = handler;
+// src/poller.ts
+async function fetchInbox(url, apiKey) {
+  const resp = await fetch(`${url}/api/agents/me/inbox`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!resp.ok) {
+    throw new Error(`OpenGate inbox returned HTTP ${resp.status}`);
+  }
+  const body = await resp.json();
+  return body.todo ?? [];
+}
+var OpenGatePoller = class {
+  constructor(pluginCfg, openclawCfg, logger, stateDir) {
+    this.pluginCfg = pluginCfg;
+    this.openclawCfg = openclawCfg;
+    this.logger = logger;
+    this.state = new TaskState(stateDir);
   }
+  timer = null;
+  state;
+  running = false;
   start() {
     if (this.running) return;
     this.running = true;
-    this.connect();
+    const intervalMs = this.pluginCfg.pollIntervalMs ?? 3e4;
+    this.logger.info(`[opengate] Starting poller \u2014 interval: ${intervalMs}ms`);
+    void this.poll();
+    this.timer = setInterval(() => void this.poll(), intervalMs);
   }
   stop() {
     this.running = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close(1e3, "Plugin stopped");
-      this.ws = null;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
     }
+    this.logger.info("[opengate] Poller stopped");
   }
-  connect() {
+  async poll() {
     if (!this.running) return;
-    const baseUrl = this.config.url.replace(/\/$/, "").replace(/^http/, "ws");
-    const wsUrl = `${baseUrl}/api/ws`;
+    const maxConcurrent = this.pluginCfg.maxConcurrent ?? 3;
+    const active = this.state.activeCount();
+    if (active >= maxConcurrent) {
+      this.logger.info(
+        `[opengate] At capacity (${active}/${maxConcurrent} active) \u2014 skipping poll`
+      );
+      return;
+    }
+    let tasks;
     try {
-      this.ws = new WebSocket(wsUrl, {
-        headers: {
-          Authorization: `Bearer ${this.config.apiKey}`
-        }
-      });
-      this.ws.on("open", () => {
-        console.log("[opengate-bridge] WebSocket connected");
-        this.backoffMs = INITIAL_BACKOFF_MS;
-        const subscribe = JSON.stringify({
-          type: "subscribe",
-          channels: ["agent.notifications"],
-          project_id: this.config.projectId
-        });
-        this.ws?.send(subscribe);
-        this.pingTimer = setInterval(() => {
-          if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.ping();
-          }
-        }, 3e4);
-      });
-      this.ws.on("message", (data) => {
-        try {
-          const event = JSON.parse(data.toString());
-          if (event.type && event.type !== "pong") {
-            this.handler(event);
-          }
-        } catch {
-          console.error(
-            "[opengate-bridge] Failed to parse WebSocket message"
-          );
-        }
-      });
-      this.ws.on("close", (code, reason) => {
-        console.log(
-          `[opengate-bridge] WebSocket closed: ${code} ${reason.toString()}`
+      tasks = await fetchInbox(this.pluginCfg.url, this.pluginCfg.apiKey);
+    } catch (e) {
+      this.logger.warn(
+        `[opengate] Failed to fetch inbox: ${e instanceof Error ? e.message : String(e)}`
+      );
+      return;
+    }
+    if (tasks.length === 0) return;
+    this.logger.info(`[opengate] Found ${tasks.length} todo task(s)`);
+    for (const task of tasks) {
+      if (!this.running) break;
+      const currentActive = this.state.activeCount();
+      if (currentActive >= maxConcurrent) {
+        this.logger.info(
+          `[opengate] Reached capacity (${currentActive}/${maxConcurrent}) \u2014 deferring remaining tasks`
         );
-        this.cleanup();
-        this.scheduleReconnect();
-      });
-      this.ws.on("error", (err) => {
-        console.error(`[opengate-bridge] WebSocket error:`, err.message);
-        this.cleanup();
-        this.scheduleReconnect();
-      });
-    } catch (err) {
-      console.error(`[opengate-bridge] WebSocket connection failed:`, err);
-      this.scheduleReconnect();
+        break;
+      }
+      if (this.state.isSpawned(task.id)) {
+        this.logger.info(`[opengate] Task ${task.id} already spawned \u2014 skipping`);
+        continue;
+      }
+      await this.spawnTask(task);
     }
   }
-  cleanup() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
+  async spawnTask(task) {
+    this.logger.info(`[opengate] Spawning session for task: "${task.title}" (${task.id})`);
+    const prompt = buildBootstrapPrompt(task, this.pluginCfg.url, this.pluginCfg.apiKey);
+    const result = await spawnTaskSession(
+      task.id,
+      prompt,
+      this.pluginCfg,
+      this.openclawCfg
+    );
+    if (!result.ok) {
+      this.logger.error(result.error);
+      return;
     }
-    this.ws = null;
-  }
-  scheduleReconnect() {
-    if (!this.running) return;
-    if (this.reconnectTimer) return;
-    console.log(
-      `[opengate-bridge] Reconnecting in ${this.backoffMs / 1e3}s...`
+    this.state.markSpawned(task.id, result.sessionKey);
+    this.logger.info(
+      `[opengate] Session spawned for task ${task.id} \u2192 session key: ${result.sessionKey}`
     );
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.backoffMs = Math.min(
-        this.backoffMs * BACKOFF_MULTIPLIER,
-        MAX_BACKOFF_MS
-      );
-      this.connect();
-    }, this.backoffMs);
   }
 };
 
-// src/message-formatter.ts
-function formatEvent(event) {
-  const taskRef = event.task_id ? ` (task: ${event.task_title ?? event.task_id})` : "";
-  switch (event.type) {
-    case "task.assigned":
-      return [
-        `New task assigned to you${taskRef}`,
-        event.priority ? `Priority: ${event.priority}` : null,
-        event.tags?.length ? `Tags: ${event.tags.join(", ")}` : null,
-        event.repo_url ? `Repo: ${event.repo_url}` : null,
-        "",
-        "Next steps:",
-        "1. Use `get_task` to read the full task details",
-        event.project_id ? "2. Use `get_workspace_info` to set up project workspace" : null,
-        "3. Use `search_knowledge` to check for relevant project knowledge",
-        "4. Use `claim_task` to start working on it",
-        "5. Use `post_comment` to share your planned approach"
-      ].filter((line) => line !== null).join("\n");
-    case "task.comment":
-      return [
-        `New comment on task${taskRef}`,
-        event.from_agent ? `From: ${event.from_agent}` : null,
-        event.content ? `> ${event.content}` : null,
-        "",
-        "Use `get_task` to see the full task context."
-      ].filter((line) => line !== null).join("\n");
-    case "task.dependency_ready":
-      return [
-        `Dependency resolved for task${taskRef}`,
-        "A blocking dependency has been completed. This task may now be ready to claim.",
-        "",
-        "Next steps:",
-        "1. Use `get_task` to review the task",
-        "2. Use `list_dependencies` to verify all dependencies are met",
-        "3. Use `claim_task` to start working if ready"
-      ].join("\n");
-    case "task.review_requested":
-      return [
-        `Review requested for task${taskRef}`,
-        event.from_agent ? `From: ${event.from_agent}` : null,
-        event.summary ? `Summary: ${event.summary}` : null,
-        "",
-        "Next steps:",
-        "1. Use `get_task` to review the task and its output",
-        "2. Approve with `approve_task` or request changes with `request_changes`"
-      ].filter((line) => line !== null).join("\n");
-    case "task.handoff":
-      return [
-        `Task handed off to you${taskRef}`,
-        event.from_agent ? `From: ${event.from_agent}` : null,
-        event.summary ? `Context: ${event.summary}` : null,
-        "",
-        "Next steps:",
-        "1. Use `get_task` to read the full task and handoff context",
-        "2. Use `claim_task` to accept the handoff",
-        "3. Use `post_comment` to acknowledge and share your plan"
-      ].filter((line) => line !== null).join("\n");
-    case "task.unblocked":
-      return [
-        `Task unblocked${taskRef}`,
-        event.reason ? `Reason: ${event.reason}` : null,
-        "",
-        "The task has been unblocked and moved back to your queue.",
-        "Use `get_task` to review and continue working on it."
-      ].filter((line) => line !== null).join("\n");
-    case "task.changes_requested":
-      return [
-        `Changes requested on task${taskRef}`,
-        event.from_agent ? `From: ${event.from_agent}` : null,
-        event.content ? `Feedback: ${event.content}` : null,
-        "",
-        "Next steps:",
-        "1. Use `get_task` to read the review feedback",
-        "2. Address the requested changes",
-        "3. Use `complete_task` to resubmit when ready"
-      ].filter((line) => line !== null).join("\n");
-    default:
-      return [
-        `OpenGate event: ${event.type}${taskRef}`,
-        event.summary ?? event.content ?? "",
-        "",
-        "Use `check_inbox` to see your current task queue."
-      ].filter((line) => line !== "").join("\n");
-  }
-}
-function formatNotificationSummary(notifications) {
-  if (notifications.length === 0) {
-    return "";
-  }
-  const lines = [
-    `You have ${notifications.length} unread notification${notifications.length === 1 ? "" : "s"} from OpenGate:`,
-    ""
-  ];
-  for (const notification of notifications) {
-    const formatted = formatEvent(notification.payload);
-    lines.push(`--- ${notification.event_type} ---`);
-    lines.push(formatted);
-    lines.push("");
-  }
-  lines.push(
-    "Use `check_inbox` for a full overview of your task queue."
-  );
-  return lines.join("\n");
-}
-
 // src/index.ts
-var PKG_VERSION = "0.1.8";
-async function checkForUpdate() {
-  try {
-    const res = await fetch("https://registry.npmjs.org/@opengate/openclaw/latest", {
-      headers: { "Accept": "application/json" },
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!res.ok) return;
-    const data = await res.json();
-    const latest = data.version;
-    if (latest && latest !== PKG_VERSION) {
-      console.log(`[opengate-bridge] Update available: ${PKG_VERSION} \u2192 ${latest}. Run: openclaw plugins update`);
-    }
-  } catch {
-  }
-}
-var DEFAULT_POLL_INTERVAL_MS = 6e5;
-var SESSION_KEY = "main";
-function register(api, config) {
-  const mode = config.mode ?? "polling";
-  const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+function register(api) {
   let poller = null;
-  let wsClient = null;
-  function sendMessage(message) {
-    if (!message) return;
-    void api.gateway.rpc("sessions.send", {
-      sessionKey: SESSION_KEY,
-      message
-    });
-  }
-  function handleNotifications(notifications) {
-    const summary = formatNotificationSummary(notifications);
-    sendMessage(summary);
+  let pluginCfg;
+  try {
+    pluginCfg = resolveConfig(api.pluginConfig ?? {});
+  } catch (e) {
+    api.logger.error(e instanceof Error ? e.message : String(e));
+    return;
   }
-  function handleWsEvent(event) {
-    const message = formatEvent(event);
-    sendMessage(message);
+  const hooksToken = api.config?.hooks?.token;
+  if (!hooksToken) {
+    api.logger.error(
+      '[opengate] hooks.token is not configured. Add the following to your OpenClaw config to enable task spawning:\n  "hooks": { "enabled": true, "token": "<your-secret>", "allowRequestSessionKey": true, "allowedSessionKeyPrefixes": ["opengate-task:"] }'
+    );
+    return;
   }
   api.registerService({
-    id: "opengate-bridge",
-    start() {
-      console.log(
-        `[opengate-bridge] Starting in ${mode} mode (url: ${config.url})`
-      );
-      checkForUpdate().catch(() => {
-      });
-      if (mode === "websocket") {
-        wsClient = new WsClient(
-          {
-            url: config.url,
-            apiKey: config.apiKey,
-            projectId: config.projectId
-          },
-          handleWsEvent
-        );
-        wsClient.start();
-      } else {
-        poller = new Poller(
-          {
-            url: config.url,
-            apiKey: config.apiKey,
-            pollIntervalMs,
-            projectId: config.projectId
-          },
-          handleNotifications
-        );
-        poller.start();
-      }
+    id: "opengate-poller",
+    start(ctx) {
+      poller = new OpenGatePoller(pluginCfg, api.config, ctx.logger, ctx.stateDir);
+      poller.start();
     },
-    stop() {
-      console.log("[opengate-bridge] Stopping");
+    stop(ctx) {
       poller?.stop();
-      wsClient?.stop();
       poller = null;
-      wsClient = null;
     }
   });
 }
 export {
-  register as default,
-  formatEvent,
-  formatNotificationSummary
+  register as default
 };

package/openclaw.plugin.json

@@ -1,46 +1,46 @@
 {
   "id": "opengate",
   "name": "OpenGate",
-  "description": "Real-time push notifications from OpenGate to agents via HTTP polling or WebSocket",
-  "version": "0.1.8",
+  "description": "Polls OpenGate for assigned tasks and spawns isolated OpenClaw sessions to execute them. Turns OpenGate into the orchestrator.",
+  "version": "0.2.0",
+  "skills": ["./skills/opengate"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
+    "required": ["url", "apiKey"],
     "properties": {
       "url": {
         "type": "string",
-        "description": "OpenGate server URL",
-        "default": "https://opengate.sh"
+        "description": "OpenGate base URL (e.g. https://opengate.sh)"
       },
       "apiKey": {
         "type": "string",
-        "description": "Agent API key (tf_... format)"
+        "description": "Agent API key for OpenGate"
       },
-      "mode": {
+      "agentId": {
         "type": "string",
-        "description": "Notification mode: 'polling' (default) or 'websocket'",
-        "enum": [
-          "polling",
-          "websocket"
-        ],
-        "default": "polling"
+        "description": "OpenClaw agent ID to spawn sessions as (default: 'main')"
+      },
+      "model": {
+        "type": "string",
+        "description": "Model override for spawned task sessions (e.g. anthropic/claude-sonnet-4-6)"
       },
       "pollIntervalMs": {
         "type": "number",
-        "description": "Polling interval in milliseconds (only used in polling mode)",
-        "default": 600000
+        "description": "How often to poll OpenGate for tasks in milliseconds (default: 30000)"
       },
-      "projectId": {
-        "type": "string",
-        "description": "Optional project ID to filter notifications"
+      "maxConcurrent": {
+        "type": "number",
+        "description": "Max concurrent task sessions (default: 3)"
       }
-    },
-    "required": [
-      "url",
-      "apiKey"
-    ]
+    }
   },
-  "skills": [
-    "skills/opengate"
-  ]
+  "uiHints": {
+    "url": { "label": "OpenGate URL", "placeholder": "https://opengate.sh" },
+    "apiKey": { "label": "Agent API Key", "sensitive": true },
+    "agentId": { "label": "OpenClaw Agent ID", "placeholder": "main" },
+    "model": { "label": "Model Override", "placeholder": "anthropic/claude-sonnet-4-6" },
+    "pollIntervalMs": { "label": "Poll Interval (ms)", "advanced": true },
+    "maxConcurrent": { "label": "Max Concurrent Tasks", "advanced": true }
+  }
 }

package/package.json

@@ -1,22 +1,19 @@
 {
   "name": "@opengate/openclaw",
-  "version": "0.1.8",
-  "description": "OpenClaw plugin for OpenGate \u2014 real-time agent notifications via HTTP polling or WebSocket",
+  "version": "0.2.0",
+  "description": "OpenGate task executor plugin for OpenClaw — polls assigned tasks and spawns isolated agent sessions",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts --format esm --dts --watch"
-  },
-  "dependencies": {
-    "ws": "^8.18.0"
+    "build": "tsup src/index.ts --format esm --dts --external openclaw",
+    "dev": "tsup src/index.ts --format esm --dts --external openclaw --watch"
   },
+  "dependencies": {},
   "devDependencies": {
     "tsup": "^8.4.0",
     "typescript": "^5.7.0",
-    "@types/node": "^22.0.0",
-    "@types/ws": "^8.5.0"
+    "@types/node": "^22.0.0"
   },
   "files": [
     "dist",