@jungjaehoon/mama-os 0.20.1 → 0.22.0

package/dist/agent/gateway-tool-executor.js

@@ -44,6 +44,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayToolExecutor = void 0;
 const fs_1 = require("fs");
@@ -58,6 +61,7 @@ const mama_core_1 = require("@jungjaehoon/mama-core");
 const security_monitor_js_1 = require("../security/security-monitor.js");
 const scope_context_js_1 = require("../memory/scope-context.js");
 const types_js_1 = require("./types.js");
+const sqlite_js_1 = __importDefault(require("../sqlite.js"));
 const mama_tool_handlers_js_1 = require("./mama-tool-handlers.js");
 const browser_tool_js_1 = require("../tools/browser-tool.js");
 const role_manager_js_1 = require("./role-manager.js");
@@ -68,6 +72,7 @@ const managed_agent_runtime_sync_js_1 = require("./managed-agent-runtime-sync.js
 const managed_agent_validation_js_1 = require("./managed-agent-validation.js");
 const delegation_executor_js_1 = require("./delegation-executor.js");
 const index_js_1 = require("../envelope/index.js");
+const wiki_publish_adapter_js_1 = require("../wiki-artifacts/wiki-publish-adapter.js");
 const { DebugLogger } = debugLogger;
 const securityLogger = new DebugLogger('SecurityAudit');
 const TRUTHY_ENV_VALUES = new Set(['1', 'true', 'yes', 'on']);
@@ -80,6 +85,24 @@ const AGENT_DETAIL_TABS = new Set([
     'validation',
     'history',
 ]);
+const RECALL_TEXT_REDACTION_PATTERNS = [
+    /MAMA_SYNTHETIC_[A-Z0-9_]+_DO_NOT_LEAK/g,
+    /synthetic:\/\/raw[^\s"']*/g,
+    /raw:[^\s"']*/g,
+    /\bhttps?:\/\/[^\s"'<>()]+/gi,
+    /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+    /\b(?:Bearer|Token|Authorization)\s*[:=]?\s*[A-Za-z0-9._~+/=-]{8,}/gi,
+    /\b(?:api[_-]?key|token|secret|password)\s*[:=]\s*[^\s"']{8,}/gi,
+    /(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{8,}\b/g,
+    /xox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+    /sk-[A-Za-z0-9_-]{20,}\b/g,
+    /\b[CU][A-Z0-9]{8,}\b/g,
+    /\b[0-9]{17,20}\b/g,
+    /(?:\/Users|\/home|\/tmp)\/[^\s"']*/g,
+    /[A-Za-z]:\\Users\\[^\s"']*/g,
+];
+const MAX_RECALL_TEXT_LENGTH = 280;
+const RECALL_TEXT_REDACTION_SCAN_LIMIT = MAX_RECALL_TEXT_LENGTH + 2048;
 const managedAgentMutationTails = new Map();
 const MEMORY_SCOPE_AUDIT_TOOLS = new Set([
     'mama_save',
@@ -103,6 +126,112 @@ const ENVELOPE_REQUIRED_SURFACES = new Set([
 ]);
 class ContextPacketProvenanceError extends Error {
 }
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringField(record, field) {
+    const value = record[field];
+    return typeof value === 'string' ? value : undefined;
+}
+function numberField(record, field) {
+    const value = record[field];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function sanitizeRecallText(value) {
+    if (!value) {
+        return undefined;
+    }
+    let sanitized = value.length > RECALL_TEXT_REDACTION_SCAN_LIMIT
+        ? value.slice(0, RECALL_TEXT_REDACTION_SCAN_LIMIT)
+        : value;
+    for (const pattern of RECALL_TEXT_REDACTION_PATTERNS) {
+        sanitized = sanitized.replace(pattern, '[redacted]');
+    }
+    const wasTruncated = value.length > MAX_RECALL_TEXT_LENGTH || sanitized.length > MAX_RECALL_TEXT_LENGTH;
+    if (sanitized.length > MAX_RECALL_TEXT_LENGTH) {
+        sanitized = sanitized.slice(0, MAX_RECALL_TEXT_LENGTH);
+    }
+    if (wasTruncated) {
+        sanitized = `${sanitized} [truncated]`;
+    }
+    return sanitized;
+}
+function sanitizeRecallMemory(value) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const safe = {};
+    const topic = sanitizeRecallText(stringField(record, 'topic'));
+    const kind = sanitizeRecallText(stringField(record, 'kind'));
+    const summary = sanitizeRecallText(stringField(record, 'summary'));
+    const status = sanitizeRecallText(stringField(record, 'status'));
+    const confidence = numberField(record, 'confidence');
+    if (topic) {
+        safe.topic = topic;
+    }
+    if (kind) {
+        safe.kind = kind;
+    }
+    if (summary) {
+        safe.summary = summary;
+    }
+    if (status) {
+        safe.status = status;
+    }
+    if (confidence !== undefined) {
+        safe.confidence = confidence;
+    }
+    return Object.keys(safe).length > 0 ? safe : null;
+}
+function sanitizeRecallMemories(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((memory) => sanitizeRecallMemory(memory))
+        .filter((memory) => memory !== null);
+}
+function sanitizeProfileEvidence(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((item) => {
+        const record = asRecord(item);
+        if (!record) {
+            return null;
+        }
+        const evidence = {};
+        const topic = sanitizeRecallText(stringField(record, 'topic'));
+        if (topic) {
+            evidence.topic = topic;
+        }
+        return Object.keys(evidence).length > 0 ? evidence : null;
+    })
+        .filter((evidence) => evidence !== null);
+}
+function sanitizeMamaRecallBundle(bundle) {
+    const record = asRecord(bundle) ?? {};
+    const profile = asRecord(record.profile) ?? {};
+    const graphContext = asRecord(record.graph_context) ?? {};
+    const edges = Array.isArray(graphContext.edges) ? graphContext.edges : [];
+    return {
+        profile: {
+            static: sanitizeRecallMemories(profile.static),
+            dynamic: sanitizeRecallMemories(profile.dynamic),
+            evidence: sanitizeProfileEvidence(profile.evidence),
+        },
+        memories: sanitizeRecallMemories(record.memories),
+        graph_context: {
+            primary: sanitizeRecallMemories(graphContext.primary),
+            expanded: sanitizeRecallMemories(graphContext.expanded),
+            edge_count: edges.length,
+        },
+    };
+}
 async function withManagedAgentMutationLock(agentId, fn) {
     const previous = managedAgentMutationTails.get(agentId) ?? Promise.resolve();
     let release;
@@ -164,9 +293,19 @@ class GatewayToolExecutor {
     disallowedGatewayTools = new Set();
     reportPublisher = null;
     wikiPublisher = null;
+    wikiPublishAdapter = null;
     obsidianVaultPath = null;
-    setObsidianVaultPath(vaultPath) {
+    obsidianVaultName = null;
+    setObsidianVaultPath(vaultPath, vaultName) {
         this.obsidianVaultPath = vaultPath;
+        this.obsidianVaultName = vaultName ?? null;
+    }
+    taskLedger = null;
+    setTaskLedger(ledger) {
+        this.taskLedger = ledger;
+    }
+    getTaskLedger() {
+        return this.taskLedger;
     }
     agentEventBus = null;
     setAgentEventBus(bus) {
@@ -236,6 +375,7 @@ class GatewayToolExecutor {
             modelRunId: executionContext?.modelRunId ?? null,
             gatewayCallId: executionContext?.gatewayCallId,
             backgroundTasks: executionContext?.backgroundTasks,
+            disallowedGatewayTools: executionContext?.disallowedGatewayTools,
         };
     }
     getExecutionState() {
@@ -267,6 +407,8 @@ class GatewayToolExecutor {
             gatewayCallId: active.gatewayCallId ?? fallback.gatewayCallId,
             parentToolName: active.parentToolName ?? fallback.parentToolName,
             backgroundTasks: active.backgroundTasks ?? fallback.backgroundTasks,
+            // Never merged from fallback - blocks are strictly per-call.
+            disallowedGatewayTools: active.disallowedGatewayTools,
         };
     }
     getActiveContext() {
@@ -394,6 +536,9 @@ class GatewayToolExecutor {
     setWikiPublisher(fn) {
         this.wikiPublisher = fn;
     }
+    setWikiPublishAdapter(adapter) {
+        this.wikiPublishAdapter = adapter;
+    }
     /** Check if a memory agent is available for routing memory writes. */
     hasMemoryAgent() {
         return this.memoryAgentProcessManager !== null;
@@ -431,6 +576,7 @@ class GatewayToolExecutor {
         this.envelopeIssuanceMode = options.envelopeIssuanceMode ?? 'enabled';
         this.metricsStore = options.metricsStore ?? null;
         this.contextCompileService = options.contextCompileService;
+        this.wikiPublishAdapter = options.wikiPublishAdapter ?? null;
         this.browserTool = (0, browser_tool_js_1.getBrowserTool)({
             screenshotDir: (0, path_1.join)(process.env.HOME || '', '.mama', 'workspace', 'media', 'outbound'),
         });
@@ -485,6 +631,11 @@ class GatewayToolExecutor {
     setContextCompileService(service) {
         this.contextCompileService = service;
     }
+    /** Wire the shared MAMA API built at boot (initMamaCore) so the executor never
+     *  lazily constructs a second API/adapter stack against the same DB. */
+    setMamaApi(api) {
+        this.mamaApi = api;
+    }
     /**
      * Initialize the MAMA API by importing from mcp-server package
      * Called lazily on first tool execution if not provided in constructor
@@ -883,6 +1034,52 @@ class GatewayToolExecutor {
             projectId: process.env.MAMA_WORKSPACE || process.cwd(),
         });
     }
+    resolveMamaRecallScopes(input) {
+        const ctx = this.getExecutionState();
+        const requestedScopes = normalizeMemoryScopes(input.scopes);
+        const callerProvidedScopes = input.scopes !== undefined;
+        const allowedScopes = ctx.envelope?.scope.memory_scopes ?? this.deriveMemoryScopesFromActiveContext(ctx) ?? [];
+        const hasActiveScopeBoundary = Boolean(ctx.envelope || ctx.agentContext);
+        if (callerProvidedScopes && !requestedScopes) {
+            return {
+                scopes: [],
+                denial: {
+                    success: false,
+                    code: 'memory_scope_invalid',
+                    error: 'mama_recall scopes must be valid memory scope objects.',
+                },
+            };
+        }
+        if (!hasActiveScopeBoundary) {
+            if (callerProvidedScopes) {
+                return {
+                    scopes: [],
+                    denial: {
+                        success: false,
+                        code: 'memory_scope_denied',
+                        error: 'mama_recall requires an active session or envelope for caller-supplied scopes.',
+                    },
+                };
+            }
+            return { scopes: [] };
+        }
+        if (!requestedScopes || requestedScopes.length === 0) {
+            return { scopes: allowedScopes };
+        }
+        const allowedScopeKeys = new Set(allowedScopes.map(memoryScopeKey));
+        const hasUnauthorizedScope = requestedScopes.some((scope) => !allowedScopeKeys.has(memoryScopeKey(scope)));
+        if (hasUnauthorizedScope) {
+            return {
+                scopes: [],
+                denial: {
+                    success: false,
+                    code: 'memory_scope_denied',
+                    error: 'mama_recall requested scopes outside the active session or envelope.',
+                },
+            };
+        }
+        return { scopes: requestedScopes };
+    }
     applyEnvelopeScopedReadDefaults(toolName, input, ctx) {
         // Memory read tools must inherit envelope scopes consistently when the
         // caller omits scopes. Otherwise recall can fall back to active-context
@@ -1003,6 +1200,8 @@ class GatewayToolExecutor {
                 agent_version: 0,
                 type: 'gateway_tool_call',
                 input_summary: toolName,
+                tool_name: toolName,
+                normalized_tool_name: toolName,
                 duration_ms: durationMs,
                 execution_status: executionStatus,
                 trigger_reason: 'gateway_tool_executor',
@@ -1058,8 +1257,10 @@ class GatewayToolExecutor {
         if (!VALID_TOOLS.includes(toolName)) {
             throw new types_js_1.AgentError(`Unknown tool: ${toolName}. Valid tools: ${VALID_TOOLS.join(', ')}`, 'UNKNOWN_TOOL', undefined, false);
         }
-        // Check structurally disallowed tools (e.g., OS agent can't use sub-agent tools)
-        if (this.disallowedGatewayTools.has(toolName)) {
+        // Structurally disallowed tools are per-call policy carried by the execution
+        // context (a shared executor serves many agents with different blocks).
+        const activeDisallowed = this.getExecutionState()?.disallowedGatewayTools;
+        if (activeDisallowed?.includes(toolName) || this.disallowedGatewayTools.has(toolName)) {
             return {
                 success: false,
                 error: `Tool "${toolName}" is not available. Use delegate() to assign this work to the appropriate sub-agent.`,
@@ -1466,24 +1667,21 @@ class GatewayToolExecutor {
                     if (!pagesInput || !Array.isArray(pagesInput)) {
                         throw new types_js_1.AgentError('wiki_publish requires pages array', 'TOOL_ERROR', undefined, false);
                     }
-                    if (this.wikiPublisher) {
-                        const now = new Date().toISOString();
-                        const wikiPages = pagesInput.map((p) => ({
-                            path: p.path,
-                            title: p.title,
-                            type: p.type || 'entity',
-                            content: p.content,
-                            sourceIds: [],
-                            compiledAt: now,
-                            confidence: p.confidence || 'medium',
-                        }));
-                        this.wikiPublisher(wikiPages);
+                    const adapter = this.wikiPublishAdapter ??
+                        (0, wiki_publish_adapter_js_1.createWikiPublishAdapter)({
+                            publisher: this.wikiPublisher,
+                        });
+                    try {
+                        const publishResult = adapter.publish({ pages: pagesInput });
                         return {
                             success: true,
-                            message: `Wiki published: ${wikiPages.length} pages`,
+                            message: `Wiki published: ${publishResult.pagesPublished} pages`,
+                            artifactsStored: publishResult.artifactsStored,
                         };
                     }
-                    throw new types_js_1.AgentError('Wiki publisher not configured', 'TOOL_ERROR', undefined, false);
+                    catch (error) {
+                        throw new types_js_1.AgentError(error instanceof Error ? error.message : 'Wiki publish failed', 'TOOL_ERROR', undefined, false);
+                    }
                 }
                 // Kagemusha query tools — progressive business data exploration
                 case 'kagemusha_overview': {
@@ -1508,6 +1706,59 @@ class GatewayToolExecutor {
                     }
                     return { success: true, messages: queryMessages(msgInput) };
                 }
+                case 'task_list': {
+                    if (!this.taskLedger) {
+                        return { success: false, error: 'Task ledger not configured' };
+                    }
+                    const listInput = input;
+                    return {
+                        success: true,
+                        tasks: this.taskLedger.list({
+                            status: listInput.status,
+                            channel: listInput.channel,
+                            search: listInput.search,
+                            limit: listInput.limit,
+                            order: listInput.order ?? 'deadline_priority',
+                        }),
+                    };
+                }
+                case 'task_create': {
+                    if (!this.taskLedger) {
+                        return { success: false, error: 'Task ledger not configured' };
+                    }
+                    return {
+                        success: true,
+                        task: this.taskLedger.create(input),
+                    };
+                }
+                case 'task_update': {
+                    if (!this.taskLedger) {
+                        return { success: false, error: 'Task ledger not configured' };
+                    }
+                    const { id: rawId, ...patch } = input;
+                    // Agents routinely pass "12"; coerce, reject non-numeric with a typed error.
+                    const id = typeof rawId === 'string' ? Number(rawId.trim()) : rawId;
+                    if (!Number.isInteger(id) || id <= 0) {
+                        throw new types_js_1.AgentError(`task_update requires a numeric id, got: ${String(rawId)}`, 'TOOL_ERROR', undefined, false);
+                    }
+                    return {
+                        success: true,
+                        task: this.taskLedger.update(id, patch),
+                    };
+                }
+                case 'schedule_upcoming': {
+                    return this.executeScheduleUpcoming(input);
+                }
+                case 'contract_no_update': {
+                    if (!this.taskLedger) {
+                        return { success: false, error: 'Task ledger not configured' };
+                    }
+                    const { reason, scope } = input;
+                    if (!reason || !scope) {
+                        throw new types_js_1.AgentError('contract_no_update requires both reason and scope', 'TOOL_ERROR', undefined, false);
+                    }
+                    return { success: true, note: this.taskLedger.recordNoUpdate(scope, reason) };
+                }
                 case 'agent_notices': {
                     const rawLimit = Number(input.limit);
                     const limit = Number.isFinite(rawLimit)
@@ -2628,6 +2879,76 @@ class GatewayToolExecutor {
             };
         }
     }
+    /**
+     * schedule_upcoming (M8 P4): read the calendar connector's raw store and
+     * return events in [now, now+days] plus a compact text digest. Lazy readonly
+     * open (operator-handler pattern); prefers metadata JSON start when present.
+     * v1 limits (documented in the tool description): no recurrence expansion,
+     * no cancellation tracking.
+     */
+    scheduleDb = null;
+    executeScheduleUpcoming(input) {
+        const rawDays = Number(input.days);
+        const days = Number.isFinite(rawDays) ? Math.max(1, Math.min(60, Math.floor(rawDays))) : 14;
+        const dbPath = process.env.MAMA_CALENDAR_RAW_DB ??
+            (0, path_1.join)((0, os_1.homedir)(), '.mama', 'connectors', 'calendar', 'raw.db');
+        if (!this.scheduleDb) {
+            if (!(0, fs_1.existsSync)(dbPath)) {
+                return {
+                    success: false,
+                    error: 'Calendar connector raw store not found (is the calendar connector enabled?)',
+                };
+            }
+            // Wrapper takes only (path); this handle is used for reads only.
+            this.scheduleDb = new sqlite_js_1.default(dbPath);
+            this.scheduleDb.prepare('PRAGMA busy_timeout = 5000').get();
+        }
+        const now = Date.now();
+        const until = now + days * 86_400_000;
+        let rows;
+        try {
+            rows = this.scheduleDb
+                .prepare(`SELECT source_id, channel, content, timestamp, metadata
+           FROM raw_items
+           WHERE timestamp >= ? AND timestamp <= ?
+           ORDER BY timestamp ASC
+           LIMIT 50`)
+                .all(now, until);
+        }
+        catch (err) {
+            // Corrupt/locked store or missing table: fail closed with a readable
+            // error and drop the cached handle so the next call can retry fresh.
+            this.scheduleDb = null;
+            return {
+                success: false,
+                error: `Calendar raw store unreadable: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        const events = rows.map((row) => {
+            let start = row.timestamp;
+            try {
+                const meta = row.metadata ? JSON.parse(row.metadata) : null;
+                const metaStart = meta?.start ?? meta?.startTime ?? meta?.start_time;
+                if (typeof metaStart === 'string' || typeof metaStart === 'number') {
+                    const parsed = new Date(metaStart).getTime();
+                    if (Number.isFinite(parsed))
+                        start = parsed;
+                }
+            }
+            catch {
+                /* metadata is best-effort */
+            }
+            return {
+                title: (row.content ?? '').split('\n')[0]?.slice(0, 120) ?? '',
+                start: new Date(start).toISOString(),
+                channel: row.channel,
+            };
+        });
+        const text = events.length === 0
+            ? `(no calendar events in the next ${days} days)`
+            : events.map((e) => `- ${e.start.slice(0, 16)} ${e.title} (${e.channel})`).join('\n');
+        return { success: true, events, text };
+    }
     /**
      * Execute Obsidian CLI command on the wiki vault.
      */
@@ -2640,8 +2961,12 @@ class GatewayToolExecutor {
             };
         }
         // Obsidian CLI syntax: obsidian <command> key=value ... [flags]
-        // Vault is not passed as path — Obsidian uses the default/focused vault
+        // Without vault=<name> the CLI targets the FOCUSED vault, so wiki writes
+        // could land in whatever vault the owner has open. Pin it when configured.
         const cliArgs = [command];
+        if (this.obsidianVaultName) {
+            cliArgs.push(`vault=${this.obsidianVaultName}`);
+        }
         for (const [key, value] of Object.entries(args || {})) {
             if (value === 'true' && ['silent', 'overwrite', 'total'].includes(key)) {
                 cliArgs.push(key);
@@ -2875,17 +3200,11 @@ class GatewayToolExecutor {
                 error: 'query is required and recallMemory API must be available',
             };
         }
-        const context = this.getActiveContext();
-        const fallbackScopes = context
-            ? (0, scope_context_js_1.deriveMemoryScopes)({
-                source: context.source,
-                channelId: context.session.channelId,
-                userId: context.session.userId,
-                projectId: process.env.MAMA_WORKSPACE || process.cwd(),
-            })
-            : [];
-        const inputScopes = Array.isArray(input.scopes) ? input.scopes : [];
-        const scopes = inputScopes.length > 0 ? inputScopes : fallbackScopes;
+        const scopeResolution = this.resolveMamaRecallScopes(input);
+        if (scopeResolution.denial) {
+            return scopeResolution.denial;
+        }
+        const scopes = scopeResolution.scopes;
         if (scopes.length === 0) {
             return {
                 success: false,
@@ -2897,7 +3216,7 @@ class GatewayToolExecutor {
                 scopes,
                 includeProfile: true,
             });
-            return { success: true, bundle };
+            return { success: true, bundle: sanitizeMamaRecallBundle(bundle) };
         }
         catch (err) {
             return {