ec-web 0.0.1 → 0.0.2

package/dist/sources/msg.js

@@ -0,0 +1,625 @@
+/**
+ * 消息数据源：扫描 data/sessions 下所有渠道的 messages.jsonl。
+ *
+ * 左列按 agent 聚合；中列列出该 agent 下所有渠道的私聊/群聊会话。
+ * 兼容旧参数名 aid/peer：前端的 aid 实际上传 scope id。
+ */
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+import { resolveParentDistModule, toFileUrl } from './parent-package.js';
+import { isTransientProtocolMessage, readAllJsonlLines, readJsonFile, } from '../fs-utils.js';
+let contextModulesPromise = null;
+const sessionAdapterPromises = new Map();
+function getContextModules() {
+    if (!contextModulesPromise) {
+        contextModulesPromise = Promise.all([
+            import(toFileUrl(resolveParentDistModule('config', 'peer-role-resolver.js'))),
+            import(toFileUrl(resolveParentDistModule('core', 'model', 'config-scope.js'))),
+            import(toFileUrl(resolveParentDistModule('core', 'message', 'peer-mode.js'))),
+        ]).then(([resolver, modelScope, peerMode]) => ({ resolver, modelScope, peerMode }));
+    }
+    return contextModulesPromise;
+}
+function getSessionAdapter(baseagent) {
+    if (!sessionAdapterPromises.has(baseagent)) {
+        const classNames = {
+            claude: 'ClaudeSessionFileAdapter',
+            codex: 'CodexSessionFileAdapter',
+            gemini: 'GeminiSessionFileAdapter',
+        };
+        const className = classNames[baseagent];
+        const promise = !className
+            ? Promise.resolve(null)
+            : Promise.resolve()
+                .then(() => import(toFileUrl(resolveParentDistModule('core', 'session', 'adapters', `${baseagent}-session-file-adapter.js`))))
+                .then(mod => mod[className] ? new mod[className]() : null)
+                .catch(() => null);
+        sessionAdapterPromises.set(baseagent, promise);
+    }
+    return sessionAdapterPromises.get(baseagent);
+}
+function safeId(value) {
+    return Buffer.from(value, 'utf8').toString('base64url');
+}
+function findMessageFiles(root) {
+    const out = [];
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                visit(full);
+            else if (entry.isFile() && entry.name === 'messages.jsonl')
+                out.push(full);
+        }
+    };
+    visit(root);
+    return out;
+}
+function readLastJsonlObject(file) {
+    const rows = readAllJsonlLines(file);
+    return rows.length ? rows[rows.length - 1] : null;
+}
+function loadThreadSessions(dirPath) {
+    const threadsDir = path.join(dirPath, '_threads');
+    const index = readJsonFile(path.join(threadsDir, 'thread-index.json')) || {};
+    return Object.entries(index).map(([threadId, value]) => {
+        const sessionId = typeof value === 'string' ? value : value?.sessionId || null;
+        const metaFile = typeof value === 'object' && value?.metaFile
+            ? value.metaFile
+            : sessionId ? `${sessionId}.jsonl` : '';
+        const metaRows = metaFile ? readAllJsonlLines(path.join(threadsDir, metaFile)) : [];
+        const active = metaRows.length ? metaRows[metaRows.length - 1] : {};
+        const replyToMessageIds = Array.from(new Set(metaRows.flatMap(row => {
+            const replyContext = row?.metadata?.replyContext;
+            const ids = [
+                replyContext?.replyToMessageId,
+                replyContext?.metadata?.refMessageId,
+            ];
+            return ids.filter((id) => typeof id === 'string' && id.length > 0);
+        })));
+        return { threadId, sessionId, active, replyToMessageIds };
+    });
+}
+function loadMainSessionIds(dirPath, active) {
+    const ids = new Set();
+    if (typeof active.id === 'string' && active.id)
+        ids.add(active.id);
+    let entries;
+    try {
+        entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return ids;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith('meta_') || !entry.name.endsWith('.jsonl'))
+            continue;
+        const latest = readLastJsonlObject(path.join(dirPath, entry.name));
+        if (typeof latest?.id === 'string' && !latest.threadId)
+            ids.add(latest.id);
+    }
+    return ids;
+}
+export function partitionMessages(messages, threadSessions, mainSessionIds) {
+    const threadBySessionId = new Map(threadSessions
+        .filter(item => item.sessionId)
+        .map(item => [item.sessionId, item]));
+    // A topic session records the inbound message it is replying to in its
+    // metadata. Use only unique references; collisions stay unclassified.
+    const threadByReplyMessageId = new Map();
+    for (const thread of threadSessions) {
+        for (const messageId of thread.replyToMessageIds || []) {
+            if (threadByReplyMessageId.has(messageId))
+                threadByReplyMessageId.set(messageId, null);
+            else
+                threadByReplyMessageId.set(messageId, thread);
+        }
+    }
+    const partitions = new Map();
+    const ensurePartition = (key, partition, threadId) => {
+        let item = partitions.get(key);
+        if (!item) {
+            item = { partition, threadId, messages: [] };
+            partitions.set(key, item);
+        }
+        return item;
+    };
+    for (const message of messages) {
+        const hasThreadField = Object.prototype.hasOwnProperty.call(message, 'threadId');
+        const explicitThreadId = typeof message.threadId === 'string' && message.threadId ? message.threadId : null;
+        const inferredThread = !hasThreadField && message.sessionId ? threadBySessionId.get(message.sessionId) : undefined;
+        const inferredReplyThread = message.msgId ? threadByReplyMessageId.get(message.msgId) : undefined;
+        if (explicitThreadId || inferredThread || inferredReplyThread) {
+            const threadId = explicitThreadId || inferredThread?.threadId || inferredReplyThread.threadId;
+            ensurePartition(`thread:${threadId}`, 'thread', threadId).messages.push({ ...message, threadId });
+        }
+        else if (hasThreadField || threadSessions.length === 0 || (message.sessionId && mainSessionIds.has(message.sessionId))) {
+            ensurePartition('main', 'main', null).messages.push({ ...message, threadId: null });
+        }
+        else {
+            ensurePartition('legacy', 'legacy', null).messages.push(message);
+        }
+    }
+    return Array.from(partitions.values());
+}
+function listConfiguredAgentAids(root) {
+    const agentsDir = path.join(root, 'agents');
+    const aids = new Set();
+    let entries;
+    try {
+        entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    }
+    catch {
+        return aids;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const config = readJsonFile(path.join(agentsDir, entry.name, 'config.json'));
+        const aid = typeof config?.aid === 'string' ? config.aid : entry.name;
+        if (looksLikeAID(aid))
+            aids.add(aid);
+    }
+    return aids;
+}
+function decodeDirSegment(seg) {
+    return seg.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
+function parseChannelKey(value) {
+    if (typeof value !== 'string')
+        return null;
+    const parts = value.split('#');
+    if (parts.length !== 3)
+        return null;
+    const [type, selfAID, name] = parts;
+    if (!type || !selfAID || !name)
+        return null;
+    return { type, selfAID, name };
+}
+function looksLikeAID(value) {
+    return !!value && value !== 'self' && value !== '_unknown' && /^[^./#\s]+\.[^/#\s]+/.test(value);
+}
+function parseLegacySessionKey(value, channelType) {
+    if (typeof value !== 'string')
+        return null;
+    const parts = value.split('#');
+    if (parts.length < 3 || parts[0] !== channelType)
+        return null;
+    if (!looksLikeAID(parts[1]))
+        return null;
+    return { type: parts[0], selfAID: parts[1], name: parts[2] || 'main' };
+}
+function pathIdentity(sessionsDir, dirPath) {
+    const relParts = path.relative(sessionsDir, dirPath).split(path.sep).filter(Boolean);
+    if (!relParts.length)
+        return {};
+    const firstKey = parseChannelKey(decodeDirSegment(relParts[0]));
+    if (firstKey) {
+        return {
+            channelType: firstKey.type,
+            channel: `${firstKey.type}#${firstKey.selfAID}#${firstKey.name}`,
+            channelId: relParts[1] ? decodeDirSegment(relParts[1]) : undefined,
+            selfAID: firstKey.selfAID,
+        };
+    }
+    if (relParts[0] === 'aun' && relParts.length >= 3) {
+        const selfAID = decodeDirSegment(relParts[1]);
+        return {
+            channelType: 'aun',
+            channel: looksLikeAID(selfAID) ? `aun#${selfAID}#main` : undefined,
+            channelId: decodeDirSegment(relParts[2]),
+            selfAID: looksLikeAID(selfAID) ? selfAID : undefined,
+        };
+    }
+    return {
+        channelType: decodeDirSegment(relParts[0]),
+        channelId: relParts[1] ? decodeDirSegment(relParts[1]) : undefined,
+    };
+}
+function inferSelfAID(active, messages, hints) {
+    if (looksLikeAID(active?.selfAID))
+        return String(active.selfAID);
+    if (looksLikeAID(hints.selfAID))
+        return hints.selfAID;
+    const channelKey = parseChannelKey(active?.channel) || parseChannelKey(active?.channelType);
+    if (channelKey)
+        return channelKey.selfAID;
+    const sessionKey = parseLegacySessionKey(active?.sessionKey, hints.channelType || active?.channelType || '');
+    if (sessionKey)
+        return sessionKey.selfAID;
+    const out = messages.find(m => m.dir === 'out' && m.from && m.from !== 'self');
+    if (out?.from)
+        return String(out.from);
+    const inboundTo = messages.find(m => m.dir === 'in' && m.to && m.to !== 'self');
+    if (inboundTo?.to)
+        return String(inboundTo.to);
+    return 'unknown';
+}
+function normalizeChatIdentity(sessionsDir, dirPath, active, messages) {
+    const pathHints = pathIdentity(sessionsDir, dirPath);
+    const activeChannelKey = parseChannelKey(active?.channel);
+    const activeTypeKey = parseChannelKey(active?.channelType);
+    const msgChannelType = messages.find(m => m.channelType)?.channelType;
+    const rawType = String(activeChannelKey?.type
+        || activeTypeKey?.type
+        || active?.channelType
+        || msgChannelType
+        || pathHints.channelType
+        || 'unknown');
+    const channelType = parseChannelKey(rawType)?.type || rawType;
+    const selfAID = inferSelfAID(active, messages, { ...pathHints, channelType });
+    const rawChannel = typeof active?.channel === 'string' && active.channel
+        ? active.channel
+        : pathHints.channel || `${channelType}#${selfAID}#main`;
+    const channelKey = parseChannelKey(rawChannel);
+    const channel = channelKey
+        ? `${channelKey.type}#${channelKey.selfAID}#${channelKey.name}`
+        : (selfAID !== 'unknown' ? `${channelType}#${selfAID}#main` : rawChannel);
+    const channelId = String(active.channelId || pathHints.channelId || path.basename(dirPath));
+    return { channelType, channel, channelId, selfAID };
+}
+function chatDisplayId(active, messages) {
+    const metadata = active?.metadata ?? {};
+    const chatType = active?.chatType || messages.find(m => m.chatType)?.chatType || 'private';
+    const groupId = chatType === 'group'
+        ? String(metadata.groupId || active?.channelId || messages.find(m => m.groupId)?.groupId || '')
+        : null;
+    const groupName = chatType === 'group' && metadata.groupName ? String(metadata.groupName) : null;
+    if (chatType === 'group') {
+        return {
+            peerId: groupId || String(active?.channelId || 'group'),
+            peerName: groupName,
+            groupId,
+            groupName,
+        };
+    }
+    const peerId = String(metadata.peerId || active?.channelId || messages.find(m => m.dir === 'in')?.from || messages.find(m => m.dir === 'out')?.to || 'unknown');
+    return {
+        peerId,
+        peerName: metadata.peerName ? String(metadata.peerName) : null,
+        groupId: null,
+        groupName: null,
+    };
+}
+function loadChats() {
+    const paths = resolvePaths();
+    const sessionsDir = paths.sessionsDir;
+    const configuredAids = listConfiguredAgentAids(paths.root);
+    const files = findMessageFiles(sessionsDir);
+    const chats = [];
+    for (const file of files) {
+        const dirPath = path.dirname(file);
+        const active = readJsonFile(path.join(dirPath, 'active.json')) ?? {};
+        const messages = readAllJsonlLines(file)
+            .filter(m => !isTransientProtocolMessage(m));
+        if (!messages.length)
+            continue;
+        const identity = normalizeChatIdentity(sessionsDir, dirPath, active, messages);
+        const { channelType, channel, channelId, selfAID } = identity;
+        if (configuredAids.size && !configuredAids.has(selfAID))
+            continue;
+        const chatType = String(active.chatType || messages.find(m => m.chatType)?.chatType || 'private');
+        const display = chatDisplayId({ ...active, chatType, channelId }, messages);
+        const threadSessions = loadThreadSessions(dirPath);
+        const threadById = new Map(threadSessions.map(item => [item.threadId, item]));
+        const mainSessionIds = loadMainSessionIds(dirPath, active);
+        for (const item of partitionMessages(messages, threadSessions, mainSessionIds)) {
+            if (!item.messages.length)
+                continue;
+            const thread = item.threadId ? threadById.get(item.threadId) : undefined;
+            const partitionActive = item.partition === 'thread' ? thread?.active || {} : item.partition === 'main' ? active : {};
+            const lastMsgAt = item.messages.reduce((max, message) => Math.max(max, message.ts || 0), 0);
+            const updatedAt = Math.max(Number(partitionActive.updatedAt || 0), lastMsgAt);
+            chats.push({
+                id: safeId(`${selfAID}\n${channelType}\n${channelId}\n${chatType}\n${item.partition}\n${item.threadId || ''}`),
+                dirPath,
+                channelType,
+                channel,
+                channelId,
+                selfAID,
+                chatType,
+                peerId: display.peerId,
+                peerName: display.peerName,
+                groupId: display.groupId,
+                groupName: display.groupName,
+                partition: item.partition,
+                threadId: item.threadId,
+                threadName: item.partition === 'thread'
+                    ? String(partitionActive.name || partitionActive.metadata?.topicName || item.threadId)
+                    : null,
+                updatedAt,
+                messages: item.messages,
+                active: partitionActive,
+            });
+        }
+    }
+    return chats;
+}
+function scopeId(chat) {
+    return safeId(chat.selfAID);
+}
+function legacyChannelScopeId(chat) {
+    return safeId(`${chat.selfAID}\n${chat.channelType}\n${chat.channel}`);
+}
+function buildScopes(chats) {
+    const map = new Map();
+    const seenChats = new Map();
+    const seenChannels = new Map();
+    const seenChannelTypes = new Map();
+    for (const chat of chats) {
+        const id = scopeId(chat);
+        let scope = map.get(id);
+        if (!scope) {
+            scope = {
+                id,
+                aid: id,
+                selfAID: chat.selfAID,
+                totalIn: 0,
+                totalOut: 0,
+                peerCount: 0,
+                groupCount: 0,
+                channelCount: 0,
+                channelTypes: [],
+                channels: [],
+                lastAt: 0,
+            };
+            map.set(id, scope);
+            seenChats.set(id, new Set());
+            seenChannels.set(id, new Set());
+            seenChannelTypes.set(id, new Set());
+        }
+        const channelSeen = seenChannels.get(id);
+        if (!channelSeen.has(chat.channel)) {
+            channelSeen.add(chat.channel);
+            scope.channels.push(chat.channel);
+            scope.channelCount = channelSeen.size;
+        }
+        const typeSeen = seenChannelTypes.get(id);
+        if (!typeSeen.has(chat.channelType)) {
+            typeSeen.add(chat.channelType);
+            scope.channelTypes.push(chat.channelType);
+            scope.channelTypes.sort();
+        }
+        let hasIn = false;
+        let hasOut = false;
+        for (const msg of chat.messages) {
+            if (msg.dir === 'in') {
+                scope.totalIn++;
+                hasIn = true;
+            }
+            else if (msg.dir === 'out') {
+                scope.totalOut++;
+                hasOut = true;
+            }
+            if (msg.ts > scope.lastAt)
+                scope.lastAt = msg.ts;
+        }
+        if (hasIn || hasOut) {
+            const chatKey = `${chat.channel}\n${chat.channelId}\n${chat.chatType}\n${chat.partition}\n${chat.threadId || ''}`;
+            const seen = seenChats.get(id);
+            if (!seen.has(chatKey)) {
+                seen.add(chatKey);
+                scope.peerCount++;
+                if (chat.chatType === 'group')
+                    scope.groupCount++;
+            }
+        }
+        if (chat.updatedAt > scope.lastAt)
+            scope.lastAt = chat.updatedAt;
+    }
+    return Array.from(map.values())
+        .sort((a, b) => b.lastAt - a.lastAt);
+}
+function channelName(channel) {
+    return parseChannelKey(channel)?.name ?? null;
+}
+function chatKey(chat) {
+    return safeId(`${chat.channelType}\n${chat.channel}\n${chat.channelId}\n${chat.chatType}\n${chat.partition}\n${chat.threadId || ''}`);
+}
+function mergePeerInfo(chats) {
+    const map = new Map();
+    for (const chat of chats) {
+        const key = chatKey(chat);
+        let peer = map.get(key);
+        if (!peer) {
+            peer = {
+                id: key,
+                peerId: key,
+                peerName: chat.chatType === 'group' ? (chat.groupName || chat.groupId || chat.channelId) : (chat.peerName || chat.peerId),
+                channel: chat.channel,
+                channelType: chat.channelType,
+                channelName: channelName(chat.channel),
+                chatType: chat.chatType,
+                groupId: chat.groupId,
+                groupName: chat.groupName,
+                partition: chat.partition,
+                threadId: chat.threadId,
+                threadName: chat.threadName,
+                inbound: 0,
+                outbound: 0,
+                lastAt: 0,
+            };
+            map.set(key, peer);
+        }
+        for (const msg of chat.messages) {
+            if (msg.dir === 'in')
+                peer.inbound++;
+            else if (msg.dir === 'out')
+                peer.outbound++;
+            if (msg.ts > peer.lastAt)
+                peer.lastAt = msg.ts;
+        }
+        if (chat.updatedAt > peer.lastAt)
+            peer.lastAt = chat.updatedAt;
+    }
+    return Array.from(map.values()).sort((a, b) => b.lastAt - a.lastAt);
+}
+function selectedChats(chats, scope) {
+    if (!scope)
+        return [];
+    return chats.filter(chat => scopeId(chat) === scope);
+}
+function messagesFor(chats, peer) {
+    const selected = peer
+        ? chats.filter(chat => chatKey(chat) === peer)
+        : chats;
+    const messages = selected.flatMap(chat => chat.messages.map(msg => ({
+        ...msg,
+        channel: chat.channel,
+        channelType: chat.channelType,
+        selfAID: chat.selfAID,
+        peerName: chat.peerName,
+        groupName: chat.groupName,
+        partition: chat.partition,
+        threadName: chat.threadName,
+    })));
+    messages.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    return messages.length > 1000 ? messages.slice(-1000) : messages;
+}
+function latestInbound(chat) {
+    for (let i = chat.messages.length - 1; i >= 0; i--) {
+        if (chat.messages[i].dir === 'in')
+            return chat.messages[i];
+    }
+    return undefined;
+}
+async function sessionTurns(active, messages) {
+    const baseagent = String(active.baseagent || active.agentType || '').toLowerCase();
+    const agentSessionId = typeof active.agentSessionId === 'string' ? active.agentSessionId : '';
+    const projectPath = typeof active.projectPath === 'string' ? active.projectPath : '';
+    if (baseagent && agentSessionId && projectPath) {
+        try {
+            const adapter = await getSessionAdapter(baseagent);
+            const turns = Number(adapter?.getFileInfo(projectPath, agentSessionId)?.turns);
+            if (Number.isFinite(turns) && turns > 0)
+                return turns;
+        }
+        catch { }
+    }
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const turns = Number(messages[i].numTurns);
+        if (Number.isFinite(turns) && turns >= 0)
+            return turns;
+    }
+    return 0;
+}
+async function buildSessionContext(chat) {
+    if (!chat || chat.partition === 'legacy')
+        return null;
+    const active = chat.active || {};
+    const inbound = latestInbound(chat);
+    const actorId = String(inbound?.from
+        || active.metadata?.peerId
+        || chat.peerId
+        || chat.channelId
+        || '');
+    const conversationId = String(chat.groupId || chat.channelId || chat.peerId || '');
+    let role = inbound?.permMode || null;
+    let permissionMode = active.permissionMode || null;
+    let chatMode = null;
+    const peerKey = `${chat.channelType}#${encodeURIComponent(conversationId)}`;
+    try {
+        const { resolver, modelScope, peerMode } = await getContextModules();
+        const detail = resolver.resolvePeerRoleDetail({
+            selfAid: chat.selfAID,
+            channelKey: chat.channel,
+            channelType: chat.channelType,
+            chatType: chat.chatType === 'group' ? 'group' : 'private',
+            actorId,
+            conversationId,
+            peerType: inbound?.peerType || active.metadata?.peerType,
+        });
+        role = detail.effectiveRole || 'none';
+        permissionMode = modelScope.resolvePermissionMode({ self: chat.selfAID, peerKey, role });
+        chatMode = peerMode.resolveChatMode({
+            self: chat.selfAID,
+            peerKey,
+            role,
+            chatType: chat.chatType,
+            peerType: inbound?.peerType || active.metadata?.peerType,
+        });
+    }
+    catch { }
+    return {
+        sessionId: active.agentSessionId || active.id || null,
+        evolclawSessionId: active.id || null,
+        name: active.name || null,
+        baseagent: active.baseagent || active.agentType || null,
+        chatMode,
+        permissionMode,
+        role,
+        turns: await sessionTurns(active, chat.messages),
+        status: active.activeTask ? 'processing' : 'idle',
+        updatedAt: Number(active.updatedAt || chat.updatedAt || 0),
+    };
+}
+async function buildSnapshot(params) {
+    const chats = loadChats();
+    const scopes = buildScopes(chats);
+    const requestedScope = params.scope || params.aid || null;
+    const scope = requestedScope && !scopes.some(s => s.id === requestedScope)
+        ? (chats.find(chat => legacyChannelScopeId(chat) === requestedScope)
+            ? scopeId(chats.find(chat => legacyChannelScopeId(chat) === requestedScope))
+            : requestedScope)
+        : requestedScope;
+    const peer = params.peer || null;
+    const inScope = selectedChats(chats, scope);
+    const peers = scope ? mergePeerInfo(inScope) : [];
+    const messages = scope ? messagesFor(inScope, peer) : [];
+    const currentChat = peer ? inScope.find(chat => chatKey(chat) === peer) : undefined;
+    const sessionContext = await buildSessionContext(currentChat);
+    return {
+        scopes,
+        aids: scopes,
+        peers,
+        messages,
+        scope,
+        aid: scope,
+        peer,
+        sessionContext,
+    };
+}
+export const msgSource = {
+    kind: 'msg',
+    async snapshot(params = {}) {
+        return await buildSnapshot(params);
+    },
+    subscribe(params, push) {
+        const sessionsDir = resolvePaths().sessionsDir;
+        let watcher = null;
+        let debounce = null;
+        const fire = () => {
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(async () => {
+                try {
+                    push(await buildSnapshot(params));
+                }
+                catch { /* ignore */ }
+            }, 150);
+        };
+        try {
+            watcher = fs.watch(sessionsDir, { recursive: true }, (_evt, filename) => {
+                const name = String(filename || '');
+                if (name.endsWith('messages.jsonl') || name.endsWith('active.json')
+                    || name.endsWith('thread-index.json') || (name.includes('_threads') && name.endsWith('.jsonl')))
+                    fire();
+            });
+        }
+        catch { /* sessionsDir may not exist yet */ }
+        return () => {
+            if (watcher)
+                watcher.close();
+            if (debounce)
+                clearTimeout(debounce);
+        };
+    },
+};

package/dist/sources/parent-package.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+let packageRootCache = null;
+function isEvolclawPackageRoot(dir) {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return pkg?.name === 'evolclaw';
+    }
+    catch {
+        return false;
+    }
+}
+function findUp(start) {
+    let dir = path.resolve(start);
+    while (true) {
+        if (isEvolclawPackageRoot(dir))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function candidateStarts() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const starts = [
+        process.env.EVOLCLAW_PACKAGE_ROOT,
+        here,
+        process.cwd(),
+        process.argv[1] ? path.dirname(process.argv[1]) : undefined,
+    ];
+    return [...new Set(starts.filter((item) => !!item))];
+}
+export function resolveEvolclawPackageRoot() {
+    if (packageRootCache)
+        return packageRootCache;
+    const searched = [];
+    for (const start of candidateStarts()) {
+        searched.push(start);
+        const root = findUp(start);
+        if (root) {
+            packageRootCache = root;
+            return root;
+        }
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgJson = require.resolve('evolclaw/package.json');
+        const root = path.dirname(pkgJson);
+        if (isEvolclawPackageRoot(root)) {
+            packageRootCache = root;
+            return root;
+        }
+    }
+    catch {
+        // Fall through to a diagnostic error.
+    }
+    throw new Error(`Main package root not found. searched=${searched.join(', ')}`);
+}
+export function resolveParentDistModule(...segments) {
+    const root = resolveEvolclawPackageRoot();
+    const modulePath = path.join(root, 'dist', ...segments);
+    if (!fs.existsSync(modulePath)) {
+        throw new Error(`Main package dist module not found: ${modulePath}. Run npm run build in ${root}.`);
+    }
+    return modulePath;
+}
+export function toFileUrl(p) {
+    return process.platform === 'win32'
+        ? new URL('file:///' + p.replace(/\\/g, '/')).href
+        : p;
+}