@borgee/agents-host 0.2.94 → 0.2.101

package/dist/gateway/channel-file-workspace.js

@@ -0,0 +1,130 @@
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+export const CHANNEL_FILE_WORKING_COPY_DIRECTORY = '.borgee/channel-files';
+export const CHANNEL_FILE_TRANSFER_MAX_BYTES = 10 * 1024 * 1024;
+export class ChannelFileWorkspaceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ChannelFileWorkspaceError';
+    }
+}
+export function validatePortableRelativePath(path) {
+    if (path.length === 0
+        || isAbsolute(path)
+        || path.includes('\\')
+        || path.includes('\0')
+        || path.split('/').some((part) => part === '' || part === '.' || part === '..' || /[\u0000-\u001f\u007f]/u.test(part))
+        || /^[A-Za-z]:/u.test(path)) {
+        throw new ChannelFileWorkspaceError('invalid_file_path', `Invalid relative file path: ${path}`);
+    }
+    return path;
+}
+export function requireExecutionRoot(payload) {
+    const workspace = payload.resolvedWorkspace;
+    if (workspace?.authority !== 'task-execution-target' || !isAbsolute(workspace.rootPath)) {
+        throw new ChannelFileWorkspaceError('execution_local_directory_required', 'Channel file transfer requires a task execution.local_directory');
+    }
+    return workspace.rootPath;
+}
+export async function readWorkspaceFile(rootPath, sourcePath) {
+    const safePath = validatePortableRelativePath(sourcePath);
+    const rootRealPath = await fs.realpath(rootPath);
+    const candidate = resolve(rootRealPath, ...safePath.split('/'));
+    assertContained(rootRealPath, candidate);
+    await rejectSymlinks(rootRealPath, candidate);
+    let stat;
+    try {
+        stat = await fs.stat(candidate);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new ChannelFileWorkspaceError('file_not_found', `Workspace file not found: ${sourcePath}`);
+        }
+        throw error;
+    }
+    if (!stat.isFile()) {
+        throw new ChannelFileWorkspaceError('file_not_found', `Workspace path is not a file: ${sourcePath}`);
+    }
+    if (stat.size > CHANNEL_FILE_TRANSFER_MAX_BYTES) {
+        throw new ChannelFileWorkspaceError('file_too_large', 'File too large (max 10MB)');
+    }
+    return await fs.readFile(candidate);
+}
+export async function writeWorkingCopy(rootPath, channelPath, content, overwrite) {
+    if (content.byteLength > CHANNEL_FILE_TRANSFER_MAX_BYTES) {
+        throw new ChannelFileWorkspaceError('file_too_large', 'File too large (max 10MB)');
+    }
+    const safePath = validatePortableRelativePath(channelPath);
+    const executionRoot = await fs.realpath(rootPath);
+    const workingRoot = resolve(executionRoot, ...CHANNEL_FILE_WORKING_COPY_DIRECTORY.split('/'));
+    assertContained(executionRoot, workingRoot);
+    await ensureSafeDirectory(executionRoot, workingRoot);
+    const destination = resolve(workingRoot, ...safePath.split('/'));
+    assertContained(workingRoot, destination);
+    await ensureSafeDirectory(workingRoot, dirname(destination));
+    await rejectSymlinks(workingRoot, destination, true);
+    try {
+        await fs.writeFile(destination, content, { flag: overwrite ? 'w' : 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            throw new ChannelFileWorkspaceError('file_exists', `Working copy already exists: ${channelPath}`);
+        }
+        throw error;
+    }
+    return destination;
+}
+async function ensureSafeDirectory(rootPath, directoryPath) {
+    const rel = relative(rootPath, directoryPath);
+    if (rel === '') {
+        return;
+    }
+    let current = rootPath;
+    for (const segment of rel.split(sep)) {
+        current = resolve(current, segment);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new ChannelFileWorkspaceError('symlink_not_allowed', `Symbolic link is not allowed: ${current}`);
+            }
+            if (!stat.isDirectory()) {
+                throw new ChannelFileWorkspaceError('invalid_file_path', `Path component is not a directory: ${current}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            await fs.mkdir(current, { mode: 0o700 });
+        }
+    }
+}
+async function rejectSymlinks(rootPath, candidate, allowMissingLeaf = false) {
+    const rel = relative(rootPath, candidate);
+    let current = rootPath;
+    const parts = rel.split(sep);
+    for (const [index, segment] of parts.entries()) {
+        current = resolve(current, segment);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new ChannelFileWorkspaceError('symlink_not_allowed', `Symbolic link is not allowed: ${current}`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && allowMissingLeaf && index === parts.length - 1) {
+                return;
+            }
+            throw error;
+        }
+    }
+    await fs.access(candidate, fsConstants.F_OK);
+}
+function assertContained(rootPath, candidate) {
+    const rel = relative(rootPath, candidate);
+    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+        throw new ChannelFileWorkspaceError('invalid_file_path', 'Path escapes the execution directory');
+    }
+}

package/dist/gateway/localhost-gateway.js

@@ -7,6 +7,7 @@ import { evaluateGatewayAuthorization, } from '../policy/gateway-authorization.j
 import { resolveConnectionsStatePath } from '../state-paths.js';
 import { findTaskForThread } from '../task-thread-resolution.js';
 import { extractVisibleMentionIds } from '../visible-mentions.js';
+import { ChannelFileWorkspaceError, readWorkspaceFile, requireExecutionRoot, validatePortableRelativePath, writeWorkingCopy, } from './channel-file-workspace.js';
 const LOOPBACK_HOST = '127.0.0.1';
 export const LOCALHOST_GATEWAY_HISTORY_LIMIT = 20;
 const LOCALHOST_GATEWAY_BODY_LIMIT_BYTES = 32 * 1024;
@@ -422,6 +423,89 @@ class LoopbackLocalhostGatewayController {
                     this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
                     return;
                 }
+                case 'files': {
+                    const files = await this.controlPlane.listChannelFiles({ channelId: binding.channelId });
+                    this.sendJson(response, 200, { files });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'file-content': {
+                    const url = new URL(request.url ?? '/', baseUrl);
+                    const path = readRequiredQueryString(url, 'path');
+                    if (!path) {
+                        throw new GatewayHttpError(400, { error: 'missing_file_path' }, 'bad-request');
+                    }
+                    validatePortableRelativePath(path);
+                    const content = await this.controlPlane.readChannelFile({
+                        channelId: binding.channelId,
+                        path,
+                        textOnly: true,
+                    });
+                    this.sendJson(response, 200, content);
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'file-download': {
+                    const body = parseFileTransferBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const content = await this.controlPlane.readChannelFile({
+                        channelId: binding.channelId,
+                        path: body.path,
+                        textOnly: false,
+                    });
+                    if (content.base64 == null) {
+                        throw new GatewayHttpError(502, { error: 'invalid_file_content' }, 'invalid-file-content');
+                    }
+                    const localPath = await writeWorkingCopy(rootPath, body.path, Buffer.from(content.base64, 'base64'), body.overwrite);
+                    this.sendJson(response, 200, { path: body.path, localPath, sizeBytes: content.sizeBytes });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
+                case 'file-sync': {
+                    const body = parseFileSyncBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const entries = (await this.controlPlane.listChannelFiles({ channelId: binding.channelId }))
+                        .filter((file) => !file.isDirectory)
+                        .filter((file) => body.path == null || file.path === body.path || file.path.startsWith(`${body.path}/`));
+                    const synced = [];
+                    for (const file of entries) {
+                        const content = await this.controlPlane.readChannelFile({
+                            channelId: binding.channelId,
+                            path: file.path,
+                            textOnly: false,
+                        });
+                        if (content.base64 == null) {
+                            throw new GatewayHttpError(502, { error: 'invalid_file_content' }, 'invalid-file-content');
+                        }
+                        synced.push({
+                            path: file.path,
+                            localPath: await writeWorkingCopy(rootPath, file.path, Buffer.from(content.base64, 'base64'), body.overwrite),
+                            sizeBytes: content.sizeBytes,
+                        });
+                    }
+                    this.sendJson(response, 200, { synced });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
+                case 'file-publish': {
+                    const body = parseFilePublishBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const workspace = binding.payload?.resolvedWorkspace;
+                    if (workspace?.authority !== 'task-execution-target' || !binding.agentId) {
+                        throw new GatewayHttpError(403, { error: 'publish_context_required' }, 'publish-context-required');
+                    }
+                    const content = await readWorkspaceFile(rootPath, body.sourcePath);
+                    const file = await this.controlPlane.publishChannelFile({
+                        channelId: binding.channelId,
+                        path: body.channelPath,
+                        contentType: body.contentType ?? inferContentType(body.sourcePath),
+                        base64: content.toString('base64'),
+                        overwrite: body.overwrite,
+                    });
+                    this.sendJson(response, 200, { file });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
                 case 'draft': {
                     if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
                         this.sendJson(response, 404, { error: 'not_found' });
@@ -599,6 +683,20 @@ class LoopbackLocalhostGatewayController {
             }
         }
         catch (error) {
+            if (error instanceof ChannelFileWorkspaceError) {
+                const statusCode = error.code === 'file_not_found'
+                    ? 404
+                    : error.code === 'file_exists'
+                        ? 409
+                        : error.code === 'file_too_large'
+                            ? 413
+                            : error.code === 'execution_local_directory_required'
+                                ? 403
+                                : 400;
+                this.sendJson(response, statusCode, { error: error.code });
+                this.recordAudit(error.code, statusCode, decision.path, request.method ?? 'GET', decision.binding);
+                return;
+            }
             const gatewayError = error instanceof GatewayHttpError
                 ? error
                 : mapGatewayControlPlaneError(error, 'authorized');
@@ -757,6 +855,48 @@ async function readGatewayJsonBody(request) {
         throw new GatewayHttpError(400, { error: 'invalid_json' }, 'invalid-json');
     }
 }
+function parseFileTransferBody(value) {
+    if (!isRecord(value) || typeof value.path !== 'string') {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return { path: validatePortableRelativePath(value.path), overwrite: value.overwrite === true };
+}
+function parseFileSyncBody(value) {
+    if (!isRecord(value) || (value.path != null && typeof value.path !== 'string')) {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return {
+        ...(typeof value.path === 'string' ? { path: validatePortableRelativePath(value.path) } : {}),
+        overwrite: value.overwrite === true,
+    };
+}
+function parseFilePublishBody(value) {
+    if (!isRecord(value)
+        || typeof value.sourcePath !== 'string'
+        || typeof value.channelPath !== 'string'
+        || (value.contentType != null && typeof value.contentType !== 'string')) {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return {
+        sourcePath: validatePortableRelativePath(value.sourcePath),
+        channelPath: validatePortableRelativePath(value.channelPath),
+        ...(typeof value.contentType === 'string' ? { contentType: value.contentType } : {}),
+        overwrite: value.overwrite === true,
+    };
+}
+function inferContentType(path) {
+    const extension = path.toLowerCase().split('.').at(-1);
+    const byExtension = {
+        css: 'text/css', csv: 'text/csv', gif: 'image/gif', html: 'text/html',
+        jpeg: 'image/jpeg', jpg: 'image/jpeg', js: 'text/javascript',
+        json: 'application/json', md: 'text/markdown', pdf: 'application/pdf',
+        png: 'image/png', py: 'text/x-python', toml: 'application/toml',
+        ts: 'text/typescript', txt: 'text/plain', webp: 'image/webp',
+        xml: 'application/xml', yaml: 'application/yaml', yml: 'application/yaml',
+        zip: 'application/zip',
+    };
+    return (extension && byExtension[extension]) || 'application/octet-stream';
+}
 async function readCollaborationRequestBody(request) {
     const bodyText = await readRequestBody(request, LOCALHOST_GATEWAY_COLLABORATION_BODY_LIMIT_BYTES);
     if (!bodyText.ok) {

package/dist/plugin-sdk.js

@@ -4502,7 +4502,7 @@ var BppTransport = class {
     };
     this.send(frame);
   }
-  // sendActivity flattens the four-shape union onto one frame. The union is
+  // sendActivity flattens the activity union onto one frame. The union is
   // how a producer says which shape it is reporting; the wire puts the
   // discriminator beside its payload with no wrapper object, matching both the
   // protocol this relays and inbound_message's own `kind`.
@@ -4575,6 +4575,18 @@ var BppTransport = class {
         frame.stop_supported = action.activity.stopSupported;
         frame.stop_unsupported_reason = action.activity.stopUnsupportedReason ?? "";
         break;
+      case "normalized":
+        frame.protocol_version = action.activity.protocolVersion;
+        frame.task_id = action.activity.taskId;
+        frame.event = action.activity.event;
+        break;
+    }
+    if (action.activity.shape === "normalized") {
+      const ids = [frame.channel_id, frame.task_id];
+      if (ids.some((value) => new TextEncoder().encode(value).byteLength > 256))
+        return;
+      if (new TextEncoder().encode(JSON.stringify(frame)).byteLength > 32768)
+        return;
     }
     this.send(frame);
   }
@@ -4705,6 +4717,18 @@ function encodeActionPayload(action) {
         after: action.after,
         limit: action.limit
       };
+    case "list_channel_files":
+      return { channel_id: action.channelId };
+    case "read_channel_file":
+      return { channel_id: action.channelId, path: action.path, text_only: action.textOnly };
+    case "publish_channel_file":
+      return {
+        channel_id: action.channelId,
+        path: action.path,
+        content_type: action.contentType,
+        base64: action.base64,
+        overwrite: action.overwrite ?? false
+      };
     case "list_users":
     case "list_channels":
       return {};
@@ -4811,6 +4835,53 @@ function decodeActionResult(op, payloadJSON, zoneInput) {
         editedAt: m.edited_at != null ? Number(m.edited_at) : void 0
       }));
     }
+    case "list_channel_files": {
+      const arr = Array.isArray(p) ? p : [];
+      return arr.map((file) => ({
+        id: String(file.id ?? ""),
+        ownerUserId: String(file.owner_user_id ?? ""),
+        channelId: String(file.channel_id ?? ""),
+        path: String(file.path ?? ""),
+        parentPath: String(file.parent_path ?? ""),
+        name: String(file.name ?? ""),
+        isDirectory: Boolean(file.is_directory),
+        mimeType: String(file.mime_type ?? ""),
+        sizeBytes: Number(file.size_bytes ?? 0),
+        source: String(file.source ?? ""),
+        sourceMessageId: String(file.source_message_id ?? ""),
+        createdAt: Number(file.created_at ?? 0),
+        updatedAt: Number(file.updated_at ?? 0)
+      }));
+    }
+    case "read_channel_file": {
+      const content = p;
+      return {
+        path: String(content.path ?? ""),
+        filename: String(content.filename ?? ""),
+        contentType: String(content.content_type ?? ""),
+        sizeBytes: Number(content.size_bytes ?? 0),
+        ...content.base64 != null ? { base64: String(content.base64) } : {},
+        ...content.text != null ? { text: String(content.text) } : {}
+      };
+    }
+    case "publish_channel_file": {
+      const file = p;
+      return {
+        id: String(file.id ?? ""),
+        ownerUserId: String(file.owner_user_id ?? ""),
+        channelId: String(file.channel_id ?? ""),
+        path: String(file.path ?? ""),
+        parentPath: String(file.parent_path ?? ""),
+        name: String(file.name ?? ""),
+        isDirectory: Boolean(file.is_directory),
+        mimeType: String(file.mime_type ?? ""),
+        sizeBytes: Number(file.size_bytes ?? 0),
+        source: String(file.source ?? ""),
+        sourceMessageId: String(file.source_message_id ?? ""),
+        createdAt: Number(file.created_at ?? 0),
+        updatedAt: Number(file.updated_at ?? 0)
+      };
+    }
     case "list_users": {
       const arr = Array.isArray(p) ? p : [];
       return arr.map((u) => ({
@@ -5155,6 +5226,15 @@ var Client = class {
   async listUsers() {
     return await this.t.perform({ op: "list_users" });
   }
+  async listChannelFiles(input) {
+    return await this.t.perform({ op: "list_channel_files", channelId: input.channelId });
+  }
+  async readChannelFile(input) {
+    return await this.t.perform({ op: "read_channel_file", ...input });
+  }
+  async publishChannelFile(input) {
+    return await this.t.perform({ op: "publish_channel_file", ...input });
+  }
   async listChannels() {
     return await this.t.perform({ op: "list_channels" });
   }
@@ -5295,10 +5375,11 @@ var Client = class {
   async listTaskPropertyDefinitions() {
     return await this.t.perform({ op: "list_task_property_definitions" });
   }
+  reportTyping(channelId) {
+    void this.t.perform({ op: "report_typing", channelId }).catch((err) => this.logger.warn("reportTyping failed", err));
+  }
   startTyping(channelId) {
-    const emit = () => {
-      void this.t.perform({ op: "report_typing", channelId }).catch((err) => this.logger.warn("startTyping failed", err));
-    };
+    const emit = () => this.reportTyping(channelId);
     emit();
     const interval = setInterval(emit, 2e3);
     interval.unref?.();