gisool 0.0.0-stage → 0.1.0

package/dist/mcp/stdio-proxy.js

@@ -0,0 +1,53 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, CallToolResultSchema, ErrorCode, ListToolsRequestSchema, ListToolsResultSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { packageVersion, SERVER_INSTRUCTIONS } from "./tools.js";
+/**
+ * Bridges a stdio MCP client to the daemon's Streamable HTTP endpoint. The upstream connection opens lazily after the
+ * downstream initialize so the daemon sees the real client name (runtime attribution depends on it).
+ */
+export async function runStdioProxy(opts) {
+    const version = packageVersion();
+    const server = new Server({ name: "gisool", version }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+    let upstream;
+    const connect = async () => {
+        const info = server.getClientVersion();
+        const client = new Client({ name: info?.name ?? "gisool-stdio-proxy", version: info?.version ?? version });
+        const transport = new StreamableHTTPClientTransport(new URL(`http://127.0.0.1:${opts.port}/mcp`), {
+            requestInit: { headers: { Authorization: `Bearer ${opts.token}` } },
+        });
+        try {
+            await client.connect(transport);
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `gisool daemon is not reachable on 127.0.0.1:${opts.port}; run \`gisool serve\` (${error.message})`);
+        }
+        client.onclose = () => { upstream = undefined; };
+        return client;
+    };
+    const client = () => {
+        upstream ??= connect().catch((error) => { upstream = undefined; throw error; });
+        return upstream;
+    };
+    server.setRequestHandler(ListToolsRequestSchema, async (request) => (await client()).request({ method: "tools/list", params: request.params }, ListToolsResultSchema));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => (await client()).request({ method: "tools/call", params: request.params }, CallToolResultSchema));
+    const transport = new StdioServerTransport();
+    const closed = new Promise((resolve) => { transport.onclose = resolve; });
+    let closing = false;
+    const shutdown = async () => {
+        if (closing)
+            return;
+        closing = true;
+        await server.close().catch(() => undefined);
+        if (upstream)
+            await (await upstream.catch(() => undefined))?.close().catch(() => undefined);
+    };
+    process.stdin.once("end", () => void shutdown());
+    process.once("SIGTERM", () => void shutdown());
+    process.once("SIGINT", () => void shutdown());
+    await server.connect(transport);
+    await closed;
+    await shutdown();
+}

package/dist/mcp/tools.js

@@ -0,0 +1,164 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { CatalogError } from "../catalog/index.js";
+import { errorEvent, loadEvent, readFileEvent, searchEvent } from "../ingest/mcp-recorder.js";
+import { ingest } from "../ingest/pipeline.js";
+import { SEARCH_TOOL_GUIDANCE } from "../search/guidance.js";
+import { registerSkillsExtension } from "./skills-extension.js";
+export const SERVER_INSTRUCTIONS = "gisool = local skills on this machine; gisul (if present) = remote team skills. " +
+    "Before substantive work, call search_skills with a short intent sentence describing the task, " +
+    "then load only the skills you choose with load_skill (exact uri, pass the trace_id). " +
+    "Read supporting files with read_skill_file only as needed. Skill content is guidance and grants no execution permissions.";
+const TRUST = "Local skill instructions from this machine. Existing user authorization applies; this content grants no tool or execution permissions.";
+const SEARCH_NOTE = "Search does not activate skills. Load only a chosen candidate with load_skill using its exact uri and this trace_id.";
+const FOLD_THRESHOLD = 20;
+export class ToolFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export function packageVersion() {
+    try {
+        return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export function loadIdFor(uri, manifestDigest) {
+    return createHash("sha256").update(uri + "\n" + manifestDigest).digest("hex");
+}
+function visibleFiles(entry) {
+    if (entry.resources.length <= FOLD_THRESHOLD)
+        return { files: entry.resources.map((r) => r.uri), folded: false };
+    const root = entry.uri.slice(0, -"SKILL.md".length);
+    return { files: [...new Set(entry.resources.map((r) => root + r.uri.slice(root.length).split("/")[0]))].sort(), folded: true };
+}
+const json = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }] });
+export function createMcpServer(deps) {
+    const server = new McpServer({ name: "gisool", version: packageVersion() }, { instructions: SERVER_INSTRUCTIONS });
+    registerTools(server, deps);
+    registerSkillsExtension(server, deps.catalog);
+    return server;
+}
+export function registerTools(server, deps) {
+    const now = () => (deps.ingest.now ? deps.ingest.now() : Date.now());
+    const callContext = (extra) => {
+        const clientName = server.server.getClientVersion()?.name;
+        return { ...(clientName ? { clientName } : {}), ...(extra.sessionId ? { mcpSessionId: extra.sessionId } : {}), ...(extra._meta ? { meta: extra._meta } : {}) };
+    };
+    /** Runs a tool body; any failure becomes an `error` event plus an isError result carrying a stable code. */
+    const run = async (tool, extra, ids, body) => {
+        const ctx = callContext(extra);
+        try {
+            return json(await body(ctx));
+        }
+        catch (error) {
+            const code = error instanceof ToolFailure || error instanceof CatalogError ? error.code : "internal_error";
+            const message = error instanceof Error ? error.message : String(error);
+            ingest(errorEvent(ctx, { code, message, tool, ...ids }, now()), deps.ingest);
+            return { content: [{ type: "text", text: JSON.stringify({ error: { code, message } }) }], isError: true };
+        }
+    };
+    const annotations = { readOnlyHint: true, destructiveHint: false, openWorldHint: false };
+    server.registerTool("search_skills", {
+        description: `Find local skills for the current task without reading their bodies. ${SEARCH_TOOL_GUIDANCE} Returns ranked candidates and a trace_id; pass the trace_id to load_skill.`,
+        inputSchema: {
+            query: z.string().max(2048).optional(),
+            mode: z.enum(["discovery", "automatic", "explicit"]).default("discovery"),
+            limit: z.number().int().min(1).max(50).default(5),
+            offset: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).default(0),
+        },
+        annotations,
+    }, async ({ query, mode, limit, offset }, extra) => run("search_skills", extra, {}, async (ctx) => {
+        const all = deps.search.search(query ?? "", { mode, limit: Math.max(1, deps.catalog.list().length) });
+        const page = all.candidates.slice(offset, offset + limit);
+        const outcome = { ...all, candidates: page };
+        ingest(searchEvent(ctx, outcome, { total: all.candidates.length }, now()), deps.ingest);
+        return {
+            trace_id: outcome.traceId,
+            candidates: page.map(({ uri, name, description, score, rank, invocation, digest }) => ({ uri, name, description, score, rank, invocation, digest })),
+            ...(outcome.abstained ? { abstained: outcome.abstained } : {}),
+            total: all.candidates.length,
+            note: SEARCH_NOTE,
+        };
+    }));
+    server.registerTool("load_skill", {
+        description: "Load a chosen local SKILL.md by its exact uri from search_skills (pass trace_id). Returns the verified markdown, its file list and a load_id for read_skill_file.",
+        inputSchema: { uri: z.string().max(4096), trace_id: z.string().max(128).optional() },
+        annotations,
+    }, async ({ uri, trace_id }, extra) => run("load_skill", extra, { ...(trace_id ? { traceId: trace_id } : {}), skillUri: uri }, async (ctx) => {
+        let entry = deps.catalog.get(uri);
+        if (!entry) {
+            await deps.catalog.refresh();
+            entry = deps.catalog.get(uri);
+        }
+        if (!entry)
+            throw new ToolFailure("unknown_skill", `Not a skill in the local catalog: ${uri}; use an exact uri returned by search_skills`);
+        let skill;
+        try {
+            skill = await deps.catalog.readResource(entry.uri);
+        }
+        catch (error) {
+            if (!(error instanceof CatalogError && error.code === "digest_mismatch"))
+                throw error;
+            await deps.catalog.refresh();
+            entry = deps.catalog.get(uri);
+            if (!entry)
+                throw new ToolFailure("unknown_skill", `Skill was removed: ${uri}`);
+            skill = await deps.catalog.readResource(entry.uri);
+        }
+        const loadId = loadIdFor(entry.uri, entry.manifestDigest);
+        const previousId = deps.store.latestLoad(entry.uri);
+        const previous = previousId ? deps.store.getLoad(previousId) : undefined;
+        deps.store.putLoad({ loadId, ...(trace_id ? { traceId: trace_id } : {}), uri: entry.uri, manifestDigest: entry.manifestDigest, resources: entry.resources });
+        ingest(loadEvent(ctx, { uri: entry.uri, loadId, manifestDigest: entry.manifestDigest, ...(trace_id ? { traceId: trace_id } : {}) }, now()), deps.ingest);
+        const { files, folded } = visibleFiles(entry);
+        return {
+            load_id: loadId, uri: entry.uri, digest: entry.digest, manifest_digest: entry.manifestDigest, markdown: skill.text,
+            files, filesFolded: folded, changed: !!previous && previous.manifestDigest !== entry.manifestDigest, trust: TRUST,
+        };
+    }));
+    server.registerTool("read_skill_file", {
+        description: "Read a supporting file of a loaded skill. Pass load_id to pin the version you loaded; omitted load_id uses the latest load of skill_uri. Directory uris return a listing.",
+        inputSchema: { skill_uri: z.string().max(4096), uri: z.string().max(4096), load_id: z.string().regex(/^[a-f0-9]{64}$/).optional() },
+        annotations,
+    }, async ({ skill_uri, uri, load_id }, extra) => run("read_skill_file", extra, { skillUri: skill_uri, ...(load_id ? { loadId: load_id } : {}) }, async (ctx) => {
+        const loadId = load_id ?? deps.store.latestLoad(skill_uri);
+        const load = loadId ? deps.store.getLoad(loadId) : undefined;
+        if (!loadId || !load)
+            throw new ToolFailure("not_loaded", load_id ? "Unknown load_id; call load_skill first" : "Call load_skill for this skill first");
+        if (load.uri !== skill_uri)
+            throw new ToolFailure("load_mismatch", "load_id belongs to a different skill");
+        const version = { skill_uri, uri, load_id: loadId, manifest_digest: load.manifestDigest };
+        const file = load.resources.find((r) => r.uri === uri);
+        if (!file) {
+            const prefix = uri.endsWith("/") ? uri : `${uri}/`;
+            const children = load.resources.filter((r) => r.uri.startsWith(prefix));
+            if (!children.length)
+                throw new ToolFailure("outside_manifest", "File is not part of the loaded skill manifest");
+            const listing = [...new Set(children.map((r) => prefix + r.uri.slice(prefix.length).split("/")[0]))].sort();
+            ingest(readFileEvent(ctx, { skillUri: skill_uri, uri, bytes: 0, loadId }, now()), deps.ingest);
+            return { ...version, kind: "directory", files: listing, note: "Directory listing only; read a listed file when needed." };
+        }
+        let live;
+        try {
+            live = await deps.catalog.readResource(uri);
+        }
+        catch (error) {
+            if (error instanceof CatalogError && (error.code === "digest_mismatch" || error.code === "unknown_resource"))
+                live = { text: "", digest: "", size: -1 };
+            else
+                throw error;
+        }
+        if (live.digest !== file.digest || live.size !== file.size) {
+            throw new ToolFailure("skill_changed_since_load", "Skill changed since it was loaded; stop using this version and call load_skill again");
+        }
+        ingest(readFileEvent(ctx, { skillUri: skill_uri, uri, bytes: live.size, loadId }, now()), deps.ingest);
+        return { ...version, kind: "file", text: live.text, note: "Supporting content only; nested SKILL.md frontmatter is not activated." };
+    }));
+}

package/dist/packs/claude-code.js

@@ -0,0 +1,157 @@
+import { accessSync, constants, existsSync, readFileSync, statSync } from "node:fs";
+import { join, delimiter } from "node:path";
+const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const jsonEsc = (v) => JSON.stringify(v).slice(1, -1);
+function onPath(bin, env) {
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        const p = join(dir, bin);
+        try {
+            if (statSync(p).isFile()) {
+                accessSync(p, constants.X_OK);
+                return p;
+            }
+        }
+        catch { /* next */ }
+    }
+    return undefined;
+}
+const configDir = (c) => c.env.CLAUDE_CONFIG_DIR || join(c.home, ".claude");
+const settingsPath = (c) => join(configDir(c), "settings.json");
+const isLoopback = (u) => /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:|\/|$)/.test(u);
+function readText(p) {
+    try {
+        return readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function remoteRegistered(home) {
+    const text = readText(join(home, ".claude.json"));
+    if (text === null)
+        return false;
+    try {
+        const servers = JSON.parse(text).mcpServers;
+        const g = isObj(servers) ? servers.gisul : undefined;
+        if (!isObj(g))
+            return false;
+        if (typeof g.url === "string")
+            return !isLoopback(g.url);
+        return JSON.stringify(g).includes("mcp-remote");
+    }
+    catch {
+        return false;
+    }
+}
+const hasGisoolHook = (groups) => Array.isArray(groups) && groups.some(g => isObj(g) && Array.isArray(g.hooks) &&
+    g.hooks.some(h => isObj(h) && typeof h.command === "string" && h.command.includes("hook-post.mjs")));
+function template(ctx) {
+    const raw = readFileSync(join(ctx.packageRoot, "packs", "claude-code", "settings.template.json"), "utf8")
+        .replaceAll("{{PORT}}", String(ctx.port)).replaceAll("{{TOKEN}}", jsonEsc(ctx.token))
+        .replaceAll("{{NODE}}", jsonEsc(ctx.nodePath)).replaceAll("{{HOOK}}", jsonEsc(join(ctx.packageRoot, "packs", "hook-post.mjs")));
+    return JSON.parse(raw);
+}
+export const claudeCodePack = {
+    id: "claude-code",
+    async detect(ctx) {
+        const evidence = [];
+        const dir = configDir(ctx);
+        if (existsSync(dir))
+            evidence.push(dir);
+        const bin = onPath("claude", ctx.env);
+        if (bin)
+            evidence.push(bin);
+        return { installed: evidence.length > 0, evidence, remoteGisulRegistered: remoteRegistered(ctx.home) };
+    },
+    async plan(ctx) {
+        const plan = { files: [], commands: [], notes: [], conflicts: [] };
+        const path = settingsPath(ctx);
+        const before = readText(path);
+        let cfg = {};
+        if (before !== null) {
+            try {
+                const parsed = JSON.parse(before);
+                if (!isObj(parsed))
+                    throw new Error("not an object");
+                cfg = parsed;
+            }
+            catch {
+                plan.conflicts.push({ path, code: "unparseable_json", detail: "settings.json does not parse as a JSON object; refusing to edit" });
+                return plan;
+            }
+        }
+        const tpl = template(ctx);
+        const wantEnv = tpl.env;
+        const wantHooks = tpl.hooks;
+        if (cfg.env !== undefined && !isObj(cfg.env))
+            plan.conflicts.push({ path, code: "env_not_object", detail: "settings.json `env` is not an object" });
+        const env = isObj(cfg.env) ? cfg.env : {};
+        for (const [k, v] of Object.entries(wantEnv)) {
+            if (Object.hasOwn(env, k) && env[k] !== v) {
+                plan.conflicts.push({ path, code: "env_conflict", detail: `${k} is already set to a different value` });
+            }
+        }
+        if (cfg.hooks !== undefined && !isObj(cfg.hooks))
+            plan.conflicts.push({ path, code: "hooks_not_object", detail: "settings.json `hooks` is not an object" });
+        const hooks = isObj(cfg.hooks) ? cfg.hooks : {};
+        for (const ev of Object.keys(wantHooks)) {
+            if (hooks[ev] !== undefined && !Array.isArray(hooks[ev]))
+                plan.conflicts.push({ path, code: "hook_not_array", detail: `hooks.${ev} is not an array` });
+        }
+        if (plan.conflicts.length === 0) {
+            const nextEnv = { ...env, ...wantEnv };
+            const nextHooks = { ...hooks };
+            for (const [ev, groups] of Object.entries(wantHooks)) {
+                const existing = hooks[ev] ?? [];
+                nextHooks[ev] = hasGisoolHook(existing) ? existing : [...existing, ...groups];
+            }
+            const next = { ...cfg, env: nextEnv, hooks: nextHooks };
+            const after = JSON.stringify(next, null, 2) + "\n";
+            const same = before !== null && JSON.stringify(JSON.parse(before)) === JSON.stringify(next);
+            if (!same)
+                plan.files.push({ path, before, after, mode: 0o600 });
+        }
+        const argv = ["claude", "mcp", "add", "--transport", "http", "--scope", "user", "gisool",
+            `http://127.0.0.1:${ctx.port}/mcp`, "--header", `Authorization: Bearer ${ctx.token}`];
+        const shown = `claude mcp add --transport http --scope user gisool http://127.0.0.1:${ctx.port}/mcp --header "Authorization: Bearer ${ctx.token}"`;
+        if (onPath("claude", ctx.env) && !ctx.env.GISOOL_NO_CLI) {
+            plan.commands.push({ argv, description: "Register the gisool MCP server with Claude Code (user scope)",
+                undo: { argv: ["claude", "mcp", "remove", "--scope", "user", "gisool"], description: "Remove the gisool MCP server" } });
+        }
+        else {
+            plan.notes.push(`manual step: run ${shown}`);
+        }
+        if (ctx.disableRemote && remoteRegistered(ctx.home)) {
+            plan.notes.push("manual step: run claude mcp remove --scope user gisul");
+        }
+        return plan;
+    },
+    async doctorChecks(ctx) {
+        const path = settingsPath(ctx);
+        const text = readText(path);
+        let cfg = {};
+        let parsed = false;
+        if (text !== null) {
+            try {
+                const p = JSON.parse(text);
+                if (isObj(p)) {
+                    cfg = p;
+                    parsed = true;
+                }
+            }
+            catch { /* reported below */ }
+        }
+        const env = isObj(cfg.env) ? cfg.env : {};
+        const hooks = isObj(cfg.hooks) ? cfg.hooks : {};
+        const endpoint = `http://127.0.0.1:${ctx.port}/ingest/otlp/v1/logs`;
+        return [
+            { name: "claude-code settings.json parses", ok: parsed, detail: text === null ? `missing: ${path}` : parsed ? path : "invalid JSON" },
+            { name: "claude-code OTel env present", ok: env.CLAUDE_CODE_ENABLE_TELEMETRY === "1" && env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT === endpoint,
+                detail: String(env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT ?? "not set") },
+            { name: "claude-code hooks present", ok: hasGisoolHook(hooks.PostToolUse) && hasGisoolHook(hooks.UserPromptExpansion),
+                detail: "PostToolUse and UserPromptExpansion run hook-post.mjs" },
+        ];
+    },
+};

package/dist/packs/codex.js

@@ -0,0 +1,148 @@
+import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join, delimiter, resolve } from "node:path";
+const BEGIN = "# >>> gisool managed";
+const END = "# <<< gisool managed";
+const tomlEsc = (v) => JSON.stringify(v).slice(1, -1);
+function onPath(bin, env) {
+    for (const dir of (env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        const p = join(dir, bin);
+        try {
+            if (statSync(p).isFile()) {
+                accessSync(p, constants.X_OK);
+                return p;
+            }
+        }
+        catch { /* next */ }
+    }
+    return undefined;
+}
+const codexDir = (c) => c.env.CODEX_HOME || join(c.home, ".codex");
+const configPath = (c) => join(codexDir(c), "config.toml");
+function readText(p) {
+    try {
+        return readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function realOrResolved(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return resolve(p);
+    }
+}
+/** Splits text into the managed block (if any) and the rest. */
+function splitManaged(text) {
+    const s = text.indexOf(BEGIN);
+    if (s < 0)
+        return null;
+    const e = text.indexOf(END, s);
+    if (e < 0)
+        return null;
+    let end = e + END.length;
+    if (text[end] === "\n")
+        end++;
+    return { outside: text.slice(0, s) + text.slice(end), start: s, end };
+}
+const OTEL_RE = /^\s*(\[\[?\s*otel\s*(\]|\.)|otel\s*\.)/m;
+const GISOOL_TABLE_RE = /^\s*\[\s*mcp_servers\.gisool\s*\]/m;
+/** Returns the body of the [mcp_servers.gisul] table, or null. */
+function gisulTable(text) {
+    const m = /^\[\s*mcp_servers\.gisul\s*\][^\n]*\n?/m.exec(text);
+    if (!m)
+        return null;
+    const start = m.index + m[0].length;
+    const next = /^\s*\[/m.exec(text.slice(start));
+    const end = next ? start + next.index : text.length;
+    return { start, end, body: text.slice(start, end) };
+}
+function remoteRegistered(text) {
+    if (text === null)
+        return false;
+    const t = gisulTable(text);
+    if (!t)
+        return false;
+    const url = /^\s*url\s*=\s*"([^"]*)"/m.exec(t.body)?.[1];
+    if (url)
+        return !/^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:|\/|$)/.test(url);
+    return /mcp-remote/.test(t.body);
+}
+function block(ctx) {
+    return readFileSync(join(ctx.packageRoot, "packs", "codex", "config.template.toml"), "utf8")
+        .replaceAll("{{PORT}}", String(ctx.port)).replaceAll("{{TOKEN}}", tomlEsc(ctx.token));
+}
+export const codexPack = {
+    id: "codex",
+    async detect(ctx) {
+        const evidence = [];
+        const dir = codexDir(ctx);
+        if (existsSync(dir))
+            evidence.push(dir);
+        const bin = onPath("codex", ctx.env);
+        if (bin)
+            evidence.push(bin);
+        return { installed: evidence.length > 0, evidence, remoteGisulRegistered: remoteRegistered(readText(configPath(ctx))) };
+    },
+    async plan(ctx) {
+        const plan = { files: [], commands: [], notes: [], conflicts: [] };
+        const path = configPath(ctx);
+        const before = readText(path);
+        const text = before ?? "";
+        const managed = splitManaged(text);
+        const outside = managed ? managed.outside : text;
+        if (OTEL_RE.test(outside)) {
+            plan.conflicts.push({ path, code: "unmanaged_otel", detail: "config.toml already has an unmanaged [otel] table or otel.* keys; refusing to edit" });
+        }
+        if (GISOOL_TABLE_RE.test(outside)) {
+            plan.conflicts.push({ path, code: "unmanaged_gisool_mcp", detail: "config.toml already has an unmanaged [mcp_servers.gisool] table" });
+        }
+        if (plan.conflicts.length)
+            return plan;
+        const wanted = block(ctx);
+        let after;
+        if (managed) {
+            after = text.slice(0, managed.start) + wanted + text.slice(managed.end);
+        }
+        else {
+            const sep = text === "" ? "" : text.endsWith("\n") ? "\n" : "\n\n";
+            after = text + sep + wanted;
+        }
+        if (ctx.disableRemote) {
+            const t = gisulTable(after);
+            if (t && remoteRegistered(after)) {
+                const body = /^\s*enabled\s*=.*$/m.test(t.body)
+                    ? t.body.replace(/^(\s*)enabled\s*=.*$/m, "$1enabled = false")
+                    : "enabled = false\n" + t.body;
+                after = after.slice(0, t.start) + body + after.slice(t.end);
+                plan.notes.push("remote gisul MCP entry disabled with enabled = false");
+            }
+        }
+        if (after !== before)
+            plan.files.push({ path, before, after, mode: 0o600 });
+        plan.notes.push("codex exec exports OTel events only partially; no Codex hooks are installed (they require trust review)");
+        return plan;
+    },
+    async doctorChecks(ctx) {
+        const path = configPath(ctx);
+        const text = readText(path);
+        const managed = text === null ? null : splitManaged(text);
+        const inner = managed && text ? text.slice(managed.start, managed.end) : "";
+        const endpoint = `http://127.0.0.1:${ctx.port}/ingest/otlp/v1/logs`;
+        // A project-local .codex/config.toml counts only when it is a different file from the user-level config (doctor run
+        // from $HOME reads the same file), and gisool's own managed block there is not a conflict.
+        const localPath = join(process.cwd(), ".codex", "config.toml");
+        const local = realOrResolved(localPath) === realOrResolved(path) ? null : readText(localPath);
+        const localOutside = local === null ? null : (splitManaged(local)?.outside ?? local);
+        return [
+            { name: "codex OTel block present", ok: inner.includes("[otel]") && inner.includes(endpoint), detail: managed ? path : `no managed block in ${path}` },
+            { name: "codex MCP entry present", ok: inner.includes("[mcp_servers.gisool]") && inner.includes(`http://127.0.0.1:${ctx.port}/mcp`), detail: path },
+            { name: "codex [otel] not in project-local config", ok: localOutside === null || !OTEL_RE.test(localOutside),
+                detail: local === null ? "no project-local config" : "project-local .codex/config.toml defines otel" },
+        ];
+    },
+};

package/dist/packs/cursor.js

@@ -0,0 +1,95 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { isObject, isRemoteEntry, noop, planJsonFile, readJsonConfig, refuse } from "./json-config.js";
+// Hook shape confirmed against https://cursor.com/docs/agent/hooks : hooks.json is { "version": 1, "hooks": { <event>: [{ "command": ... }] } }
+// and Cursor reloads hooks config files automatically. MCP servers live in ~/.cursor/mcp.json under mcpServers.
+const HOOK_EVENTS = ["beforeSubmitPrompt", "sessionStart", "sessionEnd"];
+const URL_KEYS = ["url"];
+function localMcpUrl(port) {
+    return `http://127.0.0.1:${port}/mcp`;
+}
+function hookCommand(ctx) {
+    return `"${ctx.nodePath}" "${join(ctx.packageRoot, "packs", "hook-post.mjs")}" cursor`;
+}
+function isOurHook(entry) {
+    return isObject(entry) && typeof entry.command === "string" && entry.command.endsWith('hook-post.mjs" cursor');
+}
+export const cursorPack = {
+    id: "cursor",
+    async detect({ home }) {
+        const dir = join(home, ".cursor");
+        const installed = existsSync(dir);
+        const servers = readJsonConfig(join(dir, "mcp.json")).obj.mcpServers;
+        return {
+            installed,
+            evidence: installed ? [dir] : [],
+            remoteGisulRegistered: isObject(servers) && isRemoteEntry(servers.gisul, URL_KEYS),
+        };
+    },
+    async plan(ctx) {
+        const dir = join(ctx.home, ".cursor");
+        if (!existsSync(dir))
+            return noop("~/.cursor not found; Cursor does not appear to be installed, nothing planned.");
+        const mcpPath = join(dir, "mcp.json");
+        const hooksPath = join(dir, "hooks.json");
+        const mcp = readJsonConfig(mcpPath);
+        const hooksFile = readJsonConfig(hooksPath);
+        for (const [path, cfg] of [
+            [mcpPath, mcp],
+            [hooksPath, hooksFile],
+        ]) {
+            if (cfg.error)
+                return refuse(path, "unparseable_config", cfg.error);
+        }
+        const nextMcp = structuredClone(mcp.obj);
+        const servers = nextMcp.mcpServers ?? {};
+        if (!isObject(servers))
+            return refuse(mcpPath, "invalid_shape", "mcpServers must be a JSON object");
+        const notes = [];
+        if (ctx.disableRemote && isRemoteEntry(servers.gisul, URL_KEYS)) {
+            notes.push("Remote gisul MCP entry left enabled: Cursor's disable key is unverified, so disable it manually.");
+        }
+        servers.gisool = { url: localMcpUrl(ctx.port), headers: { Authorization: `Bearer ${ctx.token}` } };
+        nextMcp.mcpServers = servers;
+        if (hooksFile.obj.version !== undefined && hooksFile.obj.version !== 1) {
+            return refuse(hooksPath, "invalid_shape", "hooks.json version must be 1");
+        }
+        const nextHooks = { ...structuredClone(hooksFile.obj), version: 1 };
+        const hooks = nextHooks.hooks ?? {};
+        if (!isObject(hooks))
+            return refuse(hooksPath, "invalid_shape", "hooks must be a JSON object");
+        for (const event of HOOK_EVENTS) {
+            const entries = hooks[event] ?? [];
+            if (!Array.isArray(entries))
+                return refuse(hooksPath, "invalid_shape", `hooks.${event} must be an array`);
+            hooks[event] = [...entries.filter((entry) => !isOurHook(entry)), { command: hookCommand(ctx) }];
+        }
+        nextHooks.hooks = hooks;
+        const files = [planJsonFile(mcpPath, mcp, nextMcp), planJsonFile(hooksPath, hooksFile, nextHooks)].filter((f) => f !== null);
+        notes.push("Restart Cursor or reload MCP servers to load the gisool MCP entry; Cursor reloads hooks.json on change.");
+        return { files, commands: [], notes, conflicts: [] };
+    },
+    async doctorChecks({ home, port }) {
+        const mcp = readJsonConfig(join(home, ".cursor", "mcp.json"));
+        if (mcp.error)
+            return [{ name: "cursor mcp.json", ok: false, detail: mcp.error }];
+        const hooksFile = readJsonConfig(join(home, ".cursor", "hooks.json"));
+        if (hooksFile.error)
+            return [{ name: "cursor hooks.json", ok: false, detail: hooksFile.error }];
+        const servers = isObject(mcp.obj.mcpServers) ? mcp.obj.mcpServers : {};
+        const entry = isObject(servers.gisool) ? servers.gisool : {};
+        const hooks = isObject(hooksFile.obj.hooks) ? hooksFile.obj.hooks : {};
+        const hooksPresent = HOOK_EVENTS.every((event) => {
+            const entries = hooks[event];
+            return Array.isArray(entries) && entries.some(isOurHook);
+        });
+        return [
+            { name: "cursor MCP gisool", ok: entry.url === localMcpUrl(port), detail: `url ${String(entry.url ?? "missing")}` },
+            {
+                name: "cursor capture hooks",
+                ok: hooksPresent,
+                detail: hooksPresent ? "beforeSubmitPrompt, sessionStart, sessionEnd present" : "capture hooks missing; rerun gisool init",
+            },
+        ];
+    },
+};

package/dist/packs/gajae.js

@@ -0,0 +1,7 @@
+import { createPiPack, resolveGajaeAgentDir } from "./omo.js";
+export const gajaePack = createPiPack({
+    id: "gajae",
+    agentDir: resolveGajaeAgentDir,
+    extensionName: "gisool",
+    installMarker: ".gjc",
+});