comisai 1.0.36 → 1.0.40

package/node_modules/@comis/daemon/dist/api/session-handlers/session-helpers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Shared session-handler helpers.
+ *
+ * Pure JSONL scanning helpers + dependency-type re-export shared across the
+ * session handler bundles. No closures, no factory: every export is a pure
+ * function, type alias, or compile-time flag so the dependency graph stays
+ * one-directional (list / read / mutate / archive → session-helpers).
+ *
+ *   - SessionHandlerDeps (re-export of SessionsApiDeps from api/types.ts)
+ *   - JsonlSessionInfo (JSONL session shape returned by scanners)
+ *   - scanJsonlSessions (per-agent JSONL discovery)
+ *   - scanWorkspaceSessions (workspace tenant/channel JSONL discovery)
+ *   - loadJsonlSession (load + unwrap pi-agent JSONL message wrappers)
+ *   - collectAvailableSessionKeys (error-message hint helper)
+ *   - IS_DEV (dev-mode response.parse gate)
+ *
+ * @module
+ */
+import type { SessionsApiDeps as SessionHandlerDeps } from "../types.js";
+export type { SessionHandlerDeps };
+/**
+ * Run `contract.response.parse(result)` only when NODE_ENV !== "production".
+ * Daemon side is the trust boundary; in production the trust check is
+ * the in-handler logic, not the contract parse.
+ */
+export declare const IS_DEV: boolean;
+/** Shape of a JSONL session entry merged into session.list results. */
+export interface JsonlSessionInfo {
+    sessionKey: string;
+    userId: string;
+    channelId: string;
+    metadata: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+    messageCount: number;
+}
+/**
+ * Scan JSONL session directories for each configured agent and return
+ * session info records for sessions that exist only as JSONL files.
+ * Performance-guarded: skips agents with >1000 session files.
+ */
+export declare function scanJsonlSessions(agentDataDir: string, agents: Record<string, unknown>): JsonlSessionInfo[];
+/**
+ * Scan workspace sessions directory for JSONL session files.
+ * Structure: {workspaceDir}/sessions/{tenantId}/{channelDir}/{sessionFile}.jsonl
+ * These sessions are created by the pi-agent session manager and may not be
+ * indexed in SQLite yet. Returns session info records for merging into session.list.
+ */
+export declare function scanWorkspaceSessions(workspaceDir: string): JsonlSessionInfo[];
+/**
+ * Load a JSONL session file and return it as SessionData-compatible shape.
+ * Used as fallback when session.history can't find a session in SQLite.
+ * pi-agent JSONL uses `{type: "message", message: {role, content}, timestamp}` wrappers.
+ * We unwrap to `{role, content, timestamp}` which session.history expects.
+ */
+export declare function loadJsonlSession(filePath: string): {
+    messages: unknown[];
+    metadata: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+} | undefined;
+/**
+ * Collect available session keys from all sources (SQLite, JSONL, workspace)
+ * for inclusion in "session not found" error messages.
+ */
+export declare function collectAvailableSessionKeys(deps: SessionHandlerDeps): string[];

package/node_modules/@comis/daemon/dist/api/session-handlers/session-helpers.js

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared session-handler helpers.
+ *
+ * Pure JSONL scanning helpers + dependency-type re-export shared across the
+ * session handler bundles. No closures, no factory: every export is a pure
+ * function, type alias, or compile-time flag so the dependency graph stays
+ * one-directional (list / read / mutate / archive → session-helpers).
+ *
+ *   - SessionHandlerDeps (re-export of SessionsApiDeps from api/types.ts)
+ *   - JsonlSessionInfo (JSONL session shape returned by scanners)
+ *   - scanJsonlSessions (per-agent JSONL discovery)
+ *   - scanWorkspaceSessions (workspace tenant/channel JSONL discovery)
+ *   - loadJsonlSession (load + unwrap pi-agent JSONL message wrappers)
+ *   - collectAvailableSessionKeys (error-message hint helper)
+ *   - IS_DEV (dev-mode response.parse gate)
+ *
+ * @module
+ */
+import { readdirSync, statSync, readFileSync } from "node:fs";
+import { safePath, systemGetEnv, systemDateFrom } from "@comis/core";
+/**
+ * Run `contract.response.parse(result)` only when NODE_ENV !== "production".
+ * Daemon side is the trust boundary; in production the trust check is
+ * the in-handler logic, not the contract parse.
+ */
+export const IS_DEV = systemGetEnv("NODE_ENV") !== "production";
+/**
+ * Scan JSONL session directories for each configured agent and return
+ * session info records for sessions that exist only as JSONL files.
+ * Performance-guarded: skips agents with >1000 session files.
+ */
+export function scanJsonlSessions(agentDataDir, agents) {
+    const results = [];
+    for (const agentId of Object.keys(agents)) {
+        const sessionsDir = safePath(agentDataDir, agentId, "sessions");
+        let files;
+        try {
+            files = readdirSync(sessionsDir).filter(f => f.endsWith(".jsonl"));
+        }
+        catch {
+            continue; // Directory doesn't exist for this agent
+        }
+        // Performance guard: skip agents with too many session files
+        if (files.length > 1000) {
+            continue;
+        }
+        for (const file of files) {
+            const filePath = safePath(sessionsDir, file);
+            try {
+                const stat = statSync(filePath);
+                // Derive session key from filename (remove .jsonl extension)
+                const sessionKey = file.slice(0, -6); // remove ".jsonl"
+                // Count lines (messages) without parsing full content
+                const content = readFileSync(filePath, "utf-8");
+                const lines = content.split("\n").filter(l => l.trim().length > 0);
+                const messageCount = lines.length;
+                // Parse first line to extract metadata if available
+                let userId = "unknown";
+                const channelId = "unknown";
+                if (lines.length > 0) {
+                    try {
+                        const firstMsg = JSON.parse(lines[0]);
+                        if (firstMsg.role === "user") {
+                            userId = firstMsg.userId ?? "unknown";
+                        }
+                    }
+                    catch { /* skip parse errors */ }
+                }
+                results.push({
+                    sessionKey,
+                    userId,
+                    channelId,
+                    metadata: {},
+                    createdAt: Math.floor(stat.birthtimeMs),
+                    updatedAt: Math.floor(stat.mtimeMs),
+                    messageCount,
+                });
+            }
+            catch {
+                continue; // Skip unreadable files
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Scan workspace sessions directory for JSONL session files.
+ * Structure: {workspaceDir}/sessions/{tenantId}/{channelDir}/{sessionFile}.jsonl
+ * These sessions are created by the pi-agent session manager and may not be
+ * indexed in SQLite yet. Returns session info records for merging into session.list.
+ */
+export function scanWorkspaceSessions(workspaceDir) {
+    const results = [];
+    const sessionsRoot = safePath(workspaceDir, "sessions");
+    let tenantDirs;
+    try {
+        tenantDirs = readdirSync(sessionsRoot);
+    }
+    catch {
+        return results;
+    }
+    for (const tenantId of tenantDirs) {
+        const tenantPath = safePath(sessionsRoot, tenantId);
+        let channelDirs;
+        try {
+            const st = statSync(tenantPath);
+            if (!st.isDirectory())
+                continue;
+            channelDirs = readdirSync(tenantPath);
+        }
+        catch {
+            continue;
+        }
+        // Performance guard
+        if (channelDirs.length > 1000)
+            continue;
+        for (const channelDir of channelDirs) {
+            const channelPath = safePath(tenantPath, channelDir);
+            let files;
+            try {
+                const st = statSync(channelPath);
+                if (!st.isDirectory())
+                    continue;
+                files = readdirSync(channelPath).filter(f => f.endsWith(".jsonl"));
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                const filePath = safePath(channelPath, file);
+                try {
+                    const st = statSync(filePath);
+                    const sessionKey = `${tenantId}:${file.slice(0, -6)}`; // tenantId:filename-without-ext
+                    const content = readFileSync(filePath, "utf-8");
+                    const lines = content.split("\n").filter(l => l.trim().length > 0);
+                    // channelDir is the chat/channel ID (e.g., "678314278")
+                    results.push({
+                        sessionKey,
+                        userId: "unknown",
+                        channelId: channelDir,
+                        metadata: { _workspaceJsonlPath: filePath },
+                        createdAt: Math.floor(st.birthtimeMs),
+                        updatedAt: Math.floor(st.mtimeMs),
+                        messageCount: lines.length,
+                    });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Load a JSONL session file and return it as SessionData-compatible shape.
+ * Used as fallback when session.history can't find a session in SQLite.
+ * pi-agent JSONL uses `{type: "message", message: {role, content}, timestamp}` wrappers.
+ * We unwrap to `{role, content, timestamp}` which session.history expects.
+ */
+export function loadJsonlSession(filePath) {
+    try {
+        const st = statSync(filePath);
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter(l => l.trim().length > 0);
+        const parsed = lines.map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean);
+        // Unwrap pi-agent message wrappers: {type:"message", message:{role,content}} → {role,content,timestamp}
+        const messages = [];
+        for (const entry of parsed) {
+            const e = entry;
+            if (e.type === "message" && e.message) {
+                const msg = e.message;
+                // Attach timestamp from the wrapper if present
+                if (e.timestamp && !msg.timestamp) {
+                    msg.timestamp = typeof e.timestamp === "string" ? systemDateFrom(e.timestamp).getTime() : e.timestamp;
+                }
+                messages.push(msg);
+            }
+        }
+        return {
+            messages,
+            metadata: {},
+            createdAt: Math.floor(st.birthtimeMs),
+            updatedAt: Math.floor(st.mtimeMs),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Collect available session keys from all sources (SQLite, JSONL, workspace)
+ * for inclusion in "session not found" error messages.
+ */
+export function collectAvailableSessionKeys(deps) {
+    const keys = [];
+    for (const s of deps.sessionStore.listDetailed()) {
+        keys.push(s.sessionKey);
+    }
+    if (deps.defaultWorkspaceDir) {
+        const existing = new Set(keys);
+        for (const ws of scanWorkspaceSessions(deps.defaultWorkspaceDir)) {
+            if (!existing.has(ws.sessionKey)) {
+                keys.push(ws.sessionKey);
+            }
+        }
+    }
+    return keys;
+}

package/node_modules/@comis/daemon/dist/api/session-handlers/session-list.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Session list/search RPC handlers.
+ *
+ * Handlers covering session-discovery queries (no per-session loading required):
+ *   - session.list: enumerate sessions (SQLite + JSONL + workspace)
+ *   - session.search: full-text search across session message bodies
+ *
+ * @module
+ */
+import type { RpcHandler } from "../types.js";
+import { type SessionHandlerDeps } from "./session-helpers.js";
+/**
+ * Bind the session list + search handlers. Object-spread compatible with
+ * `Record<string, RpcHandler>`.
+ */
+export declare function bindSessionListHandlers(deps: SessionHandlerDeps): Record<string, RpcHandler>;

package/node_modules/@comis/daemon/dist/api/session-handlers/session-list.js

@@ -0,0 +1,239 @@
+// SPDX-License-Identifier: Apache-2.0
+// @allow-throw: RPC handler module — all throws are caught and converted to JSON-RPC error responses by rpc-dispatch.ts:306-321.
+/**
+ * Session list/search RPC handlers.
+ *
+ * Handlers covering session-discovery queries (no per-session loading required):
+ *   - session.list: enumerate sessions (SQLite + JSONL + workspace)
+ *   - session.search: full-text search across session message bodies
+ *
+ * @module
+ */
+import { parseFormattedSessionKey, SessionListContract, SessionSearchContract, stripInternalFields, systemNowMs, } from "@comis/core";
+import { IS_DEV, scanJsonlSessions, scanWorkspaceSessions, } from "./session-helpers.js";
+/**
+ * Bind the session list + search handlers. Object-spread compatible with
+ * `Record<string, RpcHandler>`.
+ */
+export function bindSessionListHandlers(deps) {
+    return {
+        [SessionListContract.method]: async (rawParams) => {
+            // Bespoke pre-Zod (defaults): no required-field guards (handler defaults
+            // kind="all" + sinceMinutes=undefined). Internal-field reads BEFORE strip.
+            const callerMetadata = rawParams._callerMetadata;
+            const callerSessionKey = rawParams._callerSessionKey;
+            const tenantId = rawParams._tenantId;
+            const userParams = stripInternalFields(rawParams);
+            const params = SessionListContract.request.parse(userParams);
+            const kind = params.kind ?? "all";
+            const sinceMinutes = params.since_minutes;
+            let sessions = deps.sessionStore.listDetailed(tenantId);
+            // Merge JSONL sessions that are not in SQLite
+            if (deps.agentDataDir) {
+                const jsonlSessions = scanJsonlSessions(deps.agentDataDir, deps.agents);
+                const sqliteKeys = new Set(sessions.map(s => s.sessionKey));
+                for (const js of jsonlSessions) {
+                    if (!sqliteKeys.has(js.sessionKey)) {
+                        sessions.push(js);
+                    }
+                }
+            }
+            // Merge workspace JSONL sessions (pi-agent session manager writes here)
+            if (deps.defaultWorkspaceDir) {
+                const wsSessions = scanWorkspaceSessions(deps.defaultWorkspaceDir);
+                const existingKeys = new Set(sessions.map(s => s.sessionKey));
+                for (const ws of wsSessions) {
+                    if (!existingKeys.has(ws.sessionKey)) {
+                        sessions.push(ws);
+                    }
+                }
+            }
+            // Recency filter: only sessions active within N minutes
+            if (sinceMinutes !== undefined) {
+                const cutoff = systemNowMs() - sinceMinutes * 60_000;
+                sessions = sessions.filter((s) => s.updatedAt >= cutoff);
+            }
+            // Kind filter: derive kind from session data
+            if (kind !== "all") {
+                sessions = sessions.filter((s) => {
+                    const isSubAgent = s.metadata.parentSessionKey !== undefined;
+                    const parsed = parseFormattedSessionKey(s.sessionKey);
+                    const hasGuild = parsed?.guildId !== undefined;
+                    switch (kind) {
+                        case "sub-agent":
+                            return isSubAgent;
+                        case "group":
+                            return hasGuild && !isSubAgent;
+                        case "dm":
+                            return !hasGuild && !isSubAgent;
+                        default:
+                            return true;
+                    }
+                });
+            }
+            // Sandboxed visibility: sub-agents only see sessions they spawned
+            if (callerMetadata?.parentSessionKey) {
+                // Caller is a sub-agent -- only show sessions whose parentSessionKey matches caller
+                sessions = sessions.filter((s) => s.metadata.parentSessionKey === callerSessionKey);
+            }
+            const result = {
+                sessions: sessions.map((s) => {
+                    const parsed = parseFormattedSessionKey(s.sessionKey);
+                    // Estimate tokens from message count for list view (avoids loading full session data).
+                    // Rough heuristic: ~500 tokens per message on average (user + assistant turns).
+                    // Exact counts are available in session.history when a specific session is opened.
+                    const totalTokens = s.messageCount * 500;
+                    return {
+                        sessionKey: s.sessionKey,
+                        agentId: parsed?.agentId ?? "default",
+                        userId: s.userId,
+                        channelId: s.channelId,
+                        kind: s.metadata.parentSessionKey
+                            ? "sub-agent"
+                            : parsed?.guildId
+                                ? "group"
+                                : "dm",
+                        messageCount: s.messageCount,
+                        totalTokens,
+                        updatedAt: s.updatedAt,
+                        createdAt: s.createdAt,
+                    };
+                }),
+                total: sessions.length,
+            };
+            if (IS_DEV)
+                SessionListContract.response.parse(result);
+            return result;
+        },
+        [SessionSearchContract.method]: async (rawParams) => {
+            // Internal-field reads BEFORE strip (caller-scoping)
+            const callerAgentId = rawParams._agentId;
+            const tenantId = rawParams._tenantId;
+            const userParams = stripInternalFields(rawParams);
+            const params = SessionSearchContract.request.parse(userParams);
+            const query = params.query;
+            const scope = params.scope ?? "all";
+            const shouldSummarize = params.summarize !== false;
+            let sessions = deps.sessionStore.listDetailed(tenantId);
+            // AgentId scoping: when _agentId is provided, filter to caller's sessions
+            if (callerAgentId) {
+                sessions = sessions.filter((s) => {
+                    const parsed = parseFormattedSessionKey(s.sessionKey);
+                    return parsed?.agentId === callerAgentId;
+                });
+            }
+            // Recent-sessions mode: no query provided
+            if (!query) {
+                const recentLimit = Math.min(Math.max(params.limit ?? 10, 1), 30);
+                const recentSessions = sessions.slice(0, recentLimit).map((s) => {
+                    const parsed = parseFormattedSessionKey(s.sessionKey);
+                    return {
+                        sessionKey: s.sessionKey,
+                        agentId: parsed?.agentId ?? "default",
+                        channelType: s.metadata.parentSessionKey !== undefined
+                            ? "sub-agent"
+                            : parsed?.guildId
+                                ? "group"
+                                : "dm",
+                        messageCount: s.messageCount,
+                        updatedAt: s.updatedAt,
+                        createdAt: s.createdAt,
+                    };
+                });
+                return { mode: "recent", sessions: recentSessions, total: recentSessions.length };
+            }
+            // Search mode: query provided
+            const limit = Math.min(Math.max(params.limit ?? 10, 1), 50);
+            const results = [];
+            const queryLower = query.toLowerCase();
+            for (const session of sessions) {
+                if (results.length >= limit)
+                    break;
+                const data = deps.sessionStore.loadByFormattedKey(session.sessionKey);
+                if (!data)
+                    continue;
+                let bestMatch;
+                for (const msg of data.messages) {
+                    const m = msg;
+                    const role = m.role;
+                    // Scope filter: skip messages that don't match the requested scope
+                    if (scope !== "all") {
+                        if (scope === "tool") {
+                            if (role !== "tool" && role !== "toolResult")
+                                continue;
+                        }
+                        else if (role !== scope) {
+                            continue;
+                        }
+                    }
+                    // Extract text content from message
+                    let text = "";
+                    if (typeof m.content === "string") {
+                        text = m.content;
+                    }
+                    else if (Array.isArray(m.content)) {
+                        for (const part of m.content) {
+                            if (part.type === "text" && typeof part.text === "string") {
+                                text += part.text;
+                            }
+                        }
+                    }
+                    if (!text)
+                        continue;
+                    const textLower = text.toLowerCase();
+                    const matchIdx = textLower.indexOf(queryLower);
+                    if (matchIdx === -1)
+                        continue;
+                    // Build snippet: up to 200 chars surrounding the match
+                    const snippetStart = Math.max(0, matchIdx - 80);
+                    const snippetEnd = Math.min(text.length, matchIdx + query.length + 120);
+                    const snippet = (snippetStart > 0 ? "..." : "") +
+                        text.slice(snippetStart, snippetEnd) +
+                        (snippetEnd < text.length ? "..." : "");
+                    const score = 1.0;
+                    const timestamp = m.timestamp ?? session.updatedAt;
+                    // Keep best (first) match per session
+                    if (!bestMatch) {
+                        bestMatch = { snippet, score, timestamp };
+                    }
+                }
+                if (bestMatch) {
+                    const parsed = parseFormattedSessionKey(session.sessionKey);
+                    const isSubAgent = session.metadata.parentSessionKey !== undefined;
+                    const channelType = isSubAgent
+                        ? "sub-agent"
+                        : parsed?.guildId
+                            ? "group"
+                            : "dm";
+                    results.push({
+                        sessionKey: session.sessionKey,
+                        agentId: parsed?.agentId ?? "default",
+                        channelType,
+                        snippet: bestMatch.snippet,
+                        score: bestMatch.score,
+                        timestamp: bestMatch.timestamp,
+                    });
+                }
+            }
+            // LLM summarization: when enabled and summarizer is available
+            if (shouldSummarize && deps.summarizeSession && results.length > 0) {
+                const summarizeCap = Math.min(results.length, 5);
+                const summaryPromises = results.slice(0, summarizeCap).map(async (result) => {
+                    const data = deps.sessionStore.loadByFormattedKey(result.sessionKey);
+                    if (!data)
+                        return null;
+                    return deps.summarizeSession(data.messages, query);
+                });
+                const settled = await Promise.allSettled(summaryPromises);
+                for (let i = 0; i < summarizeCap; i++) {
+                    const outcome = settled[i];
+                    if (outcome.status === "fulfilled" && outcome.value) {
+                        results[i].rawSnippet = results[i].snippet;
+                        results[i].summary = outcome.value;
+                    }
+                }
+            }
+            return { mode: "search", results, total: results.length };
+        },
+    };
+}

package/node_modules/@comis/daemon/dist/api/session-handlers/session-mutate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session mutation RPC handlers.
+ *
+ * Handlers that route or trigger work on behalf of a session:
+ *   - session.send: cross-session message routing (fire-and-forget / wait / ping-pong)
+ *   - session.spawn: spawn a sub-agent (async or sync awaited)
+ *   - session.compact: trigger compaction for an existing session
+ *
+ * @module
+ */
+import type { RpcHandler } from "../types.js";
+import { type SessionHandlerDeps } from "./session-helpers.js";
+/**
+ * Bind the session mutation handlers. Object-spread compatible with
+ * `Record<string, RpcHandler>`.
+ */
+export declare function bindSessionMutateHandlers(deps: SessionHandlerDeps): Record<string, RpcHandler>;