@bbigbang/agent-node 0.1.0

package/dist/dreamMemoryFallback.js

@@ -0,0 +1,118 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { extractMaxDreamMessageSeq } from '@bbigbang/memory';
+import { resolveBigbangCliEntry } from './bigbangCli.js';
+export function resolveDreamShellCommand(command, env) {
+    if (!command.trimStart().startsWith('bigbang ')) {
+        return command;
+    }
+    const bigbangBin = env.BIGBANG_BIGBANG_BIN?.trim();
+    if (bigbangBin && existsSync(bigbangBin)) {
+        return command.replace(/^bigbang\b/, `"${bigbangBin.replace(/"/g, '\\"')}"`);
+    }
+    const entry = resolveBigbangCliEntry();
+    if (entry) {
+        return command.replace(/^bigbang\b/, `"${process.execPath}" "${entry.replace(/"/g, '\\"')}"`);
+    }
+    return command;
+}
+export function readDreamAuthTokenFromEnv(env) {
+    const inlineToken = env.BIGBANG_AUTH_TOKEN?.trim();
+    if (inlineToken)
+        return inlineToken;
+    const tokenFile = env.BIGBANG_AUTH_TOKEN_FILE?.trim();
+    if (!tokenFile || !existsSync(tokenFile))
+        return null;
+    try {
+        const token = readFileSync(tokenFile, 'utf8').trim();
+        return token || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveDreamShellEnv(env, cachedAuthToken) {
+    const resolved = { ...env };
+    const tokenFile = resolved.BIGBANG_AUTH_TOKEN_FILE?.trim();
+    const inlineToken = resolved.BIGBANG_AUTH_TOKEN?.trim() || cachedAuthToken?.trim() || null;
+    if (tokenFile && !existsSync(tokenFile)) {
+        delete resolved.BIGBANG_AUTH_TOKEN_FILE;
+    }
+    if (inlineToken) {
+        resolved.BIGBANG_AUTH_TOKEN = inlineToken;
+    }
+    return resolved;
+}
+async function runShellCommand(command, cwd, env, cachedAuthToken) {
+    const resolvedEnv = resolveDreamShellEnv(env, cachedAuthToken);
+    const resolvedCommand = resolveDreamShellCommand(command, resolvedEnv);
+    return new Promise((resolve) => {
+        const child = spawn(resolvedCommand, {
+            cwd,
+            env: { ...process.env, ...resolvedEnv },
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => { stdout += String(chunk); });
+        child.stderr?.on('data', (chunk) => { stderr += String(chunk); });
+        child.on('close', (exitCode) => {
+            resolve({ exitCode, stdout, stderr });
+        });
+        child.on('error', (error) => {
+            resolve({ exitCode: 1, stdout, stderr: `${stderr}\n${String(error)}`.trim() });
+        });
+    });
+}
+async function emitBashToolEvent(sink, toolCallId, command, stage, output, ok) {
+    await sink?.sendUi?.({
+        kind: 'tool',
+        mode: 'summary',
+        title: 'Bash',
+        input: { command, description: 'Dream memory fallback' },
+        toolCallId,
+        stage,
+        ...(stage === 'complete'
+            ? {
+                output: output ?? (ok ? 'ok' : 'failed'),
+                status: ok ? 'completed' : 'failed',
+            }
+            : {}),
+    });
+}
+export async function executeDreamMemoryConsolidationFallback(params) {
+    const seq = extractMaxDreamMessageSeq(params.contextText ?? undefined);
+    const topic = `dream-fallback-${randomUUID().slice(0, 8)}`;
+    const createCommand = `bigbang memory node create --topic ${topic} --summary "Dream fallback memory write" --category project_knowledge --status draft`;
+    const createToolCallId = `dream-create-fallback-${randomUUID()}`;
+    await emitBashToolEvent(params.sink, createToolCallId, createCommand, 'start');
+    const createResult = await runShellCommand(createCommand, params.workspaceRoot, params.env, params.authToken);
+    const createOutput = [createResult.stdout, createResult.stderr].filter(Boolean).join('\n').trim();
+    const wroteMemory = createResult.exitCode === 0;
+    await emitBashToolEvent(params.sink, createToolCallId, createCommand, 'complete', createOutput, wroteMemory);
+    if (!wroteMemory || seq == null) {
+        return { wroteMemory, advancedWatermark: false };
+    }
+    const watermarkCommand = `bigbang memory dream-watermark --seq ${seq}`;
+    const watermarkToolCallId = `dream-watermark-fallback-${randomUUID()}`;
+    await emitBashToolEvent(params.sink, watermarkToolCallId, watermarkCommand, 'start');
+    const watermarkResult = await runShellCommand(watermarkCommand, params.workspaceRoot, params.env, params.authToken);
+    const watermarkOutput = [watermarkResult.stdout, watermarkResult.stderr].filter(Boolean).join('\n').trim();
+    const advancedWatermark = watermarkResult.exitCode === 0;
+    await emitBashToolEvent(params.sink, watermarkToolCallId, watermarkCommand, 'complete', watermarkOutput, advancedWatermark);
+    return { wroteMemory, advancedWatermark };
+}
+export async function executeDreamWatermarkFallback(params) {
+    const seq = extractMaxDreamMessageSeq(params.contextText ?? undefined);
+    if (seq == null)
+        return false;
+    const command = `bigbang memory dream-watermark --seq ${seq}`;
+    const toolCallId = `dream-watermark-fallback-${randomUUID()}`;
+    await emitBashToolEvent(params.sink, toolCallId, command, 'start');
+    const result = await runShellCommand(command, params.workspaceRoot, params.env, params.authToken);
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    const ok = result.exitCode === 0;
+    await emitBashToolEvent(params.sink, toolCallId, command, 'complete', output || (ok ? 'dream-watermark advanced' : 'dream-watermark failed'), ok);
+    return ok;
+}

package/dist/dreamToolPolicy.js

@@ -0,0 +1,293 @@
+const DREAM_MEMORY_WRITE_SUBCOMMANDS = new Set([
+    'create',
+    'update',
+    'dream-watermark',
+]);
+const DREAM_MEMORY_READ_SUBCOMMANDS = new Set([
+    'list',
+    'search',
+]);
+const DREAM_BLOCKED_MEMORY_MCP_MARKERS = [
+    'clude-memory',
+    'clude_memory',
+];
+export function extractShellCommand(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const command = input.command;
+    return typeof command === 'string' && command.trim() ? command : null;
+}
+export function containsBigbangMemoryInvocation(command) {
+    return splitShellCommandSegments(command)
+        .some((segment) => containsBigbangMemoryAtCommandHead(segment));
+}
+function isHelpOnlyShellSegment(segment) {
+    return /\b--help\b/.test(segment) || /\bhelp\b/.test(segment.split(/\s+/).slice(-1)[0] ?? '');
+}
+function isPermittedDreamMemoryWriteSegment(segment) {
+    if (!segment.trim())
+        return false;
+    if (hasUnsafeShellSyntax(segment))
+        return false;
+    if (isHelpOnlyShellSegment(segment))
+        return false;
+    const invocation = parseBigbangMemoryInvocation(segment);
+    if (!invocation)
+        return false;
+    if (invocation.group === 'edge' && invocation.action === 'create')
+        return true;
+    if (invocation.group === 'node' && DREAM_MEMORY_WRITE_SUBCOMMANDS.has(invocation.action))
+        return true;
+    if (invocation.group === 'dream-watermark' && /--seq\b/.test(segment))
+        return true;
+    return false;
+}
+export function containsBigbangMemoryWriteInvocation(command) {
+    return splitShellCommandSegments(command).some((segment) => isPermittedDreamMemoryWriteSegment(segment));
+}
+function isOnlyDreamMemoryWriteCommand(command) {
+    const segments = splitShellCommandSegments(command).filter((segment) => segment.trim());
+    if (segments.length === 0)
+        return false;
+    return segments.every((segment) => isPermittedDreamMemoryWriteSegment(segment));
+}
+export function containsBigbangMemoryReadInvocation(command) {
+    return splitShellCommandSegments(command)
+        .some((segment) => {
+        const invocation = parseBigbangMemoryInvocation(segment);
+        if (!invocation)
+            return false;
+        if (invocation.group === 'node' && DREAM_MEMORY_READ_SUBCOMMANDS.has(invocation.action))
+            return true;
+        if (invocation.group === 'edge' && invocation.action === 'list')
+            return true;
+        if (invocation.group === 'search')
+            return true;
+        return false;
+    });
+}
+function isPermittedDreamMemoryWatermarkSegment(segment) {
+    if (!segment.trim())
+        return false;
+    if (hasUnsafeShellSyntax(segment))
+        return false;
+    if (isHelpOnlyShellSegment(segment))
+        return false;
+    const invocation = parseBigbangMemoryInvocation(segment);
+    return invocation?.group === 'dream-watermark' && /--seq\b/.test(segment);
+}
+export function isDreamMemoryWatermarkTool(toolName, input) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized !== 'bash' && normalized !== 'shell')
+        return false;
+    const command = extractShellCommand(input);
+    if (!command)
+        return false;
+    const segments = splitShellCommandSegments(command).filter((segment) => segment.trim());
+    if (segments.length === 0)
+        return false;
+    return segments.every((segment) => isPermittedDreamMemoryWatermarkSegment(segment));
+}
+export function isDreamMemoryWriteTool(toolName, input) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized !== 'bash' && normalized !== 'shell')
+        return false;
+    const command = extractShellCommand(input);
+    if (!command)
+        return false;
+    return isOnlyDreamMemoryWriteCommand(command);
+}
+export function isDreamMemoryReadTool(toolName, input) {
+    const normalized = toolName.trim().toLowerCase();
+    if (normalized !== 'bash' && normalized !== 'shell')
+        return false;
+    const command = extractShellCommand(input);
+    if (!command)
+        return false;
+    return containsBigbangMemoryReadInvocation(command);
+}
+export function isDreamBlockedMemoryTool(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    if (!normalized.startsWith('mcp__'))
+        return false;
+    if (DREAM_BLOCKED_MEMORY_MCP_MARKERS.some((marker) => normalized.includes(marker)))
+        return true;
+    if (normalized.includes('memory') && !normalized.includes('bigbang'))
+        return true;
+    return false;
+}
+export function buildDreamAdditionalDisallowedTools() {
+    return [
+        'mcp__clude-memory__get_memory_stats',
+        'mcp__clude-memory__search_memory',
+        'mcp__clude-memory__read_memory',
+        'Read',
+        'Grep',
+        'Glob',
+        'LS',
+        'WebFetch',
+        'WebSearch',
+    ];
+}
+export function isDreamAllowedReadPath(input) {
+    if (!input || typeof input !== 'object')
+        return false;
+    const candidate = input.file_path
+        ?? input.path;
+    if (typeof candidate !== 'string' || !candidate.trim())
+        return false;
+    const normalized = candidate.replace(/\\/g, '/').replace(/\/+/g, '/').toLowerCase();
+    const parts = normalized.split('/').filter((part) => part && part !== '.');
+    if (parts.includes('..'))
+        return false;
+    return normalized.endsWith('/memory.md')
+        || normalized === 'memory.md'
+        || parts.includes('notes');
+}
+export function evaluateDreamToolPermission(params) {
+    if (isDreamBlockedMemoryTool(params.toolName))
+        return 'deny_blocked_memory';
+    if (isDreamMemoryWriteTool(params.toolName, params.input))
+        return 'allow';
+    if (isDreamMemoryReadTool(params.toolName, params.input))
+        return 'deny_memory_read';
+    if (params.toolKind === 'read' && isDreamAllowedReadPath(params.input))
+        return 'allow';
+    if (params.toolKind === 'read' || params.toolKind === 'search' || params.toolKind === 'fetch') {
+        return 'deny_explore';
+    }
+    if (params.toolKind === 'execute')
+        return 'deny_execute';
+    return 'deny_explore';
+}
+function parseBigbangMemoryInvocation(segment) {
+    const tokens = shellUnquotedTokens(segment);
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index])) {
+        index += 1;
+    }
+    if (tokens[index] === 'command' || tokens[index] === 'exec')
+        index += 1;
+    if (tokens[index] === 'env') {
+        index += 1;
+        while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index])) {
+            index += 1;
+        }
+    }
+    if (tokens[index] !== 'bigbang' || tokens[index + 1] !== 'memory')
+        return null;
+    const groupToken = tokens[index + 2];
+    if (groupToken === 'dream-watermark') {
+        return { group: 'dream-watermark', action: 'set' };
+    }
+    if (groupToken === 'search') {
+        return { group: 'search', action: 'search' };
+    }
+    if (groupToken === 'node' || groupToken === 'edge') {
+        const action = tokens[index + 3];
+        if (!action)
+            return null;
+        return { group: groupToken, action };
+    }
+    return null;
+}
+function containsBigbangMemoryAtCommandHead(segment) {
+    return parseBigbangMemoryInvocation(segment) != null;
+}
+function splitShellCommandSegments(value) {
+    const segments = [];
+    let current = '';
+    let quote = null;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        const next = value[index + 1];
+        if (quote) {
+            current += char;
+            if (char === quote && value[index - 1] !== '\\')
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === ';'
+            || char === '|'
+            || char === '<'
+            || char === '>'
+            || char === '&'
+            || char === '\n'
+            || char === '\r') {
+            if (current.trim())
+                segments.push(current);
+            current = '';
+            if ((char === '&' && next === '&') || (char === '|' && next === '|'))
+                index += 1;
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        segments.push(current);
+    return segments;
+}
+function hasUnsafeShellSyntax(command) {
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        const next = command[index + 1];
+        if (quote) {
+            if (char === quote && command[index - 1] !== '\\')
+                quote = null;
+            if (quote === '"' && ((char === '$' && next === '(') || char === '`'))
+                return true;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === '|' || char === '<' || char === '>' || char === '&' || char === '`')
+            return true;
+        if (char === '\n' || char === '\r')
+            return true;
+        if (char === '$' && next === '(')
+            return true;
+    }
+    return quote != null;
+}
+function shellUnquotedTokens(command) {
+    const tokens = [];
+    let current = '';
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        if (quote) {
+            if (char === quote && command[index - 1] !== '\\') {
+                if (current)
+                    tokens.push(current);
+                current = '';
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current)
+                tokens.push(current);
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current)
+        tokens.push(current);
+    return tokens;
+}