evolcore 0.0.12 → 0.0.14

package/dist/core/runtime-lock.js

@@ -0,0 +1,101 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+export const RUNTIME_LOCK_DIR_ENV = 'EVOLCORE_RUNTIME_LOCK_DIR';
+/**
+ * Resolve a task-provided lock location without accepting relative or escaped
+ * paths. When no managed task context is present, callers retain their legacy
+ * on-disk lock path for daemon-side compatibility and migration tooling.
+ */
+export function resolveManagedLockPath(namespace, identity, legacyPath) {
+    const configured = process.env[RUNTIME_LOCK_DIR_ENV]?.trim();
+    if (!configured || !path.isAbsolute(configured) || !namespace || !identity || !isTrustedRuntimeLockDir(configured)) {
+        return legacyPath;
+    }
+    const digest = crypto.createHash('sha256').update(identity).digest('hex').slice(0, 24);
+    return path.join(path.resolve(configured), namespace, `${digest}.lock`);
+}
+function isTrustedRuntimeLockDir(candidate) {
+    const resolved = path.resolve(candidate);
+    if (path.basename(resolved) !== 'evolcore-locks')
+        return false;
+    const tmpRoot = process.env.TMPDIR?.trim();
+    if (!tmpRoot || !path.isAbsolute(tmpRoot))
+        return false;
+    const resolvedTmpRoot = path.resolve(tmpRoot);
+    const relative = path.relative(resolvedTmpRoot, resolved);
+    const isWithinTmp = relative !== '..'
+        && !relative.startsWith(`..${path.sep}`)
+        && !path.isAbsolute(relative);
+    // The daemon supplies each task either a generic evolcore-runtime-* child
+    // or Codex's private digest directory. Both share a sibling evolcore-locks
+    // directory so mutations from separate sessions still serialize. Do not
+    // accept arbitrary TMPDIR siblings supplied by a child process.
+    const tmpBase = path.basename(resolvedTmpRoot);
+    const tmpParent = path.dirname(resolvedTmpRoot);
+    const isGenericSessionRuntime = /^evolcore-runtime-[a-f0-9]{24}$/.test(tmpBase);
+    const isCodexSessionRuntime = /^[a-f0-9]{24}$/.test(tmpBase)
+        && /^evolcore-codex-(?:\d+|user)$/.test(path.basename(tmpParent));
+    const isManagedSessionSibling = (isGenericSessionRuntime || isCodexSessionRuntime)
+        && path.dirname(resolved) === tmpParent;
+    if (!isWithinTmp && !isManagedSessionSibling)
+        return false;
+    try {
+        const tmpStat = fs.lstatSync(resolvedTmpRoot);
+        if (!tmpStat.isDirectory() || tmpStat.isSymbolicLink())
+            return false;
+        if (typeof process.getuid === 'function' && tmpStat.uid !== process.getuid())
+            return false;
+        if ((tmpStat.mode & 0o077) !== 0)
+            return false;
+        if (isManagedSessionSibling) {
+            const parentStat = fs.lstatSync(tmpParent);
+            if (!parentStat.isDirectory() || parentStat.isSymbolicLink())
+                return false;
+            if (typeof process.getuid === 'function' && parentStat.uid !== process.getuid())
+                return false;
+            if ((parentStat.mode & 0o077) !== 0)
+                return false;
+        }
+        const stat = fs.lstatSync(resolved);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return false;
+        if (typeof process.getuid === 'function' && stat.uid !== process.getuid())
+            return false;
+        return (stat.mode & 0o077) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function ensureManagedLockParent(lockPath) {
+    const configured = process.env[RUNTIME_LOCK_DIR_ENV]?.trim();
+    if (!configured || !isTrustedRuntimeLockDir(configured)) {
+        throw new Error('managed runtime lock directory is not trusted');
+    }
+    const root = path.resolve(configured);
+    const parent = path.resolve(path.dirname(lockPath));
+    const relative = path.relative(root, parent);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error('managed runtime lock parent escapes its runtime directory');
+    }
+    // Create each component individually. mkdir({recursive:true}) would follow a
+    // pre-existing symlink in a namespace component before it can be checked.
+    let current = root;
+    for (const segment of relative.split(path.sep).filter(Boolean)) {
+        current = path.join(current, segment);
+        try {
+            fs.mkdirSync(current, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error?.code !== 'EEXIST')
+                throw error;
+        }
+        const stat = fs.lstatSync(current);
+        if (!stat.isDirectory() || stat.isSymbolicLink()
+            || (typeof process.getuid === 'function' && stat.uid !== process.getuid())
+            || (stat.mode & 0o077) !== 0) {
+            throw new Error(`managed runtime lock path is not a private real directory: ${current}`);
+        }
+    }
+}

package/dist/core/session/session-manager.js

@@ -2,8 +2,7 @@ import { ensureDir } from '../../utils/atomic-write.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
 import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
-import { sessionToFile, fileToSession } from './session-mapper.js';
-import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
+import { sessionToFile, fileToSession, formatSessionKey, DEFAULT_THREAD_ID } from './session-mapper.js';
 import { tryParseChannelKey } from '../channel-loader.js';
 import { isSystemControlChannel } from '../system-channels.js';
 import path from 'path';
@@ -597,6 +596,14 @@ export class SessionManager {
                     mutated = true;
                 }
             }
+            if (chatType === 'group' && metadata?.groupId) {
+                if (!session.metadata)
+                    session.metadata = {};
+                if (session.metadata.groupId !== metadata.groupId) {
+                    session.metadata.groupId = metadata.groupId;
+                    mutated = true;
+                }
+            }
             if (metadata?.peerType && session.metadata?.peerType !== metadata.peerType) {
                 if (!session.metadata)
                     session.metadata = {};
@@ -636,6 +643,9 @@ export class SessionManager {
             if (metadata?.peerType) {
                 session.metadata.peerType = metadata.peerType;
             }
+            if (chatType === 'group' && metadata?.groupId) {
+                session.metadata.groupId = metadata.groupId;
+            }
             this.persistSession(session, 'sync');
             return session;
         }
@@ -702,11 +712,20 @@ export class SessionManager {
             const existing = this.readMetaLatest(metaPath);
             if (existing) {
                 const validSessionId = this.validateSessionFile(existing);
+                let mutated = false;
                 if (metadata) {
                     const creatorPeerId = existing.metadata?.peerId;
                     existing.metadata = { ...(existing.metadata || {}), ...metadata };
                     if (creatorPeerId && existing.metadata)
                         existing.metadata.peerId = creatorPeerId;
+                    mutated = true;
+                }
+                if (chatType && existing.chatType !== chatType) {
+                    logger.info(`[SessionManager] Updating thread chatType for session ${existing.id}: ${existing.chatType} -> ${chatType}`);
+                    existing.chatType = chatType;
+                    mutated = true;
+                }
+                if (mutated) {
                     this.persistSession(existing, 'none');
                 }
                 return { ...existing, agentSessionId: validSessionId };

package/dist/core/session/session-mapper.js

@@ -1,5 +1,24 @@
 import { formatTimestamp } from './session-fs-store.js';
-import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
+/** Default topic component used by the stable session routing key. */
+export const DEFAULT_THREAD_ID = 'main';
+export function formatSessionKey(channelType, channelId, threadId) {
+    const tid = threadId || DEFAULT_THREAD_ID;
+    return `${channelType}#${encodeURIComponent(channelId)}#${encodeURIComponent(tid)}`;
+}
+export function parseSessionKey(key) {
+    const first = key.indexOf('#');
+    if (first <= 0)
+        throw new Error(`Invalid session key: ${key}`);
+    const rest = key.slice(first + 1);
+    const second = rest.indexOf('#');
+    if (second <= 0)
+        throw new Error(`Invalid session key (missing threadId): ${key}`);
+    return {
+        channelType: key.slice(0, first),
+        channelId: decodeURIComponent(rest.slice(0, second)),
+        threadId: decodeURIComponent(rest.slice(second + 1)),
+    };
+}
 export function sessionToFile(session) {
     const metadata = {};
     if (session.metadata) {

package/dist/eck/detect.js

@@ -1,6 +1,23 @@
 import fs from 'fs';
 import path from 'path';
-import { BASEAGENT_CAPS } from './baseagent-caps.js';
+export const BASEAGENT_CAPS = {
+    'claude-code': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'claude': {
+        autoLoadsRules: true,
+        supportsSystemPrompt: true,
+    },
+    'codex': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+    'gemini': {
+        autoLoadsRules: false,
+        supportsSystemPrompt: true,
+    },
+};
 const MAX_DEPTH = 5;
 export function resolveEckInjection(agentConfig, projectPath, kitsRulesPath) {
     const caps = BASEAGENT_CAPS[agentConfig.baseAgent]

package/dist/eck/group-rules-sync.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { createHash } from 'crypto';
 import { TextDecoder } from 'util';
 import { getAidStore, isValidAid, loadClient, SLOT } from '../aun/aid/index.js';
+import { downloadGroupFsBytes, GroupFsDownloadError } from '../aun/group-fs-download.js';
 import { checkGroupIndex as checkGroupIndexRpc, getGroupIndex as getGroupIndexRpc } from '../aun/msg/group-index.js';
 import { agentRelationsDir } from '../paths.js';
 import { formatPeerKey } from '../core/relation/peer-identity.js';
@@ -220,7 +220,9 @@ function lazyGroupClient(selfAid) {
         client: async () => {
             if (client)
                 return client;
-            store = await getAidStore({ slotId: SLOT.daemon });
+            // This short-lived RPC client must never share the daemon's gateway
+            // cursor. A short connection can perform a background pull on connect.
+            store = await getAidStore({ slotId: SLOT.groupRules });
             client = await loadClient(store, selfAid);
             await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
             return client;
@@ -242,39 +244,15 @@ function lazyGroupClient(selfAid) {
     };
 }
 async function downloadGroupFileBytes(client, remoteRef) {
-    const ticket = await client.call('group.fs.create_download_ticket', { path: remoteRef });
-    if (!isRecord(ticket)) {
-        throw statusError('unreadable', 'group.fs.create_download_ticket returned invalid response');
-    }
-    const downloadUrl = stringField(ticket, ['download_url', 'url']);
-    if (!downloadUrl) {
-        throw statusError('unreadable', 'group.fs.create_download_ticket did not return download_url');
-    }
-    const bytes = await client.group.fs.lowlevel.httpGet(downloadUrl, bearerHeaders(client));
-    const expectedSha = stringField(ticket, ['sha256']);
-    if (expectedSha && sha256Hex(bytes).toLowerCase() !== expectedSha.toLowerCase()) {
-        throw statusError('unreadable', 'download hash verification failed');
+    try {
+        return (await downloadGroupFsBytes(client, remoteRef)).bytes;
     }
-    return bytes;
-}
-function sha256Hex(bytes) {
-    return createHash('sha256').update(bytes).digest('hex');
-}
-function bearerHeaders(client) {
-    const token = accessTokenFromClient(client);
-    return token ? { Authorization: `Bearer ${token}` } : undefined;
-}
-function accessTokenFromClient(client) {
-    const anyClient = client;
-    if (typeof anyClient.getAccessToken === 'function') {
-        const token = stringValue(anyClient.getAccessToken());
-        if (token)
-            return token;
+    catch (error) {
+        if (error instanceof GroupFsDownloadError) {
+            throw statusError('unreadable', error.message);
+        }
+        throw error;
     }
-    return stringValue(anyClient.accessToken)
-        || stringValue(anyClient.access_token)
-        || stringValue(anyClient._identity?.access_token)
-        || stringValue(anyClient._sessionParams?.access_token);
 }
 function assertUtf8(bytes) {
     new TextDecoder('utf-8', { fatal: true }).decode(bytes);
@@ -302,6 +280,10 @@ function classifyError(e) {
     if (e instanceof StatusError)
         return e.status;
     const msg = errorMessage(e).toLowerCase();
+    // A peer cache miss is a signer/identity lookup failure, not a missing
+    // rules file.
+    if (msg.includes('peer not found in cache'))
+        return 'unreadable';
     if (msg.includes('forbidden') || msg.includes('unauthorized') || msg.includes('permission'))
         return 'forbidden';
     if (msg.includes('not found') || msg.includes('does not exist'))
@@ -314,17 +296,6 @@ function errorMessage(e) {
 function isRecord(x) {
     return typeof x === 'object' && x !== null && !Array.isArray(x);
 }
-function stringValue(x) {
-    return typeof x === 'string' ? x : '';
-}
-function stringField(obj, keys) {
-    for (const k of keys) {
-        const v = obj[k];
-        if (typeof v === 'string')
-            return v;
-    }
-    return undefined;
-}
 function numberField(obj, keys) {
     for (const k of keys) {
         const v = obj[k];