monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/dist/src/mcp-tools/terminal-tools.js

@@ -1,397 +0,0 @@
-import { getProjectCwd } from './types.js';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import { writeJsonFileAtomic } from '../utils/json-file.js';
-// Storage paths
-const STORAGE_DIR = '.monomind';
-const TERMINAL_DIR = 'terminals';
-const TERMINAL_FILE = 'store.json';
-// ── Secret-shaped env var filtering for terminal_execute ────────────────────
-// terminal_execute runs arbitrary (metacharacter-denylisted) shell commands
-// via execSync with `env: { ...process.env, ...session.env }` — the host
-// process's real environment, which commonly holds provider API keys
-// (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...), CI/VCS tokens, and cloud
-// credentials. A single unpiped command (the metacharacter denylist blocks
-// piping/chaining, but not e.g. `curl` or `aws` invoked directly) can still
-// read and exfiltrate whatever env vars it inherits. Stripping variables
-// whose *names* match common secret conventions is defense-in-depth: it
-// doesn't change legitimate terminal usage (PATH/HOME/etc. stay intact) but
-// meaningfully shrinks what a malicious or hijacked command can read by
-// default. Callers that genuinely need a specific secret can pass it via
-// terminal_create's `env` option, which flows through untouched (session.env
-// is layered on *after* the filtered process.env below).
-const SECRET_ENV_NAME_PATTERN = /(KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|_AUTH$|^AUTH_|PRIVATE_KEY|ACCESS_KEY)/i;
-/** Returns a copy of `env` with secret-shaped variable names removed. */
-export function filterSecretEnvVars(env) {
-    const filtered = {};
-    for (const [k, v] of Object.entries(env)) {
-        if (v === undefined)
-            continue;
-        if (SECRET_ENV_NAME_PATTERN.test(k))
-            continue;
-        filtered[k] = v;
-    }
-    return filtered;
-}
-function getTerminalDir() {
-    return join(getProjectCwd(), STORAGE_DIR, TERMINAL_DIR);
-}
-function getTerminalPath() {
-    return join(getTerminalDir(), TERMINAL_FILE);
-}
-const MAX_TERMINAL_STORE_BYTES = 10 * 1024 * 1024; // 10 MB
-// Same hardened-loader convention as agent-tools.ts's loadAgentStoreOrNull:
-// handlers that mutate and save must use the null-aware variant, since
-// treating a corrupt/oversized store as empty and then saving that back
-// would silently wipe every real session. Also guards against a __proto__
-// key in the parsed JSON (agent-tools.ts's loader does the same). Can't
-// delegate to utils/json-file.ts's readJsonFileSync here — it collapses
-// "file absent" and "file corrupt" into the same fallback value, but this
-// loader must tell them apart (absent → empty default is safe to build on
-// and save; corrupt → null, refuse to save over it).
-function loadTerminalStoreOrNull() {
-    try {
-        const path = getTerminalPath();
-        if (!existsSync(path))
-            return { sessions: {}, version: '3.0.0' };
-        if (statSync(path).size > MAX_TERMINAL_STORE_BYTES)
-            return null;
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
-        if (parsed && typeof parsed === 'object' && Object.prototype.hasOwnProperty.call(parsed, '__proto__'))
-            return null;
-        return parsed;
-    }
-    catch (e) {
-        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-            console.error('[loadTerminalStore] terminal store unreadable/corrupt:', e);
-        return null;
-    }
-}
-function loadTerminalStore() {
-    return loadTerminalStoreOrNull() ?? { sessions: {}, version: '3.0.0' };
-}
-function saveTerminalStore(store) {
-    writeJsonFileAtomic(getTerminalPath(), store);
-}
-export const terminalTools = [
-    {
-        name: 'terminal_create',
-        description: 'Create a new terminal session',
-        category: 'terminal',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Session name' },
-                workingDir: { type: 'string', description: 'Working directory' },
-                env: { type: 'object', description: 'Environment variables' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadTerminalStoreOrNull();
-            if (!store) {
-                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to create a session to avoid overwriting real session data.' };
-            }
-            const MAX_SESSIONS = 1000;
-            if (Object.keys(store.sessions).length >= MAX_SESSIONS) {
-                return { success: false, error: 'Session limit reached' };
-            }
-            const FORBIDDEN_ENV_KEYS = new Set([
-                'PATH',
-                'LD_PRELOAD',
-                'LD_LIBRARY_PATH',
-                'NODE_OPTIONS',
-                'NODE_PATH',
-                'DYLD_INSERT_LIBRARIES',
-                'DYLD_LIBRARY_PATH',
-            ]);
-            const rawEnv = input.env || {};
-            const safeEnv = {};
-            for (const [k, v] of Object.entries(rawEnv)) {
-                if (!FORBIDDEN_ENV_KEYS.has(k) && /^[A-Z_][A-Z0-9_]*$/i.test(k)) {
-                    safeEnv[k] = String(v);
-                }
-            }
-            // Validate workingDir: must exist, be a directory, and not escape to
-            // system-sensitive paths. Fall back to project cwd if invalid.
-            let resolvedWorkingDir = getProjectCwd();
-            if (input.workingDir && typeof input.workingDir === 'string') {
-                const candidate = resolve(input.workingDir);
-                const projectCwd = getProjectCwd();
-                const home = homedir();
-                // Allow paths under project cwd or user home directory only.
-                const isUnderProject = candidate === projectCwd || candidate.startsWith(projectCwd + '/') || candidate.startsWith(projectCwd + '\\');
-                const isUnderHome = candidate === home || candidate.startsWith(home + '/') || candidate.startsWith(home + '\\');
-                if ((isUnderProject || isUnderHome) && existsSync(candidate)) {
-                    try {
-                        if (statSync(candidate).isDirectory()) {
-                            resolvedWorkingDir = candidate;
-                        }
-                    }
-                    catch {
-                        // Leave resolvedWorkingDir as default
-                    }
-                }
-            }
-            const id = `term-${Date.now()}-${randomBytes(4).toString('hex')}`;
-            // Cap session name: stored in terminal JSON store on disk.
-            const MAX_TERMINAL_NAME_LEN = 256;
-            const rawTerminalName = input.name || `Terminal ${Object.keys(store.sessions).length + 1}`;
-            const terminalName = typeof rawTerminalName === 'string' && rawTerminalName.length > MAX_TERMINAL_NAME_LEN
-                ? rawTerminalName.slice(0, MAX_TERMINAL_NAME_LEN) : rawTerminalName;
-            const session = {
-                id,
-                name: terminalName,
-                status: 'active',
-                createdAt: new Date().toISOString(),
-                lastActivity: new Date().toISOString(),
-                workingDir: resolvedWorkingDir,
-                history: [],
-                env: safeEnv,
-            };
-            store.sessions[id] = session;
-            saveTerminalStore(store);
-            return {
-                success: true,
-                sessionId: id,
-                name: session.name,
-                status: session.status,
-                workingDir: session.workingDir,
-                createdAt: session.createdAt,
-            };
-        },
-    },
-    {
-        name: 'terminal_execute',
-        description: 'Execute a command in a terminal session',
-        category: 'terminal',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: { type: 'string', description: 'Terminal session ID' },
-                command: { type: 'string', description: 'Command to execute' },
-                timeout: { type: 'number', description: 'Command timeout in ms' },
-                captureOutput: { type: 'boolean', description: 'Capture command output' },
-            },
-            required: ['command'],
-        },
-        handler: async (input) => {
-            const store = loadTerminalStoreOrNull();
-            if (!store) {
-                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to execute to avoid overwriting real session data.' };
-            }
-            const sessionId = input.sessionId;
-            // Cap command: the metacharacter regex check at line 220 is O(n), and the
-            // raw command is stored verbatim in session history (up to 200 entries).
-            // A realistic shell command is well under 64 KB; cap there.
-            const MAX_TERMINAL_COMMAND_LEN = 64 * 1024;
-            const rawCommand = input.command;
-            const command = typeof rawCommand === 'string' && rawCommand.length > MAX_TERMINAL_COMMAND_LEN
-                ? rawCommand.slice(0, MAX_TERMINAL_COMMAND_LEN) : rawCommand;
-            const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-            // Reject inherited keys (incl. toString/hasOwnProperty/etc.) so a tampered
-            // store.json can't redirect bracket access into Object.prototype.
-            if (sessionId &&
-                (typeof sessionId !== 'string' || FORBIDDEN_KEYS.has(sessionId) || !Object.hasOwn(store.sessions, sessionId))) {
-                return { success: false, error: 'Invalid sessionId' };
-            }
-            // Find or create default session
-            let session = sessionId
-                ? store.sessions[sessionId]
-                : Object.values(store.sessions).find((s) => s.status === 'active');
-            if (!session) {
-                // Create default session
-                const id = `term-${Date.now()}-${randomBytes(4).toString('hex')}`;
-                session = {
-                    id,
-                    name: 'Default Terminal',
-                    status: 'active',
-                    createdAt: new Date().toISOString(),
-                    lastActivity: new Date().toISOString(),
-                    workingDir: getProjectCwd(),
-                    history: [],
-                    env: {},
-                };
-                store.sessions[id] = session;
-            }
-            // Reject shell metacharacters AND env-prefix syntax. The previous regex
-            // allowed `=`, which `/bin/sh` interprets as a per-command env override
-            // (`PATH=/tmp/evil ls`, `LD_PRELOAD=/tmp/x.so cmd`) — turning the
-            // metacharacter denylist into RCE. Also reject leading-dash so the
-            // first arg can't be misinterpreted by the spawned binary as a flag,
-            // and reject glob/expansion characters that may evaluate paths.
-            if (/[|;&`$\n\r<>=*?~(){}[\]#!\\"']/.test(command)) {
-                return { error: 'Command contains disallowed shell metacharacters', allowed: false };
-            }
-            if (/^\s*-/.test(command)) {
-                return { error: 'Command must not start with "-"', allowed: false };
-            }
-            const rawTimeout = Number(input.timeout);
-            const timeout = Number.isFinite(rawTimeout) && rawTimeout > 0 ? Math.min(rawTimeout, 5 * 60_000) : 30_000;
-            const cwd = session.workingDir || getProjectCwd();
-            const startTime = Date.now();
-            let output;
-            let exitCode;
-            try {
-                output = execSync(command, {
-                    cwd,
-                    encoding: 'utf-8',
-                    timeout,
-                    maxBuffer: 5 * 1024 * 1024,
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                    env: { ...filterSecretEnvVars(process.env), ...session.env },
-                });
-                exitCode = 0;
-            }
-            catch (err) {
-                const e = err;
-                output = (e.stdout?.toString() || '') + (e.stderr ? `\n[stderr] ${e.stderr.toString()}` : '');
-                exitCode = e.status ?? 1;
-            }
-            const duration = Date.now() - startTime;
-            const timestamp = new Date().toISOString();
-            // Record in history (cap output size and total entries to prevent unbounded growth)
-            const MAX_OUTPUT_BYTES = 64 * 1024;
-            const MAX_HISTORY = 200;
-            const truncatedOutput = output.length > MAX_OUTPUT_BYTES
-                ? output.slice(0, MAX_OUTPUT_BYTES) + '\n[... truncated ...]'
-                : output;
-            session.history.push({ command, output: truncatedOutput, timestamp, exitCode });
-            if (session.history.length > MAX_HISTORY) {
-                session.history.splice(0, session.history.length - MAX_HISTORY);
-            }
-            session.lastActivity = timestamp;
-            session.status = 'active';
-            saveTerminalStore(store);
-            return {
-                success: exitCode === 0,
-                sessionId: session.id,
-                command,
-                output,
-                exitCode,
-                executedAt: timestamp,
-                duration,
-            };
-        },
-    },
-    {
-        name: 'terminal_list',
-        description: 'List all terminal sessions',
-        category: 'terminal',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: {
-                    type: 'string',
-                    enum: ['all', 'active', 'idle', 'closed'],
-                    description: 'Filter by status',
-                },
-                includeHistory: { type: 'boolean', description: 'Include command history' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadTerminalStore();
-            let sessions = Object.values(store.sessions);
-            const status = input.status;
-            if (status && status !== 'all') {
-                sessions = sessions.filter((s) => s.status === status);
-            }
-            return {
-                sessions: sessions.map((s) => ({
-                    id: s.id,
-                    name: s.name,
-                    status: s.status,
-                    workingDir: s.workingDir,
-                    createdAt: s.createdAt,
-                    lastActivity: s.lastActivity,
-                    historyLength: s.history.length,
-                    ...(input.includeHistory ? { history: s.history.slice(-10) } : {}),
-                })),
-                total: sessions.length,
-                active: sessions.filter((s) => s.status === 'active').length,
-            };
-        },
-    },
-    {
-        name: 'terminal_close',
-        description: 'Close a terminal session',
-        category: 'terminal',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: { type: 'string', description: 'Session ID to close' },
-                force: { type: 'boolean', description: 'Force close' },
-            },
-            required: ['sessionId'],
-        },
-        handler: async (input) => {
-            const store = loadTerminalStoreOrNull();
-            if (!store) {
-                return { success: false, error: 'Terminal store is unreadable/corrupt — refusing to close a session to avoid overwriting real session data.' };
-            }
-            const sessionId = input.sessionId;
-            const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-            if (!sessionId || FORBIDDEN_KEYS.has(sessionId)) {
-                return { success: false, error: 'Invalid sessionId' };
-            }
-            const session = Object.hasOwn(store.sessions, sessionId) ? store.sessions[sessionId] : undefined;
-            if (!session) {
-                return { success: false, error: 'Session not found' };
-            }
-            session.status = 'closed';
-            saveTerminalStore(store);
-            return {
-                success: true,
-                sessionId,
-                closedAt: new Date().toISOString(),
-            };
-        },
-    },
-    {
-        name: 'terminal_history',
-        description: 'Get command history for a terminal session',
-        category: 'terminal',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: { type: 'string', description: 'Session ID' },
-                limit: { type: 'number', description: 'Number of entries to return' },
-                offset: { type: 'number', description: 'Offset from latest' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadTerminalStore();
-            const sessionId = input.sessionId;
-            const limit = input.limit || 50;
-            const offset = input.offset || 0;
-            const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-            if (sessionId) {
-                if (typeof sessionId !== 'string' || FORBIDDEN_KEYS.has(sessionId) || !Object.hasOwn(store.sessions, sessionId)) {
-                    return { success: false, error: 'Invalid sessionId' };
-                }
-                const session = store.sessions[sessionId];
-                if (!session) {
-                    return { success: false, error: 'Session not found' };
-                }
-                const history = session.history.slice(-(limit + offset), offset ? -offset : undefined);
-                return {
-                    sessionId,
-                    history,
-                    total: session.history.length,
-                };
-            }
-            // Return combined history from all sessions
-            const allHistory = Object.values(store.sessions)
-                .flatMap((s) => s.history.map((h) => ({ ...h, sessionId: s.id })))
-                .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())
-                .slice(offset, offset + limit);
-            return {
-                history: allHistory,
-                total: allHistory.length,
-            };
-        },
-    },
-];
-//# sourceMappingURL=terminal-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/transfer-tools.d.ts

@@ -1,27 +0,0 @@
-/**
- * Transfer MCP Tools
- *
- * Only the PII scanner remains. The IPFS pattern-marketplace tools that used to
- * live here (`transfer_ipfs-resolve`, `transfer_store-search`, `-info`,
- * `-download`, `-featured`, `-trending`) were deleted along with the ~4,600-line
- * `src/transfer/{store,ipfs,storage,models,serialization}` subtree they wrapped.
- *
- * They were unreachable three ways over: gated out of the default MCP surface,
- * exposed on a CLI path the dispatcher cannot reach (`hooks transfer store …`
- * is four levels deep; the dispatcher handles three), and pointed at a registry
- * whose bootstrap config carried the placeholder `publicKey:
- * 'ed25519:monomind-registry-key'` rather than a real key.
- *
- * `transfer_detect-pii` is unrelated to all of that — it is a real regex PII
- * scanner over `src/transfer/anonymization/`, which has no store or IPFS
- * dependency, and it stays visible by default.
- *
- * @module @monomind/cli/mcp-tools/transfer-tools
- * @version 4.0.0
- */
-import type { MCPTool } from './types.js';
-/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
-export declare const allTransferTools: MCPTool[];
-export declare const transferTools: MCPTool[];
-export default transferTools;
-//# sourceMappingURL=transfer-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/transfer-tools.js

@@ -1,76 +0,0 @@
-/**
- * Transfer MCP Tools
- *
- * Only the PII scanner remains. The IPFS pattern-marketplace tools that used to
- * live here (`transfer_ipfs-resolve`, `transfer_store-search`, `-info`,
- * `-download`, `-featured`, `-trending`) were deleted along with the ~4,600-line
- * `src/transfer/{store,ipfs,storage,models,serialization}` subtree they wrapped.
- *
- * They were unreachable three ways over: gated out of the default MCP surface,
- * exposed on a CLI path the dispatcher cannot reach (`hooks transfer store …`
- * is four levels deep; the dispatcher handles three), and pointed at a registry
- * whose bootstrap config carried the placeholder `publicKey:
- * 'ed25519:monomind-registry-key'` rather than a real key.
- *
- * `transfer_detect-pii` is unrelated to all of that — it is a real regex PII
- * scanner over `src/transfer/anonymization/`, which has no store or IPFS
- * dependency, and it stays visible by default.
- *
- * @module @monomind/cli/mcp-tools/transfer-tools
- * @version 4.0.0
- */
-/**
- * Helper to create MCP tool result
- */
-function createResult(data, isError = false) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: typeof data === 'string' ? data : JSON.stringify(data, null, 2),
-            },
-        ],
-        isError,
-    };
-}
-/** Ungated — internal/test use only. MCP clients get `transferTools` below. */
-export const allTransferTools = [
-    {
-        name: 'transfer_detect-pii',
-        description: 'Scan content for personally identifiable information with regex patterns and report what was found, without redacting it. Runs locally; no network or registry involved.',
-        category: 'transfer',
-        version: '1.0.0',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                content: {
-                    type: 'string',
-                    description: 'Content to scan for PII',
-                },
-            },
-            required: ['content'],
-        },
-        handler: async (input) => {
-            try {
-                const { detectPII } = await import('../transfer/anonymization/index.js');
-                // detectPII runs multiple PII regexes over the entire string — O(n × patterns).
-                // Cap to 1 MB to prevent ReDoS-style DoS from oversized content.
-                const MAX_PII_CONTENT_LEN = 1024 * 1024; // 1 MB
-                const rawContent = input.content;
-                const content = typeof rawContent === 'string' && rawContent.length > MAX_PII_CONTENT_LEN
-                    ? rawContent.slice(0, MAX_PII_CONTENT_LEN) : rawContent;
-                const result = detectPII(content);
-                return createResult(result);
-            }
-            catch (error) {
-                return createResult({ error: error.message }, true);
-            }
-        },
-    },
-];
-// Nothing here is gated any more — the speculative IPFS tools this flag used to
-// hide have been deleted outright. The export shape is kept so callers and the
-// category loader continue to work unchanged.
-export const transferTools = allTransferTools;
-export default transferTools;
-//# sourceMappingURL=transfer-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/types.d.ts

@@ -1,58 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-export interface MCPToolInputSchema {
-    type: 'object';
-    properties: Record<string, unknown>;
-    required?: string[];
-}
-export interface MCPToolResult {
-    content: Array<{
-        type: 'text' | 'image' | 'resource';
-        text?: string;
-        data?: string;
-        mimeType?: string;
-    }>;
-    isError?: boolean;
-}
-/**
- * Returns the effective project working directory.
- * Prefers MONOMIND_CWD (set by the install script for global/MCP installs
- * where process.cwd() may resolve to '/') over the real process.cwd().
- */
-export declare function getProjectCwd(): string;
-export declare function getMonomindDataRoot(cwd?: string): string;
-/**
- * One-time migration for the agent/task/hive/swarm stores that historically lived
- * under `<projectCwd>/.monomind/<subpath>` (via getProjectCwd()) before being
- * consolidated onto the canonical getMonomindDataRoot() location (typically
- * `<repo>/.git/monomind/<subpath>`). Several MCP tool files (agent-tools.ts,
- * hive-mind-tools.ts, swarm-tools.ts, system-tools.ts) used to read/write the
- * legacy path directly, causing the same logical store to physically split from
- * task-tools.ts/session-tools.ts, which always used getMonomindDataRoot().
- *
- * If the canonical file is missing but the legacy file exists, copy (never move,
- * for safety) the legacy file into place so pre-existing data isn't silently
- * orphaned. Best-effort and idempotent — never throws, and it's a no-op once the
- * canonical file exists or when the two paths already coincide (e.g. no .git).
- *
- * @param canonicalPath Absolute path under getMonomindDataRoot() the tool now reads from.
- * @param legacySubpath Path relative to `.monomind/` that the tool used to read from
- *   (e.g. `join('agents', 'store.json')`).
- * @param cwd Optional project cwd override (defaults to getProjectCwd()).
- */
-export declare function migrateLegacyStoreFile(canonicalPath: string, legacySubpath: string, cwd?: string): void;
-export interface MCPTool {
-    name: string;
-    description: string;
-    inputSchema: MCPToolInputSchema;
-    category?: string;
-    tags?: string[];
-    version?: string;
-    cacheable?: boolean;
-    cacheTTL?: number;
-    handler: (input: Record<string, unknown>, context?: Record<string, unknown>) => Promise<MCPToolResult | unknown>;
-}
-//# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/types.js

@@ -1,98 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-import { statSync, readFileSync, existsSync, mkdirSync, copyFileSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
-/**
- * Returns the effective project working directory.
- * Prefers MONOMIND_CWD (set by the install script for global/MCP installs
- * where process.cwd() may resolve to '/') over the real process.cwd().
- */
-export function getProjectCwd() {
-    return process.env.MONOMIND_CWD || process.cwd();
-}
-/**
- * Returns the stable Monomind data root that survives branch switches and is
- * shared across all git worktrees of the same repository.
- *
- * Resolution order:
- *   1. MONOMIND_DATA_DIR env var — allows overriding to e.g. ~/.monomind/<project>
- *   2. <repo>/.git/monomind/     — regular repo (branch-agnostic, shared by design)
- *   3. <main-repo>/.git/monomind/— worktree: .git is a pointer file → resolve to
- *                                  the shared .git dir of the main worktree
- *   4. <cwd>/.monomind/          — fallback when git is unavailable
- *
- * Mirrors the _getGitMonomindDir() function in server.mjs so session, task,
- * memory, and org data all land in the same stable location.
- */
-const _dataRootCache = new Map();
-export function getMonomindDataRoot(cwd) {
-    if (process.env.MONOMIND_DATA_DIR)
-        return process.env.MONOMIND_DATA_DIR;
-    const workDir = cwd || getProjectCwd();
-    if (_dataRootCache.has(workDir))
-        return _dataRootCache.get(workDir);
-    let result;
-    try {
-        const gitEntry = join(workDir, '.git');
-        const st = statSync(gitEntry);
-        if (st.isDirectory()) {
-            result = join(gitEntry, 'monomind');
-        }
-        else {
-            // Worktree: .git is a text file "gitdir: /main/.git/worktrees/name"
-            const m = readFileSync(gitEntry, 'utf8').match(/^gitdir:\s*(.+)/m);
-            if (m) {
-                const worktreeDir = resolve(workDir, m[1].trim());
-                const commonGitDir = dirname(dirname(worktreeDir));
-                result = join(commonGitDir, 'monomind');
-            }
-            else {
-                result = join(workDir, '.monomind');
-            }
-        }
-    }
-    catch {
-        result = join(workDir, '.monomind');
-    }
-    _dataRootCache.set(workDir, result);
-    return result;
-}
-/**
- * One-time migration for the agent/task/hive/swarm stores that historically lived
- * under `<projectCwd>/.monomind/<subpath>` (via getProjectCwd()) before being
- * consolidated onto the canonical getMonomindDataRoot() location (typically
- * `<repo>/.git/monomind/<subpath>`). Several MCP tool files (agent-tools.ts,
- * hive-mind-tools.ts, swarm-tools.ts, system-tools.ts) used to read/write the
- * legacy path directly, causing the same logical store to physically split from
- * task-tools.ts/session-tools.ts, which always used getMonomindDataRoot().
- *
- * If the canonical file is missing but the legacy file exists, copy (never move,
- * for safety) the legacy file into place so pre-existing data isn't silently
- * orphaned. Best-effort and idempotent — never throws, and it's a no-op once the
- * canonical file exists or when the two paths already coincide (e.g. no .git).
- *
- * @param canonicalPath Absolute path under getMonomindDataRoot() the tool now reads from.
- * @param legacySubpath Path relative to `.monomind/` that the tool used to read from
- *   (e.g. `join('agents', 'store.json')`).
- * @param cwd Optional project cwd override (defaults to getProjectCwd()).
- */
-export function migrateLegacyStoreFile(canonicalPath, legacySubpath, cwd) {
-    try {
-        if (existsSync(canonicalPath))
-            return;
-        const legacyPath = join(cwd || getProjectCwd(), '.monomind', legacySubpath);
-        if (legacyPath === canonicalPath)
-            return;
-        if (!existsSync(legacyPath))
-            return;
-        mkdirSync(dirname(canonicalPath), { recursive: true });
-        copyFileSync(legacyPath, canonicalPath);
-    }
-    catch {
-        // Best-effort; leave both stores as-is on any failure.
-    }
-}
-//# sourceMappingURL=types.js.map