@2en/clawly-plugins 0.1.0 → 1.0.0

package/index.ts

@@ -2,10 +2,13 @@
  * OpenClaw plugin: Clawly utility RPC methods (clawly.*).
  *
  * Gateway methods:
- * - clawly.file.get — read a local file and return base64-encoded content
+ * - clawly.file.getOutbound — read a persisted outbound file by original-path hash
+ *
+ * Hooks:
+ * - tool_result_persist — copies TTS audio to persistent outbound directory
  */
 
-import {registerFileMethods} from './file'
+import {registerOutboundHook, registerOutboundMethods} from './outbound'
 
 type PluginRuntime = {
   state?: {
@@ -30,6 +33,7 @@ export type PluginApi = {
       respond: (ok: boolean, payload?: unknown, error?: {code?: string; message?: string}) => void
     }) => Promise<void> | void,
   ) => void
+  on: (hookName: string, handler: (...args: any[]) => any, opts?: {priority?: number}) => void
 }
 
 export default {
@@ -37,7 +41,8 @@ export default {
   name: 'Clawly Plugins',
   description: 'Clawly utility RPC methods (clawly.*).',
   register(api: PluginApi) {
-    registerFileMethods(api)
+    registerOutboundHook(api)
+    registerOutboundMethods(api)
     api.logger.info(`Loaded ${api.id} plugin.`)
   },
 }

package/outbound.ts

@@ -0,0 +1,103 @@
+/**
+ * TTS outbound persistence — copies ephemeral TTS audio to a persistent directory
+ * so mobile can fetch it after the temp files are cleaned up.
+ *
+ * Hook:   tool_result_persist → copies TTS audioPath to ~/.openclaw/clawly/outbound/<hash>.<ext>
+ * Method: clawly.file.getOutbound → reads outbound file by original-path hash
+ */
+
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+import type {PluginApi} from './index'
+
+const OUTBOUND_DIR = path.join(os.homedir(), '.openclaw', 'clawly', 'outbound')
+
+function hashPath(filePath: string): string {
+  return crypto.createHash('sha256').update(filePath).digest('hex')
+}
+
+function outboundFilePath(originalPath: string): string {
+  const hash = hashPath(originalPath)
+  const ext = path.extname(originalPath) // e.g. ".mp3"
+  return path.join(OUTBOUND_DIR, `${hash}${ext}`)
+}
+
+function ensureOutboundDir(): void {
+  fs.mkdirSync(OUTBOUND_DIR, {recursive: true})
+}
+
+// ── Hook: tool_result_persist ───────────────────────────────────────
+
+export function registerOutboundHook(api: PluginApi) {
+  api.on(
+    'tool_result_persist',
+    (event: {toolName?: string; message?: {details?: {audioPath?: string}}}) => {
+      if (event.toolName !== 'tts') return
+      const audioPath = event.message?.details?.audioPath
+      if (!audioPath) return
+
+      try {
+        const dest = outboundFilePath(audioPath)
+        if (fs.existsSync(dest)) return // idempotent
+
+        if (!fs.existsSync(audioPath)) {
+          api.logger.warn(`outbound: source file missing, skipping copy: ${audioPath}`)
+          return
+        }
+
+        ensureOutboundDir()
+        fs.copyFileSync(audioPath, dest)
+        api.logger.info(`outbound: persisted ${audioPath} → ${dest}`)
+      } catch (err) {
+        api.logger.error(
+          `outbound: failed to persist ${audioPath}: ${err instanceof Error ? err.message : String(err)}`,
+        )
+      }
+    },
+  )
+}
+
+// ── Gateway method: clawly.file.getOutbound ─────────────────────────
+
+export function registerOutboundMethods(api: PluginApi) {
+  api.registerGatewayMethod('clawly.file.getOutbound', async ({params, respond}) => {
+    const rawPath = typeof params.path === 'string' ? params.path.trim() : ''
+
+    if (!rawPath) {
+      respond(false, undefined, {code: 'invalid_params', message: 'path is required'})
+      return
+    }
+
+    const dest = outboundFilePath(rawPath)
+
+    if (!fs.existsSync(dest)) {
+      api.logger.warn(`outbound: file not found: ${rawPath} ${dest}`)
+      respond(false, undefined, {code: 'not_found', message: 'outbound file not found'})
+      return
+    }
+
+    const buffer = fs.readFileSync(dest)
+
+    const EXT_MIME: Record<string, string> = {
+      '.mp3': 'audio/mpeg',
+      '.wav': 'audio/wav',
+      '.m4a': 'audio/mp4',
+      '.ogg': 'audio/ogg',
+      '.aac': 'audio/aac',
+      '.flac': 'audio/flac',
+      '.webm': 'audio/webm',
+    }
+    const mimeType = EXT_MIME[path.extname(dest).toLowerCase()] ?? 'application/octet-stream'
+
+    const base64 = buffer.toString('base64')
+    const filename = path.basename(rawPath)
+
+    api.logger.info(
+      `clawly.file.getOutbound: served ${filename} (${mimeType}, ${buffer.length} bytes)`,
+    )
+    respond(true, {base64, mimeType, filename})
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -10,12 +10,9 @@
   },
   "files": [
     "index.ts",
-    "file.ts",
+    "outbound.ts",
     "openclaw.plugin.json"
   ],
-  "dependencies": {
-    "file-type": "^19.6.0"
-  },
   "openclaw": {
     "extensions": [
       "./index.ts"

package/file.ts

@@ -1,161 +0,0 @@
-/**
- * clawly.file.get — read a file from the local filesystem and return it as base64.
- *
- * Validates: absolute path, no traversal, MIME whitelist, 50 MB size limit.
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import {fileTypeFromBuffer} from 'file-type'
-
-import type {PluginApi} from './index'
-
-const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50 MB
-
-const ALLOWED_MIME_PREFIXES = ['image/', 'video/', 'audio/']
-
-/** Extensions allowed via fallback when file-type cannot detect MIME (e.g. plain text). */
-const DOCUMENT_EXT_WHITELIST = new Set([
-  'pdf',
-  'doc',
-  'docx',
-  'xls',
-  'xlsx',
-  'ppt',
-  'pptx',
-  'txt',
-  'csv',
-  'rtf',
-])
-
-const EXT_TO_MIME: Record<string, string> = {
-  pdf: 'application/pdf',
-  doc: 'application/msword',
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  xls: 'application/vnd.ms-excel',
-  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  ppt: 'application/vnd.ms-powerpoint',
-  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  txt: 'text/plain',
-  csv: 'text/csv',
-  rtf: 'application/rtf',
-}
-
-function getExtension(filePath: string): string {
-  const dot = filePath.lastIndexOf('.')
-  return dot === -1 ? '' : filePath.slice(dot + 1).toLowerCase()
-}
-
-function getFilename(filePath: string): string {
-  return path.basename(filePath)
-}
-
-export function registerFileMethods(api: PluginApi) {
-  api.registerGatewayMethod('clawly.file.get', async ({params, respond}) => {
-    const rawPath = typeof params.path === 'string' ? params.path.trim() : ''
-
-    // ── Validate path ──────────────────────────────────────────────
-    if (!rawPath) {
-      respond(false, undefined, {code: 'invalid_params', message: 'path is required'})
-      return
-    }
-
-    if (!path.isAbsolute(rawPath)) {
-      respond(false, undefined, {code: 'invalid_params', message: 'path must be absolute'})
-      return
-    }
-
-    const normalized = path.normalize(rawPath)
-
-    // Resolve symlinks and verify the real path matches the normalized expectation
-    let realPath: string
-    try {
-      realPath = await fs.realpath(normalized)
-    } 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(
-        `clawly.file.get realpath failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-      respond(false, undefined, {code: 'error', message: 'failed to resolve path'})
-      return
-    }
-
-    // ── Size check ─────────────────────────────────────────────────
-    let stat: Awaited<ReturnType<typeof fs.stat>>
-    try {
-      stat = await fs.stat(realPath)
-    } 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(
-        `clawly.file.get stat failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-      respond(false, undefined, {code: 'error', message: 'failed to stat file'})
-      return
-    }
-
-    if (!stat.isFile()) {
-      respond(false, undefined, {code: 'invalid_params', message: 'path is not a regular file'})
-      return
-    }
-
-    if (stat.size > MAX_FILE_SIZE) {
-      respond(false, undefined, {
-        code: 'file_too_large',
-        message: `file exceeds ${MAX_FILE_SIZE / 1024 / 1024} MB limit`,
-      })
-      return
-    }
-
-    // ── Read file ──────────────────────────────────────────────────
-    let buffer: Buffer
-    try {
-      buffer = await fs.readFile(realPath)
-    } catch (err) {
-      api.logger.error(
-        `clawly.file.get readFile failed: ${err instanceof Error ? err.message : String(err)}`,
-      )
-      respond(false, undefined, {code: 'error', message: 'failed to read file'})
-      return
-    }
-
-    // ── MIME detection ─────────────────────────────────────────────
-    let mimeType: string | undefined
-
-    const detected = await fileTypeFromBuffer(buffer)
-    if (detected) {
-      mimeType = detected.mime
-    }
-
-    // Check against allowed MIME prefixes
-    if (mimeType && ALLOWED_MIME_PREFIXES.some((prefix) => mimeType!.startsWith(prefix))) {
-      // Allowed media type
-    } else {
-      // Fallback: check document extension whitelist
-      const ext = getExtension(realPath)
-      if (DOCUMENT_EXT_WHITELIST.has(ext)) {
-        mimeType = EXT_TO_MIME[ext] ?? 'application/octet-stream'
-      } else {
-        respond(false, undefined, {
-          code: 'unsupported_type',
-          message: `file type not allowed: ${mimeType ?? `unknown (ext: .${ext || '?'})`}`,
-        })
-        return
-      }
-    }
-
-    // ── Respond ────────────────────────────────────────────────────
-    const base64 = buffer.toString('base64')
-    const filename = getFilename(realPath)
-
-    api.logger.info(`clawly.file.get: served ${filename} (${mimeType}, ${buffer.length} bytes)`)
-    respond(true, {base64, mimeType, filename})
-  })
-}