@2en/clawly-plugins 1.4.0 → 1.5.0

package/calendar.ts

@@ -0,0 +1,257 @@
+/**
+ * Calendar integration via Clawly backend.
+ *
+ * Gateway methods (external RPC):
+ * - calendar.listCalendars — list available calendars
+ * - calendar.listEvents    — list events in a time range
+ * - calendar.createEvent   — create a new calendar event
+ *
+ * Agent tools (LLM-callable):
+ * - calendar_list_calendars — list available calendars
+ * - calendar_list_events    — list events in a time range
+ * - calendar_create_event   — create a new calendar event
+ */
+
+import type {PluginApi} from './index'
+import type {GatewayCfg, HandlerResult} from './gateway-fetch'
+import {gatewayFetch, toToolResult} from './gateway-fetch'
+
+// ── Handlers ──
+
+async function handleListCalendars(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const qs = typeof params.provider === 'string' ? `?provider=${params.provider}` : ''
+  const res = await gatewayFetch(cfg, `/calendar/calendars${qs}`)
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+async function handleListEvents(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const calendarId = typeof params.calendarId === 'string' ? params.calendarId : ''
+  const start =
+    typeof params.start === 'number'
+      ? params.start
+      : typeof params.start === 'string'
+        ? Number(params.start)
+        : 0
+  const end =
+    typeof params.end === 'number'
+      ? params.end
+      : typeof params.end === 'string'
+        ? Number(params.end)
+        : 0
+
+  if (!calendarId || !start || !end)
+    return {
+      ok: false,
+      error: {code: 'invalid_params', message: 'calendarId, start, and end are required'},
+    }
+
+  const qs = new URLSearchParams({calendar_id: calendarId, start: String(start), end: String(end)})
+  if (typeof params.provider === 'string') qs.set('provider', params.provider)
+
+  const res = await gatewayFetch(cfg, `/calendar/events?${qs.toString()}`)
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+async function handleCreateEvent(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const calendarId = typeof params.calendarId === 'string' ? params.calendarId : ''
+  const title = typeof params.title === 'string' ? params.title : ''
+  const startTime = typeof params.startTime === 'number' ? params.startTime : 0
+  const endTime = typeof params.endTime === 'number' ? params.endTime : 0
+
+  if (!calendarId || !title || !startTime || !endTime)
+    return {
+      ok: false,
+      error: {
+        code: 'invalid_params',
+        message: 'calendarId, title, startTime, and endTime are required',
+      },
+    }
+
+  const res = await gatewayFetch(cfg, '/calendar/events', {
+    method: 'POST',
+    body: JSON.stringify({
+      calendarId,
+      title,
+      startTime,
+      endTime,
+      description: typeof params.description === 'string' ? params.description : undefined,
+      location: typeof params.location === 'string' ? params.location : undefined,
+      participants: Array.isArray(params.participants) ? params.participants : undefined,
+      provider: typeof params.provider === 'string' ? params.provider : undefined,
+    }),
+  })
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+// ── Registration ──
+
+export function registerCalendar(api: PluginApi, cfg: GatewayCfg) {
+  // Gateway methods (external RPC)
+
+  api.registerGatewayMethod('calendar.listCalendars', async ({params, respond}) => {
+    try {
+      const r = await handleListCalendars(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  api.registerGatewayMethod('calendar.listEvents', async ({params, respond}) => {
+    try {
+      const r = await handleListEvents(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  api.registerGatewayMethod('calendar.createEvent', async ({params, respond}) => {
+    try {
+      const r = await handleCreateEvent(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  // Agent tools (LLM-callable)
+
+  api.registerTool({
+    name: 'calendar_list_calendars',
+    description:
+      'List available calendars for the connected account. ' +
+      'If no calendar account is connected, the result will contain a CONNECTION_REQUIRED error.',
+    parameters: {
+      type: 'object',
+      properties: {
+        provider: {type: 'string', description: 'Calendar provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleListCalendars(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.registerTool({
+    name: 'calendar_list_events',
+    description: 'List calendar events in a time range.',
+    parameters: {
+      type: 'object',
+      required: ['calendarId', 'start', 'end'],
+      properties: {
+        calendarId: {type: 'string', description: 'Calendar ID (from calendar_list_calendars)'},
+        start: {type: 'number', description: 'Start time as Unix timestamp (seconds)'},
+        end: {type: 'number', description: 'End time as Unix timestamp (seconds)'},
+        provider: {type: 'string', description: 'Calendar provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleListEvents(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.registerTool({
+    name: 'calendar_create_event',
+    description: 'Create a new calendar event.',
+    parameters: {
+      type: 'object',
+      required: ['calendarId', 'title', 'startTime', 'endTime'],
+      properties: {
+        calendarId: {type: 'string', description: 'Calendar ID (from calendar_list_calendars)'},
+        title: {type: 'string', description: 'Event title'},
+        startTime: {type: 'number', description: 'Start time as Unix timestamp (seconds)'},
+        endTime: {type: 'number', description: 'End time as Unix timestamp (seconds)'},
+        description: {type: 'string', description: 'Event description'},
+        location: {type: 'string', description: 'Event location'},
+        participants: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {name: {type: 'string'}, email: {type: 'string'}},
+            required: ['email'],
+          },
+          description: 'Event participants',
+        },
+        provider: {type: 'string', description: 'Calendar provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleCreateEvent(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.logger.info(
+    'calendar: registered gateway methods (calendar.listCalendars, calendar.listEvents, calendar.createEvent) ' +
+      'and agent tools (calendar_list_calendars, calendar_list_events, calendar_create_event)',
+  )
+}

package/channel.ts

@@ -9,8 +9,8 @@
 
 import {$} from 'zx'
 import type {PluginApi} from './index'
-import {sendPushNotification} from './notification'
-import {isClientOnline} from './presence'
+import {sendPushNotification} from './gateway/notification'
+import {isClientOnline} from './gateway/presence'
 
 $.verbose = false
 

package/{echo.ts → command/clawly_echo.ts}

@@ -3,7 +3,7 @@
  * invoking the LLM.
  */
 
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 
 export function registerEchoCommand(api: PluginApi) {
   api.registerCommand({

package/command/index.ts

@@ -0,0 +1,6 @@
+import type {PluginApi} from '../index'
+import {registerEchoCommand} from './clawly_echo'
+
+export function registerCommands(api: PluginApi) {
+  registerEchoCommand(api)
+}

package/email.ts

@@ -0,0 +1,313 @@
+/**
+ * Email integration via Clawly backend.
+ *
+ * Gateway methods (external RPC):
+ * - email.search       — search/list email messages
+ * - email.read         — read a single email message
+ * - email.send         — send an email
+ * - email.getConnectUrl — get OAuth URL to connect an email account
+ *
+ * Agent tools (LLM-callable):
+ * - email_search       — search/list email messages
+ * - email_read         — read a single email message by ID
+ * - email_send         — send an email
+ * - email_connect      — get OAuth URL to connect an email account
+ */
+
+import type {PluginApi} from './index'
+import type {GatewayCfg, HandlerResult} from './gateway-fetch'
+import {gatewayFetch, toToolResult} from './gateway-fetch'
+
+// ── Handlers ──
+
+async function handleSearch(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const qs = new URLSearchParams()
+  if (typeof params.query === 'string') qs.set('query', params.query)
+  if (typeof params.from === 'string') qs.set('from', params.from)
+  if (typeof params.to === 'string') qs.set('to', params.to)
+  if (typeof params.folder === 'string') qs.set('in', params.folder)
+  if (typeof params.limit === 'number') qs.set('limit', String(params.limit))
+  if (typeof params.provider === 'string') qs.set('provider', params.provider)
+
+  const res = await gatewayFetch(cfg, `/email/messages?${qs.toString()}`)
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+async function handleRead(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const id = typeof params.id === 'string' ? params.id : ''
+  if (!id) return {ok: false, error: {code: 'invalid_params', message: 'id is required'}}
+
+  const qs = typeof params.provider === 'string' ? `?provider=${params.provider}` : ''
+  const res = await gatewayFetch(cfg, `/email/messages/${encodeURIComponent(id)}${qs}`)
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+async function handleSend(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const to = Array.isArray(params.to)
+    ? params.to
+    : typeof params.to === 'string'
+      ? [{email: params.to}]
+      : []
+  const subject = typeof params.subject === 'string' ? params.subject : ''
+  const body = typeof params.body === 'string' ? params.body : ''
+
+  if (!to.length || !subject || !body)
+    return {
+      ok: false,
+      error: {code: 'invalid_params', message: 'to, subject, and body are required'},
+    }
+
+  const res = await gatewayFetch(cfg, '/email/messages/send', {
+    method: 'POST',
+    body: JSON.stringify({
+      to,
+      subject,
+      body,
+      replyToMessageId:
+        typeof params.replyToMessageId === 'string' ? params.replyToMessageId : undefined,
+      provider: typeof params.provider === 'string' ? params.provider : undefined,
+    }),
+  })
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+async function handleGetConnectUrl(
+  cfg: GatewayCfg,
+  params: Record<string, unknown>,
+): Promise<HandlerResult> {
+  const provider = typeof params.provider === 'string' ? params.provider : undefined
+  const res = await gatewayFetch(cfg, '/connections/start', {
+    method: 'POST',
+    body: JSON.stringify({provider}),
+  })
+  const data = await res.json()
+  if (!res.ok)
+    return {
+      ok: false,
+      error: {code: data.error ?? 'error', message: data.message ?? res.statusText},
+    }
+  return {ok: true, data}
+}
+
+// ── Registration ──
+
+export function registerEmail(api: PluginApi, cfg: GatewayCfg) {
+  // Gateway methods (external RPC)
+
+  api.registerGatewayMethod('email.search', async ({params, respond}) => {
+    try {
+      const r = await handleSearch(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  api.registerGatewayMethod('email.read', async ({params, respond}) => {
+    try {
+      const r = await handleRead(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  api.registerGatewayMethod('email.send', async ({params, respond}) => {
+    try {
+      const r = await handleSend(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  api.registerGatewayMethod('email.getConnectUrl', async ({params, respond}) => {
+    try {
+      const r = await handleGetConnectUrl(cfg, params)
+      r.ok ? respond(true, r.data) : respond(false, undefined, r.error)
+    } catch (err) {
+      respond(false, undefined, {
+        code: 'error',
+        message: err instanceof Error ? err.message : String(err),
+      })
+    }
+  })
+
+  // Agent tools (LLM-callable)
+
+  api.registerTool({
+    name: 'email_search',
+    description:
+      'Search or list email messages. Returns a list of email messages matching the query. ' +
+      'If no email account is connected, the result will contain a CONNECTION_REQUIRED error ' +
+      'with available providers — use email_connect to get an OAuth URL.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: {type: 'string', description: 'Search query (e.g. "from:alice subject:meeting")'},
+        from: {type: 'string', description: 'Filter by sender email'},
+        to: {type: 'string', description: 'Filter by recipient email'},
+        folder: {type: 'string', description: 'Folder name (e.g. INBOX, SENT)'},
+        limit: {type: 'number', description: 'Max results (default 10)'},
+        provider: {type: 'string', description: 'Email provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleSearch(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.registerTool({
+    name: 'email_read',
+    description: 'Read a single email message by ID. Returns full message content including body.',
+    parameters: {
+      type: 'object',
+      required: ['id'],
+      properties: {
+        id: {type: 'string', description: 'Message ID'},
+        provider: {type: 'string', description: 'Email provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleRead(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.registerTool({
+    name: 'email_send',
+    description: 'Send an email. Requires a connected email account.',
+    parameters: {
+      type: 'object',
+      required: ['to', 'subject', 'body'],
+      properties: {
+        to: {
+          oneOf: [
+            {type: 'string', description: 'Recipient email address'},
+            {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {name: {type: 'string'}, email: {type: 'string'}},
+                required: ['email'],
+              },
+            },
+          ],
+          description: 'Recipient(s) — single email string or array of {name?, email}',
+        },
+        subject: {type: 'string', description: 'Email subject'},
+        body: {type: 'string', description: 'Email body (plain text or HTML)'},
+        replyToMessageId: {type: 'string', description: 'Message ID to reply to'},
+        provider: {type: 'string', description: 'Email provider: google or microsoft'},
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleSend(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.registerTool({
+    name: 'email_connect',
+    description:
+      'Get an OAuth URL to connect an email account (Gmail or Outlook). ' +
+      'Returns an authorizeUrl that the user should open in a browser to authorize access. ' +
+      'Use this when email operations return CONNECTION_REQUIRED.',
+    parameters: {
+      type: 'object',
+      properties: {
+        provider: {
+          type: 'string',
+          enum: ['google', 'microsoft'],
+          description: 'Email provider to connect (google for Gmail, microsoft for Outlook)',
+        },
+      },
+    },
+    async execute(_toolCallId, params) {
+      try {
+        return toToolResult(await handleGetConnectUrl(cfg, params))
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({error: err instanceof Error ? err.message : String(err)}),
+            },
+          ],
+        }
+      }
+    },
+  })
+
+  api.logger.info(
+    'email: registered gateway methods (email.search, email.read, email.send, email.getConnectUrl) ' +
+      'and agent tools (email_search, email_read, email_send, email_connect)',
+  )
+}

package/{agent-send.ts → gateway/agent.ts}

@@ -9,7 +9,7 @@
  */
 
 import {$} from 'zx'
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 import {sendPushNotification} from './notification'
 import {isClientOnline} from './presence'
 

package/gateway/clawhub2gateway.md

@@ -0,0 +1,68 @@
+# clawhub2gateway
+
+OpenClaw plugin that wraps the **ClawHub CLI** as **Gateway WebSocket RPC methods**.
+
+## What you get
+
+Gateway methods (call via WS RPC):
+
+- `clawhub2gateway.search`
+- `clawhub2gateway.explore`
+- `clawhub2gateway.install`
+- `clawhub2gateway.update`
+- `clawhub2gateway.list`
+- `clawhub2gateway.inspect`
+- `clawhub2gateway.star`
+- `clawhub2gateway.unstar`
+
+## Install on a gateway host
+
+1) Install the ClawHub CLI (must be on PATH for the OpenClaw process):
+
+```bash
+npm i -g clawhub
+```
+
+2) Put this plugin on the gateway host and make it discoverable. Common options:
+
+- **Workspace plugin**: copy this folder to `<workspace>/.openclaw/extensions/clawhub2gateway/`
+  with `index.ts` + `openclaw.plugin.json`
+- **Config path**: set `plugins.load.paths` to the plugin folder path
+
+3) Enable the plugin in your `openclaw.json`:
+
+```json5
+{
+  "plugins": {
+    "enabled": true,
+    "entries": {
+      "clawhub2gateway": { "enabled": true, "config": {} }
+    }
+  }
+}
+```
+
+## Plugin config
+
+Configured under `plugins.entries.clawhub2gateway.config`:
+
+- `bin` (string, default: `"clawhub"`): command to execute
+- `defaultDir` (string, default: `"skills"`): default `--dir`
+- `defaultNoInput` (boolean, default: `true`): default `--no-input`
+- `defaultTimeoutMs` (number, default: `60000`)
+- `configPath` (string, optional): sets `CLAWHUB_CONFIG_PATH`. Defaults to
+  `<OPENCLAW_STATE_DIR>/clawhub/config.json` when state dir is known.
+
+## Call examples (RPC params)
+
+Install:
+
+```json
+{ "method": "clawhub2gateway.install", "params": { "slug": "my-skill-pack" } }
+```
+
+Explore:
+
+```json
+{ "method": "clawhub2gateway.explore", "params": { "limit": 50, "sort": "trending", "json": true } }
+```

package/{clawhub2gateway.ts → gateway/clawhub2gateway.ts}

@@ -19,7 +19,7 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 
 type JsonSchema = Record<string, unknown>
 

package/gateway/index.ts

@@ -0,0 +1,14 @@
+import type {PluginApi} from '../index'
+import {registerAgentSend} from './agent'
+import {registerClawhub2gateway} from './clawhub2gateway'
+import {registerMemoryBrowser} from './memory'
+import {registerNotification} from './notification'
+import {registerPresence} from './presence'
+
+export function registerGateway(api: PluginApi) {
+  registerPresence(api)
+  registerNotification(api)
+  registerAgentSend(api)
+  registerMemoryBrowser(api)
+  registerClawhub2gateway(api)
+}

package/gateway/memory-browser.md

@@ -0,0 +1,55 @@
+# memory-browser
+
+OpenClaw plugin that exposes the **memory directory** (all `.md` files) as **Gateway WebSocket RPC methods**.
+
+## What you get
+
+Gateway methods (call via WS RPC):
+
+- **`memory-browser.list`** — List all `.md` files in the memory directory (recursive). Returns `{ files: string[] }` (relative paths).
+- **`memory-browser.get`** — Return the content of a single `.md` file. Params: `{ path: string }` (relative path, e.g. `"notes/foo.md"`). Returns `{ path: string, content: string }`.
+
+## Memory directory
+
+The memory directory is resolved in this order:
+
+1. Plugin config `memoryDir` (absolute path)
+2. `<OPENCLAW_STATE_DIR>/memory` (or `<CLAWDBOT_STATE_DIR>/memory`)
+3. `<process.cwd()>/memory`
+
+## Install on a gateway host
+
+1. Put this plugin on the gateway host and make it discoverable, e.g.:
+   - Workspace: `<workspace>/.openclaw/extensions/memory-browser/` with `index.ts` + `openclaw.plugin.json`
+   - Or set `plugins.load.paths` to the plugin folder
+
+2. Enable the plugin in `openclaw.json`:
+
+```json5
+{
+  "plugins": {
+    "enabled": true,
+    "entries": {
+      "memory-browser": { "enabled": true, "config": {} }
+    }
+  }
+}
+```
+
+Optional config: `config.memoryDir` to override the memory directory path.
+
+## Call examples (RPC params)
+
+List all `.md` files:
+
+```json
+{ "method": "memory-browser.list", "params": {} }
+```
+
+Get one file:
+
+```json
+{ "method": "memory-browser.get", "params": { "path": "notes/meeting-2024.md" } }
+```
+
+`path` must be a relative path to a `.md` file inside the memory directory; directory traversal (`..`) is rejected.

package/{memory.ts → gateway/memory.ts}

@@ -10,7 +10,7 @@ import fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 
 function isRecord(v: unknown): v is Record<string, unknown> {
   return Boolean(v && typeof v === 'object' && !Array.isArray(v))

package/{notification.ts → gateway/notification.ts}

@@ -13,7 +13,7 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 
 const TOKEN_DIR = path.join(os.homedir(), '.openclaw', 'clawly')
 const TOKEN_FILE = path.join(TOKEN_DIR, 'expo-push-token.json')

package/{presence.ts → gateway/presence.ts}

@@ -7,7 +7,7 @@
 
 import {$} from 'zx'
 
-import type {PluginApi} from './index'
+import type {PluginApi} from '../index'
 
 $.verbose = false
 

package/gateway-fetch.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared helpers for plugins that proxy to the Clawly model-gateway backend.
+ */
+
+import type {PluginApi} from './index'
+
+export type GatewayCfg = {baseUrl: string; token: string}
+
+export type HandlerResult = {ok: boolean; data?: unknown; error?: {code: string; message: string}}
+
+export function getGatewayConfig(api: PluginApi): GatewayCfg {
+  const cfg = api.pluginConfig && typeof api.pluginConfig === 'object' ? api.pluginConfig : {}
+  const baseUrl =
+    typeof (cfg as Record<string, unknown>).gatewayBaseUrl === 'string'
+      ? ((cfg as Record<string, unknown>).gatewayBaseUrl as string).replace(/\/$/, '')
+      : ''
+  const token =
+    typeof (cfg as Record<string, unknown>).gatewayToken === 'string'
+      ? ((cfg as Record<string, unknown>).gatewayToken as string)
+      : ''
+  return {baseUrl, token}
+}
+
+export async function gatewayFetch(
+  cfg: GatewayCfg,
+  path: string,
+  init?: RequestInit,
+): Promise<Response> {
+  return fetch(`${cfg.baseUrl}${path}`, {
+    ...init,
+    headers: {
+      ...(init?.headers ?? {}),
+      Authorization: `Bearer ${cfg.token}`,
+      'Content-Type': 'application/json',
+    },
+  })
+}
+
+export function toToolResult(result: HandlerResult) {
+  return {content: [{type: 'text', text: JSON.stringify(result.ok ? result.data : result.error)}]}
+}

package/index.ts

@@ -24,16 +24,15 @@
  * - before_tool_call      — enforces delivery fields on cron.create
  */
 
-import {registerAgentSend} from './agent-send'
-import {registerIsUserOnlineTool, registerSendAppPushTool} from './tools'
+import {registerCalendar} from './calendar'
 import {registerClawlyCronChannel} from './channel'
-import {registerClawhub2gateway} from './clawhub2gateway'
+import {registerCommands} from './command'
 import {registerCronHook} from './cron-hook'
-import {registerEchoCommand} from './echo'
-import {registerMemoryBrowser} from './memory'
-import {registerNotification} from './notification'
+import {registerEmail} from './email'
+import {registerGateway} from './gateway'
+import {getGatewayConfig} from './gateway-fetch'
 import {registerOutboundHook, registerOutboundMethods} from './outbound'
-import {registerPresence} from './presence'
+import {registerTools} from './tools'
 
 type PluginRuntime = {
   system?: {
@@ -100,16 +99,19 @@ export default {
   register(api: PluginApi) {
     registerOutboundHook(api)
     registerOutboundMethods(api)
-    registerEchoCommand(api)
-    registerPresence(api)
-    registerNotification(api)
-    registerAgentSend(api)
-    registerIsUserOnlineTool(api)
-    registerSendAppPushTool(api)
+    registerCommands(api)
+    registerTools(api)
     registerClawlyCronChannel(api)
     registerCronHook(api)
-    registerMemoryBrowser(api)
-    registerClawhub2gateway(api)
+    registerGateway(api)
+
+    // Email & calendar (optional — requires gatewayBaseUrl + gatewayToken in config)
+    const gw = getGatewayConfig(api)
+    if (gw.baseUrl && gw.token) {
+      registerEmail(api, gw)
+      registerCalendar(api, gw)
+    }
+
     api.logger.info(`Loaded ${api.id} plugin.`)
   },
 }

package/openclaw.plugin.json

@@ -45,7 +45,9 @@
       "defaultDir": { "type": "string", "minLength": 1 },
       "defaultNoInput": { "type": "boolean" },
       "defaultTimeoutMs": { "type": "number", "minimum": 1000 },
-      "configPath": { "type": "string" }
+      "configPath": { "type": "string" },
+      "gatewayBaseUrl": { "type": "string" },
+      "gatewayToken": { "type": "string" }
     },
     "required": []
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -12,18 +12,16 @@
     "zx": "npm:zx@8.8.5-lite"
   },
   "files": [
+    "command",
+    "gateway",
     "tools",
     "index.ts",
+    "calendar.ts",
     "channel.ts",
-    "clawhub2gateway.ts",
     "cron-hook.ts",
-    "memory.ts",
+    "email.ts",
+    "gateway-fetch.ts",
     "outbound.ts",
-    "echo.ts",
-    "presence.ts",
-    "notification.ts",
-    "agent-send.ts",
-    "tools.ts",
     "openclaw.plugin.json"
   ],
   "publishConfig": {

package/tools/clawly-is-user-online.ts

@@ -5,7 +5,7 @@
  */
 
 import type {PluginApi} from '../index'
-import {isClientOnline} from '../presence'
+import {isClientOnline} from '../gateway/presence'
 
 const TOOL_NAME = 'clawly_is_user_online'
 

package/tools/clawly-send-app-push.ts

@@ -7,7 +7,7 @@
  */
 
 import type {PluginApi} from '../index'
-import {sendPushNotification} from '../notification'
+import {sendPushNotification} from '../gateway/notification'
 
 const TOOL_NAME = 'clawly_send_app_push'
 

package/tools/index.ts

@@ -0,0 +1,8 @@
+import type {PluginApi} from '../index'
+import {registerIsUserOnlineTool} from './clawly-is-user-online'
+import {registerSendAppPushTool} from './clawly-send-app-push'
+
+export function registerTools(api: PluginApi) {
+  registerIsUserOnlineTool(api)
+  registerSendAppPushTool(api)
+}

package/tools.ts

@@ -1,2 +0,0 @@
-export {registerIsUserOnlineTool} from './tools/clawly-is-user-online'
-export {registerSendAppPushTool} from './tools/clawly-send-app-push'