@2en/clawly-plugins 1.13.0 → 1.14.0

package/index.ts

@@ -33,7 +33,7 @@ import {registerCronHook} from './cron-hook'
 import {registerEmail} from './email'
 import {registerGateway} from './gateway'
 import {getGatewayConfig} from './gateway-fetch'
-import {registerOutboundHook, registerOutboundMethods} from './outbound'
+import {registerOutboundHook, registerOutboundHttpRoute, registerOutboundMethods} from './outbound'
 import {registerTools} from './tools'
 
 type PluginRuntime = {
@@ -92,6 +92,13 @@ export type PluginApi = {
     opts?: {optional?: boolean},
   ) => void
   registerChannel: (registration: {plugin: any}) => void
+  registerHttpRoute: (params: {
+    path: string
+    handler: (
+      req: import('node:http').IncomingMessage,
+      res: import('node:http').ServerResponse,
+    ) => Promise<void> | void
+  }) => void
 }
 
 export default {
@@ -101,6 +108,7 @@ export default {
   register(api: PluginApi) {
     registerOutboundHook(api)
     registerOutboundMethods(api)
+    registerOutboundHttpRoute(api)
     registerCommands(api)
     registerTools(api)
     registerClawlyCronChannel(api)

package/outbound.ts

@@ -8,6 +8,8 @@
 
 import crypto from 'node:crypto'
 import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import type {IncomingMessage, ServerResponse} from 'node:http'
 import os from 'node:os'
 import path from 'node:path'
 
@@ -29,6 +31,15 @@ function ensureOutboundDir(): void {
   fs.mkdirSync(OUTBOUND_DIR, {recursive: true})
 }
 
+async function fileExists(p: string): Promise<boolean> {
+  try {
+    await fsp.access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
 // ── Hook: tool_result_persist ───────────────────────────────────────
 
 export function registerOutboundHook(api: PluginApi) {
@@ -73,16 +84,94 @@ export function registerOutboundMethods(api: PluginApi) {
 
     const dest = outboundFilePath(rawPath)
 
-    if (!fs.existsSync(dest)) {
+    if (!(await fileExists(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 buffer = await fsp.readFile(dest)
     const base64 = buffer.toString('base64')
 
     api.logger.info(`clawly.file.getOutbound: served ${rawPath} (${buffer.length} bytes)`)
     respond(true, {base64})
   })
 }
+
+// ── HTTP route: GET /clawly/file/outbound?path=<original-path> ─────────────
+
+const MIME: Record<string, string> = {
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.m4a': 'audio/mp4',
+  '.aac': 'audio/aac',
+  '.flac': 'audio/flac',
+  '.webm': 'audio/webm',
+}
+
+function sendJson(res: ServerResponse, status: number, body: Record<string, unknown>) {
+  res.writeHead(status, {'Content-Type': 'application/json'})
+  res.end(JSON.stringify(body))
+}
+
+export function registerOutboundHttpRoute(api: PluginApi) {
+  api.registerHttpRoute({
+    path: '/clawly/file/outbound',
+    handler: async (_req: IncomingMessage, res: ServerResponse) => {
+      const url = new URL(_req.url ?? '/', 'http://localhost')
+      const rawPath = url.searchParams.get('path')?.trim() ?? ''
+
+      if (!rawPath) {
+        sendJson(res, 400, {error: 'path query parameter is required'})
+        return
+      }
+
+      const dest = outboundFilePath(rawPath)
+
+      if (!(await fileExists(dest))) {
+        api.logger.warn(`outbound http: file not found: ${rawPath}`)
+        sendJson(res, 404, {error: 'outbound file not found'})
+        return
+      }
+
+      const ext = path.extname(dest).toLowerCase()
+      const contentType = MIME[ext] ?? 'application/octet-stream'
+      const stat = await fsp.stat(dest)
+      const total = stat.size
+      const rangeHeader = _req.headers.range
+
+      if (rangeHeader) {
+        const match = /bytes=(\d+)-(\d*)/.exec(rangeHeader)
+        if (match) {
+          const start = Number(match[1])
+          const end = match[2] ? Number(match[2]) : total - 1
+          const chunkSize = end - start + 1
+          const stream = fs.createReadStream(dest, {start, end})
+
+          res.writeHead(206, {
+            'Content-Type': contentType,
+            'Content-Range': `bytes ${start}-${end}/${total}`,
+            'Accept-Ranges': 'bytes',
+            'Content-Length': chunkSize,
+          })
+          stream.pipe(res)
+          api.logger.info(
+            `outbound http: served ${rawPath} -> ${dest} range ${start}-${end}/${total}`,
+          )
+          return
+        }
+      }
+
+      const buffer = await fsp.readFile(dest)
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': total,
+        'Accept-Ranges': 'bytes',
+      })
+      res.end(buffer)
+
+      api.logger.info(`outbound http: served ${rawPath} -> ${dest} (${total} bytes)`)
+    },
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "module": "index.ts",
   "type": "module",
   "repository": {