@2en/clawly-plugins 1.4.0 → 1.4.1

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/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/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

@@ -1,5 +1,5 @@
 /**
- * OpenClaw plugin: Clawly utility RPC methods (clawly.*), memory browser, and ClawHub CLI bridge.
+ * OpenClaw plugin: Clawly utility RPC methods (clawly.*).
  *
  * Gateway methods:
  * - clawly.file.getOutbound — read a persisted outbound file by original-path hash
@@ -8,9 +8,6 @@
  * - clawly.notification.send    — send a push notification directly
  * - clawly.agent.send        — send a message to the agent (+ optional push)
  * - clawly.agent.echo        — echo-wrapped agent message (bypasses LLM)
- * - memory-browser.list      — list all .md files in the memory directory
- * - memory-browser.get       — return content of a single .md file
- * - clawhub2gateway.*        — ClawHub CLI RPC bridge (search/install/update/list/explore/inspect/star/unstar)
  *
  * Agent tools:
  * - clawly_is_user_online    — check if user's device is connected
@@ -25,29 +22,18 @@
  */
 
 import {registerAgentSend} from './agent-send'
+import {registerCalendar} from './calendar'
 import {registerIsUserOnlineTool, registerSendAppPushTool} from './tools'
 import {registerClawlyCronChannel} from './channel'
-import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerCronHook} from './cron-hook'
 import {registerEchoCommand} from './echo'
-import {registerMemoryBrowser} from './memory'
+import {registerEmail} from './email'
+import {getGatewayConfig} from './gateway-fetch'
 import {registerNotification} from './notification'
 import {registerOutboundHook, registerOutboundMethods} from './outbound'
 import {registerPresence} from './presence'
 
 type PluginRuntime = {
-  system?: {
-    runCommandWithTimeout?: (
-      argv: string[],
-      opts: {timeoutMs: number; cwd?: string; env?: Record<string, string | undefined>},
-    ) => Promise<{
-      stdout: string
-      stderr: string
-      code: number | null
-      signal: string | null
-      killed: boolean
-    }>
-  }
   state?: {
     resolveStateDir?: (env?: NodeJS.ProcessEnv) => string
   }
@@ -108,8 +94,14 @@ export default {
     registerSendAppPushTool(api)
     registerClawlyCronChannel(api)
     registerCronHook(api)
-    registerMemoryBrowser(api)
-    registerClawhub2gateway(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

@@ -1,51 +1,14 @@
 {
   "id": "clawly-plugins",
   "name": "Clawly Plugins",
-  "description": "Clawly utility RPC methods (clawly.*): file access, presence, push notifications, agent messaging, memory browser, and ClawHub CLI bridge.",
+  "description": "Clawly utility RPC methods (clawly.*): file access, presence, push notifications, and agent messaging.",
   "version": "0.2.0",
-  "uiHints": {
-    "memoryDir": {
-      "label": "Memory directory",
-      "help": "Absolute path to the memory directory containing .md files. Defaults to <OPENCLAW_WORKSPACE>/memory.",
-      "placeholder": "/data/memory"
-    },
-    "bin": {
-      "label": "clawhub binary",
-      "help": "Command to run (must be in PATH on the gateway host).",
-      "placeholder": "clawhub"
-    },
-    "defaultDir": {
-      "label": "Default skills dir",
-      "help": "Maps to `clawhub --dir` when not provided per-call.",
-      "placeholder": "skills"
-    },
-    "defaultNoInput": {
-      "label": "Default no-input",
-      "help": "If true, adds `--no-input` unless the tool call overrides it.",
-      "advanced": true
-    },
-    "defaultTimeoutMs": {
-      "label": "Default timeout (ms)",
-      "help": "Default command timeout for most tool calls.",
-      "advanced": true
-    },
-    "configPath": {
-      "label": "CLAWHUB_CONFIG_PATH",
-      "help": "Where the ClawHub CLI stores auth/config. Defaults to `<OPENCLAW_STATE_DIR>/clawhub/config.json`.",
-      "advanced": true,
-      "placeholder": "~/.openclaw/clawhub/config.json"
-    }
-  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "memoryDir": { "type": "string", "minLength": 1 },
-      "bin": { "type": "string", "minLength": 1 },
-      "defaultDir": { "type": "string", "minLength": 1 },
-      "defaultNoInput": { "type": "boolean" },
-      "defaultTimeoutMs": { "type": "number", "minimum": 1000 },
-      "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.4.1",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -14,10 +14,11 @@
   "files": [
     "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",

package/clawhub2gateway.ts

@@ -1,405 +0,0 @@
-/**
- * ClawHub CLI RPC bridge — expose ClawHub CLI commands as Gateway RPC methods.
- *
- * Gateway methods:
- * - clawhub2gateway.search
- * - clawhub2gateway.install
- * - clawhub2gateway.update
- * - clawhub2gateway.list
- * - clawhub2gateway.explore
- * - clawhub2gateway.inspect
- * - clawhub2gateway.star
- * - clawhub2gateway.unstar
- *
- * Notes:
- * - This plugin shells out to the `clawhub` CLI. Install it on the gateway host:
- *   `npm i -g clawhub` (or ensure it is in PATH).
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import type {PluginApi} from './index'
-
-type JsonSchema = Record<string, unknown>
-
-function isRecord(v: unknown): v is Record<string, unknown> {
-  return Boolean(v && typeof v === 'object' && !Array.isArray(v))
-}
-
-function readBool(params: Record<string, unknown>, key: string): boolean | undefined {
-  return typeof params[key] === 'boolean' ? (params[key] as boolean) : undefined
-}
-
-function readString(params: Record<string, unknown>, key: string): string | undefined {
-  const v = params[key]
-  if (typeof v !== 'string') return undefined
-  const t = v.trim()
-  return t ? t : undefined
-}
-
-function readNumber(params: Record<string, unknown>, key: string): number | undefined {
-  const v = params[key]
-  if (typeof v === 'number' && Number.isFinite(v)) return v
-  if (typeof v === 'string' && v.trim()) {
-    const n = Number(v.trim())
-    if (Number.isFinite(n)) return n
-  }
-  return undefined
-}
-
-function coercePluginConfig(api: PluginApi): Record<string, unknown> {
-  return isRecord(api.pluginConfig) ? api.pluginConfig : {}
-}
-
-function configString(
-  cfg: Record<string, unknown>,
-  key: string,
-  fallback?: string,
-): string | undefined {
-  const v = cfg[key]
-  if (typeof v === 'string' && v.trim()) return v.trim()
-  return fallback
-}
-
-function configBool(cfg: Record<string, unknown>, key: string, fallback: boolean): boolean {
-  const v = cfg[key]
-  if (typeof v === 'boolean') return v
-  return fallback
-}
-
-function configNumber(cfg: Record<string, unknown>, key: string, fallback: number): number {
-  const v = cfg[key]
-  if (typeof v === 'number' && Number.isFinite(v)) return v
-  return fallback
-}
-
-async function ensureDir(dirPath: string): Promise<void> {
-  await fs.mkdir(dirPath, {recursive: true})
-}
-
-function buildGlobalCliArgs(
-  params: Record<string, unknown>,
-  defaults: {dir: string; noInput: boolean},
-) {
-  const out: string[] = []
-
-  const workdir = readString(params, 'workdir')
-  const dir = readString(params, 'dir') ?? defaults.dir
-  const site = readString(params, 'site')
-  const registry = readString(params, 'registry')
-  const noInput = readBool(params, 'noInput') ?? defaults.noInput
-
-  if (workdir) out.push('--workdir', workdir)
-  if (dir) out.push('--dir', dir)
-  if (site) out.push('--site', site)
-  if (registry) out.push('--registry', registry)
-  if (noInput) out.push('--no-input')
-
-  return out
-}
-
-async function runClawhubCommand(opts: {
-  api: PluginApi
-  argv: string[]
-  cwd?: string
-  timeoutMs: number
-  env?: Record<string, string | undefined>
-}) {
-  const runner = opts.api.runtime.system?.runCommandWithTimeout
-  if (!runner) {
-    throw new Error('Plugin runtime missing system.runCommandWithTimeout')
-  }
-  const result = await runner(opts.argv, {timeoutMs: opts.timeoutMs, cwd: opts.cwd, env: opts.env})
-  return result
-}
-
-function joinOutput(stdout: string, stderr: string): string {
-  const s1 = (stdout ?? '').trimEnd()
-  const s2 = (stderr ?? '').trimEnd()
-  if (s1 && s2) return `${s1}\n\n${s2}`
-  return s1 || s2 || ''
-}
-
-function baseToolParamsSchema(extra?: JsonSchema): JsonSchema {
-  return {
-    type: 'object',
-    additionalProperties: false,
-    properties: {
-      workdir: {type: 'string', description: 'Working directory (ClawHub --workdir)'},
-      dir: {type: 'string', description: 'Skills directory relative to workdir (ClawHub --dir)'},
-      site: {type: 'string', description: 'ClawHub site URL (ClawHub --site)'},
-      registry: {type: 'string', description: 'ClawHub registry API URL (ClawHub --registry)'},
-      noInput: {type: 'boolean', description: 'Disable prompts (ClawHub --no-input)'},
-      timeoutMs: {type: 'number', description: 'Command timeout in milliseconds'},
-      ...(extra ?? {}),
-    },
-  }
-}
-
-export function registerClawhub2gateway(api: PluginApi) {
-  const cfg = coercePluginConfig(api)
-  const bin = configString(cfg, 'bin', 'clawhub') ?? 'clawhub'
-  const defaultDir = configString(cfg, 'defaultDir', 'skills') ?? 'skills'
-  const defaultNoInput = configBool(cfg, 'defaultNoInput', true)
-  const defaultTimeoutMs = configNumber(cfg, 'defaultTimeoutMs', 60_000)
-  const configPath = configString(cfg, 'configPath')
-
-  const stateDir =
-    api.runtime.state?.resolveStateDir?.(process.env) ??
-    process.env.OPENCLAW_STATE_DIR ??
-    process.env.CLAWDBOT_STATE_DIR ??
-    ''
-  const defaultConfigPath = stateDir ? path.join(stateDir, 'clawhub', 'config.json') : ''
-
-  const resolveEnv = async (): Promise<Record<string, string | undefined>> => {
-    const env: Record<string, string | undefined> = {}
-    const resolved = configPath ?? defaultConfigPath
-    if (resolved) {
-      await ensureDir(path.dirname(resolved))
-      env.CLAWHUB_CONFIG_PATH = resolved
-    }
-    return env
-  }
-
-  const registerRpc = (rpc: {
-    method: string
-    description: string
-    parameters: JsonSchema
-    buildCli: (
-      params: Record<string, unknown>,
-    ) => Promise<{argv: string[]; cwd?: string; timeoutMs?: number}>
-  }) => {
-    api.registerGatewayMethod(rpc.method, async ({params, respond}) => {
-      try {
-        const timeoutMs = Math.max(
-          1_000,
-          Math.floor(readNumber(params, 'timeoutMs') ?? defaultTimeoutMs),
-        )
-        const built = await rpc.buildCli(params)
-        const env = await resolveEnv()
-        const res = await runClawhubCommand({
-          api,
-          argv: built.argv,
-          cwd: built.cwd,
-          timeoutMs: built.timeoutMs ?? timeoutMs,
-          env,
-        })
-        const output = joinOutput(res.stdout, res.stderr)
-        if (res.code && res.code !== 0) {
-          respond(false, undefined, {
-            code: 'command_failed',
-            message: output || `clawhub exited with code ${res.code}`,
-          })
-          return
-        }
-        respond(true, {
-          ok: true,
-          output,
-          stdout: res.stdout,
-          stderr: res.stderr,
-          code: res.code,
-          signal: res.signal,
-          killed: res.killed,
-          argv: built.argv,
-          cwd: built.cwd,
-        })
-      } catch (err) {
-        respond(false, undefined, {
-          code: 'error',
-          message: err instanceof Error ? err.message : String(err),
-        })
-      }
-    })
-  }
-
-  // -----------------------------
-  // Search
-  // -----------------------------
-
-  registerRpc({
-    method: 'clawhub2gateway.search',
-    description: 'ClawHub CLI: search skills.',
-    parameters: baseToolParamsSchema({
-      query: {type: 'string', description: 'Search query'},
-      limit: {type: 'number', description: 'Max results (clawhub search --limit)'},
-    }),
-    async buildCli(params) {
-      const query = readString(params, 'query')
-      if (!query) throw new Error('query required')
-      const limit = readNumber(params, 'limit')
-      const globalArgs = buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput})
-      const argv = [bin, 'search', query, ...globalArgs]
-      if (limit !== undefined) argv.push('--limit', String(Math.max(1, Math.floor(limit))))
-      return {argv}
-    },
-  })
-
-  registerRpc({
-    method: 'clawhub2gateway.explore',
-    description: 'ClawHub CLI: explore skills.!',
-    parameters: baseToolParamsSchema({
-      limit: {type: 'number', description: 'Max results (clawhub explore --limit, if supported)'},
-      sort: {
-        type: 'string',
-        enum: ['newest', 'downloads', 'rating', 'installs', 'installsAllTime', 'trending'],
-        description:
-          'Sort order (clawhub explore --sort). One of newest, downloads, rating, installs, installsAllTime, trending.',
-      },
-      json: {type: 'boolean', description: 'Output JSON'},
-    }),
-    async buildCli(params) {
-      const limit = readNumber(params, 'limit')
-      const sort = readString(params, 'sort')
-      const json = readBool(params, 'json') ?? false
-      const globalArgs = buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput})
-      const argv = [bin, 'explore', ...globalArgs]
-      if (limit !== undefined) argv.push('--limit', String(Math.max(1, Math.floor(limit))))
-      if (sort) argv.push('--sort', sort)
-      if (json) argv.push('--json')
-      return {argv}
-    },
-  })
-
-  // -----------------------------
-  // Install / Update / List
-  // -----------------------------
-
-  registerRpc({
-    method: 'clawhub2gateway.install',
-    description: 'ClawHub CLI: install a skill into the workspace skills dir.',
-    parameters: baseToolParamsSchema({
-      slug: {type: 'string', description: 'Skill slug to install'},
-      version: {type: 'string', description: 'Specific version to install'},
-      force: {
-        type: 'boolean',
-        description: 'Overwrite if folder exists (clawhub install --force)',
-      },
-    }),
-    async buildCli(params) {
-      const slug = readString(params, 'slug')
-      if (!slug) throw new Error('slug required')
-      const version = readString(params, 'version')
-      const force = readBool(params, 'force') ?? false
-      const globalArgs = buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput})
-      const argv = [bin, 'install', slug, ...globalArgs]
-      if (version) argv.push('--version', version)
-      if (force) argv.push('--force')
-      return {argv}
-    },
-  })
-
-  registerRpc({
-    method: 'clawhub2gateway.update',
-    description: 'ClawHub CLI: update one skill or all installed skills.',
-    parameters: baseToolParamsSchema({
-      slug: {type: 'string', description: 'Skill slug to update (omit when all=true)'},
-      all: {type: 'boolean', description: 'Update all skills (clawhub update --all)'},
-      version: {type: 'string', description: 'Update to a specific version (single slug only)'},
-      force: {
-        type: 'boolean',
-        description: 'Overwrite when local files do not match any published version',
-      },
-    }),
-    async buildCli(params) {
-      const all = readBool(params, 'all') ?? false
-      const slug = readString(params, 'slug')
-      const version = readString(params, 'version')
-      const force = readBool(params, 'force') ?? false
-      const globalArgs = buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput})
-
-      const argv = [bin, 'update', ...globalArgs]
-      if (all) {
-        argv.push('--all')
-      } else {
-        if (!slug) throw new Error('slug required when all=false')
-        argv.push(slug)
-        if (version) argv.push('--version', version)
-      }
-      if (force) argv.push('--force')
-      return {argv}
-    },
-  })
-
-  registerRpc({
-    method: 'clawhub2gateway.list',
-    description: 'ClawHub CLI: list installed skills from .clawhub/lock.json.',
-    parameters: baseToolParamsSchema(),
-    async buildCli(params) {
-      const argv = [
-        bin,
-        'list',
-        ...buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput}),
-      ]
-      return {argv}
-    },
-  })
-
-  // -----------------------------
-  // Inspect / Star
-  // -----------------------------
-
-  registerRpc({
-    method: 'clawhub2gateway.inspect',
-    description: 'ClawHub CLI: inspect a skill without installing.',
-    parameters: baseToolParamsSchema({
-      slug: {type: 'string', description: 'Skill slug'},
-    }),
-    async buildCli(params) {
-      const slug = readString(params, 'slug')
-      if (!slug) throw new Error('slug required')
-      const globalArgs = buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput})
-
-      const argv = [bin, 'inspect', slug, ...globalArgs]
-      return {argv}
-    },
-  })
-
-  registerRpc({
-    method: 'clawhub2gateway.star',
-    description: 'ClawHub CLI: star a skill.',
-    parameters: baseToolParamsSchema({
-      slug: {type: 'string', description: 'Skill slug'},
-    }),
-    async buildCli(params) {
-      const slug = readString(params, 'slug')
-      if (!slug) throw new Error('slug required')
-      const argv = [
-        bin,
-        'star',
-        slug,
-        ...buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput}),
-      ]
-      return {argv}
-    },
-  })
-
-  registerRpc({
-    method: 'clawhub2gateway.unstar',
-    description: 'ClawHub CLI: unstar a skill.',
-    parameters: baseToolParamsSchema({
-      slug: {type: 'string', description: 'Skill slug'},
-    }),
-    async buildCli(params) {
-      const slug = readString(params, 'slug')
-      if (!slug) throw new Error('slug required')
-      const argv = [
-        bin,
-        'unstar',
-        slug,
-        ...buildGlobalCliArgs(params, {dir: defaultDir, noInput: defaultNoInput}),
-      ]
-      return {argv}
-    },
-  })
-
-  api.logger.info(
-    [
-      `clawhub2gateway: registered.`,
-      `Using clawhub bin: ${bin}`,
-      defaultConfigPath
-        ? `CLI config: ${configPath ?? defaultConfigPath}`
-        : 'CLI config: (not set)',
-    ].join(' '),
-  )
-}

package/memory.ts

@@ -1,187 +0,0 @@
-/**
- * Memory directory browser — expose memory directory .md files as Gateway RPC methods.
- *
- * Gateway methods:
- * - memory-browser.list — list all .md files in the OpenClaw memory directory
- * - memory-browser.get — return the content of a single .md file by path
- */
-
-import fs from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-
-import type {PluginApi} from './index'
-
-function isRecord(v: unknown): v is Record<string, unknown> {
-  return Boolean(v && typeof v === 'object' && !Array.isArray(v))
-}
-
-function configString(
-  cfg: Record<string, unknown>,
-  key: string,
-  fallback?: string,
-): string | undefined {
-  const v = cfg[key]
-  if (typeof v === 'string' && v.trim()) return v.trim()
-  return fallback
-}
-
-function readString(params: Record<string, unknown>, key: string): string | undefined {
-  const v = params[key]
-  if (typeof v !== 'string') return undefined
-  const t = v.trim()
-  return t ? t : undefined
-}
-
-function coercePluginConfig(api: PluginApi): Record<string, unknown> {
-  return isRecord(api.pluginConfig) ? api.pluginConfig : {}
-}
-
-/** Resolve the memory directory path. Memory lives under workspace (agents.defaults.workspace). */
-function resolveMemoryDir(api: PluginApi, profile?: string): string {
-  const cfg = coercePluginConfig(api)
-  const configPath = configString(cfg, 'memoryDir')
-  if (configPath) return configPath
-
-  const baseDir =
-    process.env.OPENCLAW_WORKSPACE ?? path.join(os.homedir(), '.openclaw', 'workspace')
-  // Profile-aware: "main" or empty → default workspace, otherwise workspace-<profile>
-  if (profile && profile !== 'main') {
-    const parentDir = path.dirname(baseDir)
-    const baseName = path.basename(baseDir)
-    return path.join(parentDir, `${baseName}-${profile}`, 'memory')
-  }
-  return path.join(baseDir, 'memory')
-}
-
-/** Check that a relative path is safe (no directory traversal). */
-function isSafeRelativePath(relativePath: string): boolean {
-  if (!relativePath || relativePath.startsWith('/') || relativePath.includes('\\')) {
-    return false
-  }
-  const normalized = path.normalize(relativePath)
-  if (normalized.startsWith('..') || normalized.includes('..')) {
-    return false
-  }
-  return true
-}
-
-/** Recursively collect all .md file paths under dir, relative to baseDir. */
-async function collectMdFiles(dir: string, baseDir: string, acc: string[] = []): Promise<string[]> {
-  let entries: fs.Dirent[]
-  try {
-    entries = await fs.readdir(dir, {withFileTypes: true})
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return acc
-    throw err
-  }
-
-  for (const e of entries) {
-    const full = path.join(dir, e.name)
-    const rel = path.relative(baseDir, full)
-
-    if (e.isDirectory()) {
-      await collectMdFiles(full, baseDir, acc)
-    } else if (e.isFile() && e.name.toLowerCase().endsWith('.md')) {
-      acc.push(rel)
-    }
-  }
-  return acc
-}
-
-export function registerMemoryBrowser(api: PluginApi) {
-  const memoryDir = resolveMemoryDir(api)
-  api.logger.info(`memory-browser: memory directory: ${memoryDir}`)
-
-  // -----------------------------
-  // memory-browser.list
-  // -----------------------------
-  api.registerGatewayMethod('memory-browser.list', async ({params, respond}) => {
-    try {
-      const profile = readString(params, 'profile')
-      const dir = profile ? resolveMemoryDir(api, profile) : memoryDir
-      const files = await collectMdFiles(dir, dir)
-      api.logger.info(`memory-browser.list: ${files.length} files found`)
-      files.sort()
-      respond(true, {files})
-    } catch (err) {
-      api.logger.error(
-        `memory-browser.list failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-      respond(false, undefined, {
-        code: 'error',
-        message: err instanceof Error ? err.message : String(err),
-      })
-    }
-  })
-
-  // -----------------------------
-  // memory-browser.get
-  // -----------------------------
-  api.registerGatewayMethod('memory-browser.get', async ({params, respond}) => {
-    const relativePath = readString(params, 'path')
-    const profile = readString(params, 'profile')
-    const dir = profile ? resolveMemoryDir(api, profile) : memoryDir
-    if (!relativePath) {
-      respond(false, undefined, {
-        code: 'invalid_params',
-        message: 'path (relative path to .md file) is required',
-      })
-      return
-    }
-    if (!isSafeRelativePath(relativePath)) {
-      respond(false, undefined, {
-        code: 'invalid_params',
-        message: 'path must be a safe relative path (no directory traversal)',
-      })
-      return
-    }
-    if (!relativePath.toLowerCase().endsWith('.md')) {
-      respond(false, undefined, {
-        code: 'invalid_params',
-        message: 'path must point to a .md file',
-      })
-      return
-    }
-
-    const fullPath = path.join(dir, path.normalize(relativePath))
-    const realMemory = await fs.realpath(dir).catch(() => dir)
-    const realResolved = await fs.realpath(fullPath).catch(() => null)
-
-    if (!realResolved) {
-      respond(false, undefined, {
-        code: 'not_found',
-        message: 'file not found',
-      })
-      return
-    }
-    const rel = path.relative(realMemory, realResolved)
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      respond(false, undefined, {
-        code: 'not_found',
-        message: 'file not found or outside memory directory',
-      })
-      return
-    }
-
-    try {
-      const content = await fs.readFile(fullPath, 'utf-8')
-      respond(true, {path: relativePath, content})
-    } catch (err) {
-      const code = (err as NodeJS.ErrnoException).code
-      if (code === 'ENOENT') {
-        respond(false, undefined, {code: 'not_found', message: 'file not found'})
-        return
-      }
-      api.logger.error(
-        `memory-browser.get failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-      respond(false, undefined, {
-        code: 'error',
-        message: err instanceof Error ? err.message : String(err),
-      })
-    }
-  })
-
-  api.logger.info(`memory-browser: registered (dir: ${memoryDir})`)
-}