gisool 0.0.0-stage → 0.1.0

package/dist/ingest/hooks.js

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+const SKILL_FILE_IN_PATH = /[\\/]([^\\/]+)[\\/]SKILL\.md$/;
+const SKILL_FILE_IN_COMMAND = /[\\/]([^\\/\s'"`]+)[\\/]SKILL\.md(?![\w.])/g;
+export function str(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function obj(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+export function skillNameFromPath(path) {
+    return path ? SKILL_FILE_IN_PATH.exec(path)?.[1] : undefined;
+}
+export function skillNamesInCommand(command) {
+    if (!command)
+        return [];
+    const names = new Set();
+    for (const match of command.matchAll(SKILL_FILE_IN_COMMAND))
+        names.add(match[1]);
+    return [...names];
+}
+function commandText(value) {
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === "string").join(" ");
+    return str(value);
+}
+export function makeEvent(kind, source, ref, ts, extra = {}) {
+    return { id: randomUUID(), ts, kind, source, ref, data: {}, ...extra };
+}
+function promptEvent(ref, ts, prompt, data = {}) {
+    const text = typeof prompt === "string" ? prompt : undefined;
+    return makeEvent("prompt", "hook", ref, ts, text === undefined ? { data: { ...data, promptUnavailable: true } } : { text, data });
+}
+function nativeSkill(ref, ts, name, via, extra = {}, data = {}) {
+    return makeEvent("native_skill", "hook", ref, ts, { ...extra, data: { ...data, name, via } });
+}
+function fileReadSkills(ref, ts, toolName, input, toolUseId) {
+    const extra = toolUseId ? { toolUseId } : {};
+    if (toolName === "Read") {
+        const filePath = str(input?.file_path);
+        const name = skillNameFromPath(filePath);
+        return name ? [nativeSkill(ref, ts, name, "file_read", extra, { path: filePath, tool: "Read" })] : [];
+    }
+    if (toolName === "Bash" || toolName === "shell" || toolName === "local_shell") {
+        return skillNamesInCommand(commandText(input?.command)).map((name) => nativeSkill(ref, ts, name, "file_read", extra, { tool: toolName }));
+    }
+    return [];
+}
+function claudeCode(p, ts) {
+    const ref = { runtime: "claude-code", runtimeSessionId: str(p.session_id), cwd: str(p.cwd) };
+    const events = [];
+    const bindings = [];
+    switch (p.hook_event_name) {
+        case "UserPromptSubmit":
+            events.push(promptEvent(ref, ts, p.prompt, str(p.prompt_id) ? { promptId: p.prompt_id } : {}));
+            break;
+        case "SessionStart":
+            events.push(makeEvent("session_start", "hook", ref, ts, { data: { source: p.source } }));
+            break;
+        case "SessionEnd":
+            events.push(makeEvent("session_end", "hook", ref, ts, { data: { reason: p.reason } }));
+            break;
+        case "UserPromptExpansion": {
+            const name = str(p.command_name);
+            if (name && p.expansion_type === "slash_command")
+                events.push(nativeSkill(ref, ts, name, "expansion", {}, { commandSource: p.command_source }));
+            break;
+        }
+        case "PostToolUse": {
+            const toolName = str(p.tool_name);
+            const input = obj(p.tool_input);
+            const toolUseId = str(p.tool_use_id);
+            if (toolName?.startsWith("mcp__gisool__")) {
+                if (toolUseId && ref.runtimeSessionId)
+                    bindings.push({ toolUseId, ref });
+            }
+            else if (toolName === "Skill") {
+                const name = str(input?.skill) ?? str(input?.skill_name) ?? str(input?.name);
+                if (name)
+                    events.push(nativeSkill(ref, ts, name, "tool", toolUseId ? { toolUseId } : {}));
+            }
+            else {
+                events.push(...fileReadSkills(ref, ts, toolName, input, toolUseId));
+            }
+            break;
+        }
+    }
+    return { events, bindings };
+}
+function codex(p, ts) {
+    const ref = { runtime: "codex", runtimeSessionId: str(p.session_id), cwd: str(p.cwd) };
+    const events = [];
+    if (p.hook_event_name === "UserPromptSubmit")
+        events.push(promptEvent(ref, ts, p.prompt, str(p.turn_id) ? { turnId: p.turn_id } : {}));
+    else if (p.hook_event_name === "PostToolUse" && p.tool_name === "Bash")
+        events.push(...fileReadSkills(ref, ts, "Bash", obj(p.tool_input)));
+    else if (p.hook_event_name === "SessionStart")
+        events.push(makeEvent("session_start", "hook", ref, ts));
+    return { events, bindings: [] };
+}
+function gemini(p, ts) {
+    const ref = { runtime: "gemini", runtimeSessionId: str(p.session_id), cwd: str(p.cwd) };
+    const events = [];
+    switch (p.hook_event_name) {
+        case "BeforeAgent":
+            events.push(promptEvent(ref, ts, p.prompt));
+            break;
+        case "AfterTool": {
+            const input = obj(p.tool_input);
+            const name = p.tool_name === "activate_skill" ? str(input?.name) ?? str(input?.skill) : undefined;
+            if (name)
+                events.push(nativeSkill(ref, ts, name, "tool"));
+            break;
+        }
+        case "SessionStart":
+            events.push(makeEvent("session_start", "hook", ref, ts));
+            break;
+        case "SessionEnd":
+            events.push(makeEvent("session_end", "hook", ref, ts));
+            break;
+    }
+    return { events, bindings: [] };
+}
+function cursor(p, ts) {
+    const roots = Array.isArray(p.workspace_roots) ? p.workspace_roots : [];
+    const ref = { runtime: "cursor", conversationId: str(p.conversation_id), cwd: str(roots[0]) ?? str(p.cwd) };
+    const events = [];
+    if (p.hook_event_name === "beforeSubmitPrompt")
+        events.push(promptEvent(ref, ts, p.prompt, str(p.generation_id) ? { generationId: p.generation_id } : {}));
+    else if (p.hook_event_name === "sessionStart")
+        events.push(makeEvent("session_start", "hook", ref, ts));
+    else if (p.hook_event_name === "sessionEnd")
+        events.push(makeEvent("session_end", "hook", ref, ts));
+    return { events, bindings: [] };
+}
+function piForwarder(runtime, p, ts) {
+    if (p.event !== "before_agent_start")
+        return { events: [], bindings: [] };
+    const ref = { runtime, runtimeSessionId: str(p.sessionId), cwd: str(p.cwd) };
+    return { events: [promptEvent(ref, ts, p.prompt)], bindings: [] };
+}
+function openclaw(p, ts) {
+    if (p.event !== "before_agent_run" && p.event !== "message_received")
+        return { events: [], bindings: [] };
+    const sessionKey = str(p.sessionKey);
+    const ref = { runtime: "openclaw", runtimeSessionId: str(p.sessionId) ?? sessionKey };
+    return { events: [promptEvent(ref, ts, p.prompt, { hook: p.event, ...(sessionKey ? { sessionKey } : {}) })], bindings: [] };
+}
+/** Normalizes one raw hook payload; unrecognized events yield no events (the pipeline counts them as dropped). */
+export function normalizeHook(runtime, payload, now) {
+    const p = payload;
+    switch (runtime) {
+        case "claude-code":
+            return claudeCode(p, now);
+        case "codex":
+            return codex(p, now);
+        case "gemini":
+            return gemini(p, now);
+        case "cursor":
+            return cursor(p, now);
+        case "omo":
+        case "gajae":
+            return piForwarder(runtime, p, now);
+        case "openclaw":
+            return openclaw(p, now);
+        case "unknown":
+            return { events: [], bindings: [] };
+    }
+}

package/dist/ingest/mcp-recorder.js

@@ -0,0 +1,41 @@
+import { makeEvent, str } from "./hooks.js";
+import { runtimeFromClientName } from "./runtimes.js";
+/**
+ * Vendor _meta keys: Codex sends unprefixed `threadId` (-> conversationId) and `sessionId` (-> runtimeSessionId);
+ * Claude Code sends `claudecode/toolUseId`; OpenCode dev builds send `ai.opencode/sessionID`.
+ */
+export function mcpBase(ctx) {
+    const meta = ctx.meta ?? {};
+    const ref = { runtime: runtimeFromClientName(ctx.clientName) };
+    if (ctx.clientName)
+        ref.clientName = ctx.clientName;
+    const runtimeSessionId = str(meta.sessionId) ?? str(meta["ai.opencode/sessionID"]);
+    const conversationId = str(meta.threadId);
+    if (runtimeSessionId)
+        ref.runtimeSessionId = runtimeSessionId;
+    if (conversationId)
+        ref.conversationId = conversationId;
+    const toolUseId = str(meta["claudecode/toolUseId"]);
+    const data = ctx.mcpSessionId ? { mcpSessionId: ctx.mcpSessionId } : {};
+    return toolUseId ? { ref, toolUseId, data } : { ref, data };
+}
+function build(kind, ctx, ts, extra, data) {
+    const base = mcpBase(ctx);
+    return makeEvent(kind, "mcp", base.ref, ts, { ...(base.toolUseId ? { toolUseId: base.toolUseId } : {}), ...extra, data: { ...base.data, ...data } });
+}
+export function searchEvent(ctx, outcome, opts, ts) {
+    const data = {
+        query: outcome.query, mode: outcome.mode, candidates: outcome.candidates, elapsedMs: outcome.elapsedMs, total: opts.total, chosen: opts.chosen ?? [],
+        ...(outcome.abstained ? { abstained: outcome.abstained } : {}),
+    };
+    return build("search", ctx, ts, { traceId: outcome.traceId, text: outcome.query }, data);
+}
+export function loadEvent(ctx, load, ts) {
+    return build("load", ctx, ts, { skillUri: load.uri, loadId: load.loadId, ...(load.traceId ? { traceId: load.traceId } : {}) }, { uri: load.uri, loadId: load.loadId, manifestDigest: load.manifestDigest });
+}
+export function readFileEvent(ctx, read, ts) {
+    return build("read_file", ctx, ts, { skillUri: read.skillUri, ...(read.loadId ? { loadId: read.loadId } : {}), ...(read.traceId ? { traceId: read.traceId } : {}) }, { skillUri: read.skillUri, uri: read.uri, bytes: read.bytes });
+}
+export function errorEvent(ctx, err, ts) {
+    return build("error", ctx, ts, { ...(err.traceId ? { traceId: err.traceId } : {}), ...(err.skillUri ? { skillUri: err.skillUri } : {}), ...(err.loadId ? { loadId: err.loadId } : {}) }, { code: err.code, message: err.message, ...(err.tool ? { tool: err.tool } : {}) });
+}

package/dist/ingest/otlp.js

@@ -0,0 +1,160 @@
+import { makeEvent, skillNameFromPath, skillNamesInCommand, str } from "./hooks.js";
+function decode(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    if (value.stringValue !== undefined)
+        return value.stringValue;
+    if (value.boolValue !== undefined)
+        return value.boolValue;
+    if (value.intValue !== undefined)
+        return Number(value.intValue);
+    if (value.doubleValue !== undefined)
+        return value.doubleValue;
+    if (value.arrayValue)
+        return (value.arrayValue.values ?? []).map(decode);
+    if (value.kvlistValue)
+        return toAttrs(value.kvlistValue.values);
+    if (value.bytesValue !== undefined)
+        return value.bytesValue;
+    return undefined;
+}
+function toAttrs(list) {
+    const out = {};
+    if (!Array.isArray(list))
+        return out;
+    for (const kv of list)
+        if (kv && typeof kv.key === "string")
+            out[kv.key] = decode(kv.value);
+    return out;
+}
+function parseJsonObject(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined; // tool_input is truncated at ~4 KB by Claude Code, so unparseable JSON is expected and simply carries no path.
+    }
+}
+function tsOf(record, now) {
+    const nanos = Number(record.timeUnixNano ?? 0) || Number(record.observedTimeUnixNano ?? 0);
+    return nanos > 0 ? Math.floor(nanos / 1e6) : now;
+}
+function eventNameOf(record, attrs, serviceHint) {
+    const candidates = [record.eventName, attrs["event.name"], decode(record.body)].filter((v) => typeof v === "string" && v.length > 0);
+    const prefixed = candidates.find((n) => n.startsWith("claude_code.") || n.startsWith("codex."));
+    if (prefixed)
+        return prefixed;
+    const bare = candidates[0];
+    if (!bare)
+        return undefined;
+    return serviceHint.includes("codex") ? `codex.${bare}` : `claude_code.${bare}`;
+}
+function promptText(attrs) {
+    const text = str(attrs.prompt) ?? str(attrs.prompt_text);
+    return text === "<REDACTED>" ? undefined : text;
+}
+// Claude Code tool_result attributes (https://code.claude.com/docs/en/monitoring-usage.md, "Tool result event"):
+// `tool_name`, `tool_use_id`, and with OTEL_LOG_TOOL_DETAILS=1 `tool_parameters` (JSON string: Bash `bash_command`/`full_command`,
+// MCP `mcp_server_name`/`mcp_tool_name`, Skill `skill_name`) and `tool_input` (JSON-serialized arguments, e.g. Read `file_path`).
+function claudeToolResult(attrs, ref, ts) {
+    const toolName = str(attrs.tool_name);
+    const params = parseJsonObject(attrs.tool_parameters) ?? {};
+    const input = parseJsonObject(attrs.tool_input) ?? {};
+    const mcpServer = str(attrs.mcp_server_name) ?? str(params.mcp_server_name) ?? "";
+    if (mcpServer.toLowerCase().includes("gisool") || toolName?.startsWith("mcp__gisool__"))
+        return "ignored";
+    const toolUseId = str(attrs.tool_use_id);
+    const extra = toolUseId ? { toolUseId } : {};
+    if (toolName === "Read") {
+        const filePath = str(input.file_path) ?? str(params.file_path);
+        const name = skillNameFromPath(filePath);
+        return name ? [makeEvent("native_skill", "otel", ref, ts, { ...extra, data: { name, via: "file_read", path: filePath, tool: "Read" } })] : [];
+    }
+    if (toolName === "Bash") {
+        const command = str(params.full_command) ?? str(params.bash_command) ?? str(input.command);
+        return skillNamesInCommand(command).map((name) => makeEvent("native_skill", "otel", ref, ts, { ...extra, data: { name, via: "file_read", tool: "Bash" } }));
+    }
+    return [];
+}
+function mapRecord(name, attrs, ts) {
+    if (name.startsWith("claude_code.")) {
+        const ref = { runtime: "claude-code", runtimeSessionId: str(attrs["session.id"]) };
+        switch (name) {
+            case "claude_code.user_prompt": {
+                const text = promptText(attrs);
+                const promptLength = typeof attrs.prompt_length === "number" ? attrs.prompt_length : undefined;
+                const data = { promptId: str(attrs["prompt.id"]) };
+                if (text === undefined)
+                    Object.assign(data, { promptUnavailable: true, promptLength });
+                return [makeEvent("prompt", "otel", ref, ts, { ...(text !== undefined ? { text } : {}), data })];
+            }
+            case "claude_code.skill_activated": {
+                const skill = str(attrs["skill.name"]);
+                if (!skill)
+                    return "ignored";
+                return [makeEvent("native_skill", "otel", ref, ts, { data: { name: skill, via: "otel", trigger: str(attrs.invocation_trigger), source: str(attrs["skill.source"]) } })];
+            }
+            case "claude_code.tool_result":
+                return claudeToolResult(attrs, ref, ts);
+            default:
+                return "unknown";
+        }
+    }
+    if (name.startsWith("codex.")) {
+        const ref = { runtime: "codex", conversationId: str(attrs["conversation.id"]) };
+        switch (name) {
+            case "codex.user_prompt": {
+                const text = promptText(attrs);
+                return [makeEvent("prompt", "otel", ref, ts, text !== undefined ? { text } : { data: { promptUnavailable: true } })];
+            }
+            case "codex.skill_invocation": {
+                const skill = str(attrs["skill.name"]);
+                if (!skill)
+                    return "ignored";
+                return [makeEvent("native_skill", "otel", ref, ts, { data: { name: skill, via: "otel", scope: str(attrs["skill.scope"]), invocationType: str(attrs["skill.invocation_type"]) } })];
+            }
+            case "codex.conversation_starts":
+                return [makeEvent("session_start", "otel", ref, ts)];
+            default:
+                return "unknown";
+        }
+    }
+    return "unknown";
+}
+function badOtlp(message) {
+    return { ok: false, status: 400, error: { code: "bad_otlp", message } };
+}
+/** Parses an OTLP/HTTP JSON logs export into CanonicalEvents; unknown event names are counted, not stored. */
+export function parseOtlpLogs(body, now) {
+    if (body === null || typeof body !== "object" || Array.isArray(body))
+        return badOtlp("body must be an ExportLogsServiceRequest JSON object");
+    const resourceLogs = body.resourceLogs;
+    if (!Array.isArray(resourceLogs))
+        return badOtlp("resourceLogs must be an array");
+    const events = [];
+    let unknown = 0;
+    let ignored = 0;
+    for (const rl of resourceLogs) {
+        const resourceAttrs = toAttrs(rl?.resource?.attributes);
+        const scopeLogs = Array.isArray(rl?.scopeLogs) ? rl.scopeLogs : [];
+        for (const sl of scopeLogs) {
+            const serviceHint = `${String(resourceAttrs["service.name"] ?? "")} ${sl?.scope?.name ?? ""}`.toLowerCase();
+            const records = Array.isArray(sl?.logRecords) ? sl.logRecords : [];
+            for (const record of records) {
+                const attrs = { ...resourceAttrs, ...toAttrs(record?.attributes) };
+                const name = record ? eventNameOf(record, attrs, serviceHint) : undefined;
+                const mapped = name ? mapRecord(name, attrs, tsOf(record, now)) : "unknown";
+                if (mapped === "unknown")
+                    unknown += 1;
+                else if (mapped === "ignored")
+                    ignored += 1;
+                else
+                    events.push(...mapped);
+            }
+        }
+    }
+    return { ok: true, events, unknown, ignored, response: { partialSuccess: {} } };
+}

package/dist/ingest/pipeline.js

@@ -0,0 +1,100 @@
+import { attribute, createAttributionState, remember } from "./attribution.js";
+import { normalizeHook } from "./hooks.js";
+import { parseOtlpLogs } from "./otlp.js";
+import { applyCapture } from "./redact.js";
+export function createIngestDeps(store, opts = {}) {
+    return { store, captureLevel: opts.captureLevel ?? "full", state: opts.state ?? createAttributionState(), publish: opts.publish, log: opts.log, now: opts.now };
+}
+function nowOf(deps) {
+    return deps.now ? deps.now() : Date.now();
+}
+function logError(deps, message, error) {
+    if (deps.log)
+        deps.log(message, error);
+    else
+        console.error(`[gisool ingest] ${message}`, error);
+}
+function count(deps, kind, code) {
+    try {
+        deps.store.countIngest(kind, code);
+    }
+    catch (error) {
+        logError(deps, `countIngest(${kind}) failed`, error);
+    }
+}
+function capture(event, level) {
+    if (event.text === undefined)
+        return event;
+    const captured = applyCapture(level, event.text);
+    const { text: _dropped, ...rest } = event;
+    const next = { ...rest, textDigest: captured.textDigest, textLength: captured.textLength };
+    if (captured.text !== undefined)
+        next.text = captured.text;
+    if (event.kind === "search" && typeof event.data.query === "string")
+        next.data = { ...event.data, query: captured.text ?? "" };
+    return next;
+}
+/**
+ * capture -> attribute -> store.append -> publish, fully synchronous. Errors are logged, counted as
+ * rejected `ingest_error`, and swallowed so one bad event never breaks a batch or blocks an agent.
+ */
+export function ingest(event, deps) {
+    try {
+        const level = typeof deps.captureLevel === "function" ? deps.captureLevel() : deps.captureLevel;
+        const captured = capture(event, level);
+        const attribution = attribute(captured, deps.store, nowOf(deps), deps.state);
+        deps.store.append(captured, attribution);
+        if (captured.loadId && attribution.sessionId !== "unattributed")
+            remember(deps.state.loadSessions, captured.loadId, attribution.sessionId);
+        count(deps, "accepted");
+        if (deps.publish && attribution.sessionId !== "unattributed")
+            deps.publish({ sessionId: attribution.sessionId, attribution, event: captured });
+        return attribution;
+    }
+    catch (error) {
+        logError(deps, `failed to ingest ${event.kind} event ${event.id}`, error);
+        count(deps, "rejected", "ingest_error");
+        return undefined;
+    }
+}
+/** Binds Claude tool_use_ids to sessions in either arrival order and ingests the hook's events. */
+export function ingestHook(runtime, payload, deps) {
+    const now = nowOf(deps);
+    const { events, bindings } = normalizeHook(runtime, payload, now);
+    for (const binding of bindings) {
+        try {
+            const sessionId = deps.store.upsertSession(binding.ref, now);
+            remember(deps.state.toolUseSessions, binding.toolUseId, sessionId);
+            const eventId = deps.store.findEventByToolUseId(binding.toolUseId);
+            if (eventId) {
+                deps.store.reattribute(eventId, sessionId, "vendor_meta");
+                deps.publish?.({ sessionId, attribution: { sessionId, method: "vendor_meta" } });
+            }
+        }
+        catch (error) {
+            logError(deps, `failed to bind tool_use_id ${binding.toolUseId}`, error);
+            count(deps, "rejected", "ingest_error");
+        }
+    }
+    if (events.length === 0 && bindings.length === 0) {
+        count(deps, "dropped", "unknown_event");
+        return { accepted: 0, dropped: 1 };
+    }
+    let accepted = 0;
+    for (const event of events)
+        if (ingest(event, deps))
+            accepted += 1;
+    return { accepted, dropped: 0 };
+}
+export function ingestOtlp(body, deps) {
+    const parsed = parseOtlpLogs(body, nowOf(deps));
+    if (!parsed.ok) {
+        count(deps, "rejected", parsed.error.code);
+        return { status: 400, body: parsed.error };
+    }
+    for (let i = 0; i < parsed.unknown; i += 1)
+        count(deps, "dropped", "unknown_event");
+    for (const event of parsed.events)
+        ingest(event, deps);
+    return { status: 200, body: parsed.response };
+}

package/dist/ingest/redact.js

@@ -0,0 +1,36 @@
+import { createHash } from "node:crypto";
+export const REDACTED_MAX_CHARS = 2048;
+export const MASK = "[REDACTED]";
+export const SECRET_PATTERNS = [
+    /sk-[A-Za-z0-9]{20,}/g,
+    /ghp_[A-Za-z0-9]{30,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /xox[baprs]-[A-Za-z0-9-]+/g,
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    /Bearer [A-Za-z0-9._-]{20,}/g,
+];
+export function sha256Hex(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+export function maskSecrets(text) {
+    let out = text;
+    for (const pattern of SECRET_PATTERNS)
+        out = out.replace(pattern, MASK);
+    return out;
+}
+/**
+ * full -> text unchanged; redacted -> secrets masked then truncated to 2048 chars;
+ * metadata -> text dropped. Digest and length always describe the original text.
+ */
+export function applyCapture(level, text) {
+    const textDigest = sha256Hex(text);
+    const textLength = text.length;
+    switch (level) {
+        case "full":
+            return { text, textDigest, textLength };
+        case "redacted":
+            return { text: maskSecrets(text).slice(0, REDACTED_MAX_CHARS), textDigest, textLength };
+        case "metadata":
+            return { textDigest, textLength };
+    }
+}

package/dist/ingest/runtimes.js

@@ -0,0 +1,25 @@
+const EXACT = {
+    "claude-code": "claude-code",
+    "codex-mcp-client": "codex",
+    "gemini-cli-mcp-client": "gemini",
+    "senpi-mcp-client": "omo", // verified OmO 5 client name
+    opencode: "omo",
+    "gjc-coding-agent": "gajae",
+};
+export function runtimeFromClientName(name) {
+    if (!name)
+        return "unknown";
+    const exact = EXACT[name];
+    if (exact)
+        return exact;
+    const lower = name.toLowerCase();
+    if (lower.startsWith("cursor"))
+        return "cursor";
+    if (lower.includes("openclaw"))
+        return "openclaw";
+    return "unknown";
+}
+export const RUNTIME_IDS = ["claude-code", "codex", "gemini", "cursor", "omo", "gajae", "openclaw", "unknown"];
+export function isRuntimeId(value) {
+    return RUNTIME_IDS.includes(value);
+}

package/dist/mcp/http.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { bearerOf, safeEqual } from "../api/security.js";
+import { createMcpServer } from "./tools.js";
+export const SESSION_IDLE_MS = 24 * 60 * 60 * 1000;
+function rpcError(res, status, message) {
+    res.status(status).json({ jsonrpc: "2.0", error: { code: -32000, message }, id: null });
+}
+export function registerMcp(app, deps) {
+    const sessions = new Map();
+    const idleMs = deps.idleMs ?? SESSION_IDLE_MS;
+    const auth = (req, res, next) => {
+        if (deps.token && !safeEqual(bearerOf(req), deps.token)) {
+            res.status(401).json({ error: "unauthorized" });
+            return;
+        }
+        next();
+    };
+    const existing = (req) => {
+        const id = req.header("mcp-session-id");
+        const session = id ? sessions.get(id) : undefined;
+        if (session)
+            session.lastSeen = Date.now();
+        return session;
+    };
+    const closeSession = async (id) => {
+        const session = sessions.get(id);
+        if (!session)
+            return;
+        sessions.delete(id);
+        await session.transport.close().catch(() => undefined);
+        await session.server.close().catch(() => undefined);
+    };
+    app.post("/mcp", auth, express.json({ limit: "4mb" }), async (req, res) => {
+        const id = req.header("mcp-session-id");
+        let session = existing(req);
+        if (id && !session)
+            return rpcError(res, 404, "Unknown or expired MCP session; reinitialize");
+        if (!session) {
+            if (!isInitializeRequest(req.body))
+                return rpcError(res, 400, "Missing mcp-session-id; send initialize first");
+            const server = createMcpServer(deps);
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: randomUUID,
+                onsessioninitialized: (sid) => { sessions.set(sid, created); },
+            });
+            const created = { server, transport, lastSeen: Date.now() };
+            transport.onclose = () => {
+                const sid = transport.sessionId;
+                if (sid && sessions.get(sid) === created)
+                    sessions.delete(sid);
+            };
+            await server.connect(transport);
+            session = created;
+        }
+        await session.transport.handleRequest(req, res, req.body);
+    });
+    const handleSessionRequest = async (req, res) => {
+        const session = existing(req);
+        if (!session)
+            return rpcError(res, req.header("mcp-session-id") ? 404 : 400, "Unknown or missing mcp-session-id");
+        await session.transport.handleRequest(req, res);
+    };
+    app.get("/mcp", auth, handleSessionRequest);
+    app.delete("/mcp", auth, handleSessionRequest);
+    const sweep = (now = Date.now()) => {
+        const stale = [...sessions.entries()].filter(([, s]) => now - s.lastSeen > idleMs).map(([sid]) => sid);
+        for (const sid of stale)
+            void closeSession(sid);
+        return stale.length;
+    };
+    const timer = setInterval(sweep, deps.sweepMs ?? 60 * 60 * 1000);
+    timer.unref();
+    return {
+        sessionCount: () => sessions.size,
+        sweep,
+        async close() {
+            clearInterval(timer);
+            await Promise.all([...sessions.keys()].map(closeSession));
+        },
+    };
+}

package/dist/mcp/skills-extension.js

@@ -0,0 +1,35 @@
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+export const SKILLS_EXTENSION_ID = "io.modelcontextprotocol/skills";
+const SkillsListRequestSchema = z.object({
+    method: z.literal("skills/list"),
+    params: z.object({ cursor: z.string().optional() }).passthrough().optional(),
+});
+const SkillsGetRequestSchema = z.object({
+    method: z.literal("skills/get"),
+    params: z.object({ uri: z.string() }).passthrough(),
+});
+function toWire(entry) {
+    return {
+        uri: entry.uri,
+        frontmatter: {
+            name: entry.name,
+            description: entry.description,
+            ...(entry.invocation === "explicit" ? { "disable-model-invocation": true } : {}),
+            ...(entry.tags.length ? { keywords: entry.tags } : {}),
+        },
+        resources: entry.resources.map(({ uri, digest, size }) => ({ uri, digest, size })),
+    };
+}
+export function registerSkillsExtension(server, catalog) {
+    server.server.registerCapabilities({ extensions: { [SKILLS_EXTENSION_ID]: {} } });
+    server.server.setRequestHandler(SkillsListRequestSchema, async () => ({
+        skills: [...catalog.list()].sort((a, b) => a.name.localeCompare(b.name)).map(toWire),
+    }));
+    server.server.setRequestHandler(SkillsGetRequestSchema, async (request) => {
+        const entry = catalog.get(request.params.uri);
+        if (!entry)
+            throw new McpError(ErrorCode.InvalidParams, `Not a skill served by this server: ${request.params.uri}`);
+        return { skill: toWire(entry) };
+    });
+}