@bbigbang/channel-bridge 0.1.0

package/dist/assetCache.d.ts

@@ -0,0 +1,15 @@
+export declare function resolveConversationAssetCacheRoot(params: {
+    explicitCacheRoot?: string | null;
+    agentId: string;
+    conversationId: string;
+}): string;
+export declare function findCachedAssetFile(cacheRoot: string, attachmentId: string): string | null;
+export declare function buildCachedAssetFilePath(cacheRoot: string, attachmentId: string, filename: string): string;
+export type CachedAssetMetadata = {
+    filename?: string | null;
+    mimeType?: string | null;
+};
+export declare function buildCachedAssetMetadataPath(cacheRoot: string, attachmentId: string): string;
+export declare function readCachedAssetMetadata(cacheRoot: string, attachmentId: string): CachedAssetMetadata | null;
+export declare function writeCachedAssetMetadata(cacheRoot: string, attachmentId: string, metadata: CachedAssetMetadata): void;
+export declare function sanitizeAssetFilename(filename: string): string;

package/dist/assetCache.js

@@ -0,0 +1,50 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, normalize, sep } from 'node:path';
+const ASSET_CACHE_ROOT_DIRNAME = 'bigbang-assets';
+export function resolveConversationAssetCacheRoot(params) {
+    const explicitCacheRoot = params.explicitCacheRoot?.trim();
+    const cacheRoot = explicitCacheRoot && explicitCacheRoot.length > 0
+        ? explicitCacheRoot
+        : join(tmpdir(), ASSET_CACHE_ROOT_DIRNAME, sanitizeAssetCacheSegment(params.agentId), sanitizeAssetCacheSegment(params.conversationId));
+    mkdirSync(cacheRoot, { recursive: true });
+    return cacheRoot;
+}
+export function findCachedAssetFile(cacheRoot, attachmentId) {
+    const filename = readdirSync(cacheRoot).find((entry) => entry.startsWith(`${attachmentId}--`));
+    return filename ? join(cacheRoot, filename) : null;
+}
+export function buildCachedAssetFilePath(cacheRoot, attachmentId, filename) {
+    return join(cacheRoot, `${attachmentId}--${sanitizeAssetFilename(filename)}`);
+}
+export function buildCachedAssetMetadataPath(cacheRoot, attachmentId) {
+    return join(cacheRoot, `${attachmentId}.metadata.json`);
+}
+export function readCachedAssetMetadata(cacheRoot, attachmentId) {
+    try {
+        const raw = readFileSync(buildCachedAssetMetadataPath(cacheRoot, attachmentId), 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCachedAssetMetadata(cacheRoot, attachmentId, metadata) {
+    writeFileSync(buildCachedAssetMetadataPath(cacheRoot, attachmentId), JSON.stringify({
+        ...(metadata.filename ? { filename: metadata.filename } : {}),
+        ...(metadata.mimeType ? { mimeType: metadata.mimeType } : {}),
+    }), 'utf8');
+}
+export function sanitizeAssetFilename(filename) {
+    const normalized = normalize(filename).split(sep).pop()?.trim() ?? '';
+    return normalized
+        .replace(/[^A-Za-z0-9._-]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        || 'asset';
+}
+function sanitizeAssetCacheSegment(value) {
+    const normalized = value.trim() || 'unknown';
+    return encodeURIComponent(normalized).replace(/%/g, '_');
+}

package/dist/contextBundleFormat.d.ts

@@ -0,0 +1,3 @@
+import type { RelevantContextBundle, RelevantContextBundleItem } from '@bbigbang/protocol';
+export type { RelevantContextBundle, RelevantContextBundleItem };
+export declare function formatContextBundleToolText(bundle: RelevantContextBundle): string;

package/dist/contextBundleFormat.js

@@ -0,0 +1,82 @@
+export function formatContextBundleToolText(bundle) {
+    const lines = ['## Relevant Context Bundle'];
+    lines.push(`Current: ${bundle.currentConversation.replyTarget} [${bundle.currentConversation.surfaceKind}, ${bundle.currentConversation.status}]`);
+    lines.push(`Recommended next action: ${bundle.recommendedNextAction}`);
+    lines.push(`Why: ${bundle.recommendedNextActionReason}`);
+    if (bundle.suggestedHistoryReads.length > 0) {
+        lines.push('', 'Suggested history reads:');
+        for (const suggestion of bundle.suggestedHistoryReads) {
+            const parts = [suggestion.target];
+            if (suggestion.around)
+                parts.push(`around=${suggestion.around}`);
+            if (suggestion.includeRoot)
+                parts.push('include_root=true');
+            parts.push(`reason=${suggestion.reason}`);
+            lines.push(`- ${parts.join('  ')}`);
+        }
+    }
+    lines.push('', `Items (${bundle.items.length}/${bundle.totalCount})`);
+    if (bundle.items.length === 0) {
+        lines.push('- No related surface, task, or handoff scored above zero.');
+    }
+    else {
+        for (const item of bundle.items) {
+            lines.push(`- ${formatBundleItem(item)}`);
+        }
+    }
+    if (bundle.truncated) {
+        const overflow = Object.entries(bundle.overflowByStatus)
+            .map(([status, count]) => `${status}=${count}`)
+            .join(', ');
+        lines.push('', `Overflow: ${overflow || 'additional items omitted'}`);
+    }
+    return lines.join('\n');
+}
+function formatBundleItem(item) {
+    const reasonText = item.reasons
+        .map((reason) => reason.detail ? `${reason.code}(${reason.detail})` : reason.code)
+        .join(', ');
+    if (item.kind === 'surface') {
+        const parts = [
+            `[surface score=${item.score}] ${item.replyTarget} [${item.status}]`,
+            `surface=${item.surfaceKind}`,
+            `reasons=${reasonText}`,
+        ];
+        if (item.boundTask)
+            parts.push(`task=${formatTaskIdentity(item.boundTask.agentTaskRef, item.boundTask.taskNumber)} [${item.boundTask.status}]`);
+        if (item.goal)
+            parts.push(`goal=${item.goal}`);
+        if (item.nextStep)
+            parts.push(`next=${item.nextStep}`);
+        return parts.join('  ');
+    }
+    if (item.kind === 'task') {
+        const parts = [
+            `[task score=${item.score}] ${formatTaskIdentity(item.agentTaskRef, item.taskNumber)} [${item.status}]`,
+            `title=${item.title}`,
+            `reasons=${reasonText}`,
+        ];
+        if (item.threadTarget)
+            parts.push(`thread=${item.threadTarget}`);
+        else if (item.sourceTarget)
+            parts.push(`source=${item.sourceTarget}`);
+        return parts.join('  ');
+    }
+    const parts = [
+        `[handoff score=${item.score}] ${item.handoffId} ${item.mode} [${item.status}]`,
+        `${item.sourceTarget ?? item.sourceConversationId} -> ${item.targetReplyTarget}`,
+        `reasons=${reasonText}`,
+    ];
+    if (item.relatedTaskRef)
+        parts.push(`task=${item.relatedTaskRef}`);
+    return parts.join('  ');
+}
+function formatTaskIdentity(agentTaskRef, taskNumber) {
+    if (agentTaskRef && taskNumber != null)
+        return `${agentTaskRef} · #t${taskNumber}`;
+    if (agentTaskRef)
+        return agentTaskRef;
+    if (taskNumber != null)
+        return `#t${taskNumber}`;
+    return 'task';
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * channel-bridge — MCP server for bigbang agents.
+ *
+ * Mirrors Slock's chat-bridge.js: exposes send_message, check_messages,
+ * list_server, read_history, and task board tools over MCP stdio transport.
+ * The tools call bigbang's internal agent API (/api/internal/agent/:id/*).
+ *
+ * Usage:
+ *   channel-bridge --agent-id <id> --server-url <url> [--auth-token <token>]
+ */
+export {};