@gitkraken/agent-tools 0.0.0-stage → 0.2.0

package/dist/hooks/templates.js

@@ -0,0 +1,278 @@
+import{joinPath as e}from"../config.js";import{removeTracked as t,writeFileTracked as n}from"../file-change.js";import{HookConfigError as r}from"./errors.js";const i=`// gk-managed:`;function a(t,n){return e(t===`opencode`?e(n.paths.configHome,`opencode`,`plugins`):e(n.paths.piAgentDir||e(n.paths.home,`.pi`,`agent`),`extensions`),`gk-hooks.js`)}function o(e){return e?.split(`
+`,1)[0].startsWith(i)??!1}function s(e){if(!o(e))return;let t=e.split(`
+`,1)[0];try{let e=JSON.parse(t.slice(14));if(e&&typeof e==`object`&&Array.isArray(e.events)){let t=e;return{events:t.events.filter(e=>typeof e==`string`),executable:typeof t.executable==`string`?t.executable:``,hostMajor:typeof t.hostMajor==`number`?t.hostMajor:0}}}catch{}}function c(e,t,n,r){let a={events:t,executable:n,version:e===`opencode`?5:1};e===`opencode`&&r&&(a.hostMajor=r);let o=e===`opencode`?`import { spawn } from "node:child_process";
+
+const EVENTS = new Set({{.EventsJSON}});
+const EXECUTABLE = {{.ExecJSON}};
+const HOST = {{.HostJSON}};
+const MAX_HOOK_INPUT_BYTES = {{.MaxInputBytesJSON}};
+
+function getString(value) {
+  return typeof value === "string" && value.length > 0 ? value : "";
+}
+
+// extractToolName is the one piece of the relay every host must supply: only
+// the host knows where its payloads carry a tool name. The default below
+// returns null so a host that forgets it still forwards events with
+// tool_name: null, instead of throwing inside runHook's catch-all and
+// silently forwarding nothing at all. Hosts override it with
+// {{define "extractToolName"}} — see hook_pi.js.tmpl and
+// hook_opencode.js.tmpl.
+function extractToolName(payload) {
+  return (
+    getString(payload?.input?.tool) ||
+    getString(payload?.event?.properties?.part?.tool) ||
+    getString(payload?.event?.properties?.tool) ||
+    // v2's tool.hook("execute.before"/"execute.after") callbacks pass { event },
+    // where event.tool is the tool name directly (e.g. "read").
+    getString(payload?.event?.tool) ||
+    ""
+  );
+}
+
+const V1_ONLY_EVENTS = new Set({{.V1OnlyEventsJSON}});
+const V2_EVENT_ALIASES = new Map(Object.entries({{.V2EventAliasesJSON}}));
+
+function extractSessionID(event) {
+  return (
+    getString(event?.properties?.sessionID) ||
+    getString(event?.properties?.sessionId) ||
+    getString(event?.properties?.session_id) ||
+    // A message or part names its session in its own sessionID; its id names
+    // the message or part. Only a session's own info carries the session id
+    // as id, so that fallback comes after every explicit session field.
+    getString(event?.properties?.info?.sessionID) ||
+    getString(event?.properties?.part?.sessionID) ||
+    getString(event?.properties?.info?.id) ||
+    getString(event?.properties?.id) ||
+    getString(event?.sessionID) ||
+    getString(event?.sessionId) ||
+    getString(event?.session_id) ||
+    // v2's event bus nests the id under \`data\` instead of \`properties\`. The
+    // event's own top-level id is never a fallback: on v2 it names the event,
+    // and relaying it would report a session that does not exist.
+    getString(event?.data?.sessionID)
+  );
+}
+
+
+
+// server is the OpenCode v1 plugin entrypoint (returns a Hooks object). v1
+// calls this directly off the default export below.
+const server = async (ctx) => {
+  // No process.cwd() fallback: that is the host's launch directory, which the
+  // relay cannot tell apart from a real per-session cwd and would use to
+  // attribute the session to the wrong repo. Each hook below drops its event
+  // instead when cwd is empty, so the spawn is skipped entirely rather than
+  // paid for and discarded by the relay's own missing-cwd guard.
+  const cwd = getString(ctx.directory) || getString(ctx.worktree);
+  const hooks = {};
+
+  // General event hook — forwards native dot names as-is.
+  hooks.event = async ({ event }) => {
+    if (!cwd) return;
+    const type = event?.type ?? "";
+    if (type === "tool.execute.before" || type === "tool.execute.after") return;
+    const sessionID = extractSessionID(event);
+    if (!sessionID) return;
+    runHook(type, sessionID, cwd, { event });
+  };
+
+  // Dedicated tool hooks — provide structured sessionID and tool name.
+  if (EVENTS.has("tool.execute.before")) {
+    hooks["tool.execute.before"] = async (input, output) => {
+      if (!cwd) return;
+      const sessionID =
+        getString(input?.sessionID) || getString(input?.sessionId) || getString(input?.session_id);
+      if (!sessionID) return;
+      runHook("tool.execute.before", sessionID, cwd, { input, output });
+    };
+  }
+  if (EVENTS.has("tool.execute.after")) {
+    hooks["tool.execute.after"] = async (input, output) => {
+      if (!cwd) return;
+      const sessionID =
+        getString(input?.sessionID) || getString(input?.sessionId) || getString(input?.session_id);
+      if (!sessionID) return;
+      runHook("tool.execute.after", sessionID, cwd, { input, output });
+    };
+  }
+
+  return hooks;
+};
+
+// setup is the OpenCode v2 plugin entrypoint. v2 replaced the returned-Hooks
+// shape with named registration APIs (ctx.tool.hook, ctx.event.subscribe). It
+// dropped the v1 names ctx.directory/ctx.worktree, but the directory itself is
+// still on the context as ctx.location.directory, so that is the base cwd.
+const setup = async (ctx) => {
+  // Per-session directories arrive only on the subset of events that carry a
+  // location, and the subscription only yields from plugin load onward, so a
+  // session predating this plugin instance (server restart, resumed session)
+  // never populates the cache. Treat the cache as an override on top of the
+  // context directory rather than the only source, and never guess: with no
+  // directory at all, send "" so the relay drops the event instead of
+  // attributing the session to the host's launch directory.
+  const baseCwd =
+    getString(ctx?.location?.directory) || getString(ctx?.directory) || getString(ctx?.worktree);
+  // session.deleted is an explicit, rare user action, so eviction on it alone
+  // would let a host left running for days accumulate one entry per session it
+  // ever saw. Cap the map the way runner.go caps its cwd timeline and drop the
+  // oldest entry first (Map iterates in insertion order); a session evicted
+  // this way falls back to baseCwd, same as one that never carried a location.
+  const MAX_TRACKED_SESSIONS = 50;
+  const cwdBySession = new Map();
+  const rememberCwd = (sessionID, directory) => {
+    // Re-insert so a session still in use is treated as the newest entry.
+    cwdBySession.delete(sessionID);
+    cwdBySession.set(sessionID, directory);
+    while (cwdBySession.size > MAX_TRACKED_SESSIONS) {
+      cwdBySession.delete(cwdBySession.keys().next().value);
+    }
+  };
+  const resolveCwd = (sessionID) => (sessionID && cwdBySession.get(sessionID)) || baseCwd;
+
+  if (EVENTS.has("tool.execute.before")) {
+    await ctx.tool.hook("execute.before", (event) => {
+      const sessionID = getString(event?.sessionID);
+      if (!sessionID) return;
+      runHook("tool.execute.before", sessionID, resolveCwd(sessionID), { event });
+    });
+  }
+  if (EVENTS.has("tool.execute.after")) {
+    await ctx.tool.hook("execute.after", (event) => {
+      const sessionID = getString(event?.sessionID);
+      if (!sessionID) return;
+      runHook("tool.execute.after", sessionID, resolveCwd(sessionID), { event });
+    });
+  }
+
+  const controller = new AbortController();
+  (async () => {
+    try {
+      for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+        const sessionID = extractSessionID(event);
+        const directory =
+          getString(event?.location?.directory) || getString(event?.data?.location?.directory);
+        if (sessionID && directory) rememberCwd(sessionID, directory);
+
+        const type = event?.type ?? "";
+        if (type === "tool.execute.before" || type === "tool.execute.after") continue;
+        if (V1_ONLY_EVENTS.has(type)) continue;
+        // File edits, branch changes and todo updates can arrive without a
+        // session; there is no conversation to attribute them to.
+        if (!sessionID) continue;
+        runHook(type, sessionID, resolveCwd(sessionID), { event }, V2_EVENT_ALIASES.get(type));
+        // Evict regardless of whether session.deleted is in the installed
+        // EVENTS set, so an explicitly deleted session is released immediately
+        // rather than waiting to age out of the cap above.
+        if (type === "session.deleted") cwdBySession.delete(sessionID);
+      }
+    } catch (_) {
+      // Subscription tears down when the plugin is disposed; must never throw.
+    }
+  })();
+
+  return () => controller.abort();
+};
+
+// OpenCode v2 validates the default export as an object before reading setup;
+// callable objects fail that schema. v1.4+ reads server from this same shape.
+// Older v1 hosts cannot share one module shape with v2 and are unsupported by
+// this v2-capable template.
+export default { id: "gk-hooks", server, setup };
+`:`import { spawn } from "node:child_process";
+
+const EVENTS = new Set({{.EventsJSON}});
+const EXECUTABLE = {{.ExecJSON}};
+const HOST = {{.HostJSON}};
+const MAX_HOOK_INPUT_BYTES = {{.MaxInputBytesJSON}};
+
+function getString(value) {
+  return typeof value === "string" && value.length > 0 ? value : "";
+}
+
+// extractToolName is the one piece of the relay every host must supply: only
+// the host knows where its payloads carry a tool name. The default below
+// returns null so a host that forgets it still forwards events with
+// tool_name: null, instead of throwing inside runHook's catch-all and
+// silently forwarding nothing at all. Hosts override it with
+// {{define "extractToolName"}} — see hook_pi.js.tmpl and
+// hook_opencode.js.tmpl.
+function extractToolName(payload) {
+  return getString(payload?.event?.toolName);
+}
+
+
+
+function sessionIdOf(ctx) {
+  return getString(ctx?.sessionManager?.getSessionId?.());
+}
+
+export default function (pi) {
+  for (const name of EVENTS) {
+    pi.on(name, async (event, ctx) => {
+      // A reload is not a session ending; forwarding it would kill a live session.
+      if (name === "session_shutdown" && event?.reason === "reload") return;
+      // No process.cwd() fallback: that is pi's launch directory, which the
+      // relay cannot tell apart from a real per-session cwd and would use to
+      // attribute the session to the wrong repo. Dropping the event lets the
+      // relay's missing-cwd guard stay meaningful.
+      const cwd = getString(ctx?.cwd);
+      if (!cwd) return;
+      runHook(name, sessionIdOf(ctx), cwd, { event });
+    });
+  }
+}
+`,s={EventsJSON:JSON.stringify(t),ExecJSON:JSON.stringify(n),HostJSON:JSON.stringify(e),MaxInputBytesJSON:`1048576`,V1OnlyEventsJSON:JSON.stringify([`session.updated`,`session.error`]),V2EventAliasesJSON:JSON.stringify({"session.execution.failed":[`session.error`],"session.status":[`session.updated`]})},c=e===`opencode`?`
+
+const V1_ONLY_EVENTS`:`
+
+
+
+function sessionIdOf`,l=o.indexOf(c);if(l<0)throw Error(`missing ${e} relay insertion point`);let u=o.slice(0,l)+`
+
+function buildHookInput(eventName, sessionID, cwd, payload) {
+  const toolName = extractToolName(payload);
+  const hookInput = {
+    hook_event_name: eventName,
+    session_id: sessionID || "",
+    cwd,
+    tool_name: toolName || null,
+    source: null,
+    model: null,
+    reason: null,
+    agent_id: null,
+    agent_type: null,
+    hook_payload: payload || null,
+  };
+
+  const serializedInput = JSON.stringify(hookInput);
+  const payloadBytes = Buffer.byteLength(serializedInput, "utf8");
+  if (payloadBytes <= MAX_HOOK_INPUT_BYTES) {
+    return serializedInput;
+  }
+
+  return JSON.stringify({
+    ...hookInput,
+    hook_payload: { truncated: true, originalBytes: payloadBytes },
+  });
+}
+
+function runHook(eventName, sessionID, cwd, payload, aliases = []) {
+  if (!EVENTS.has(eventName) && !aliases.some((alias) => EVENTS.has(alias))) return;
+  try {
+    const input = buildHookInput(eventName, sessionID, cwd, payload);
+    const child = spawn(EXECUTABLE, ["ai", "hook", "run", "--host", HOST], {
+      stdio: ["pipe", "ignore", "ignore"],
+      windowsHide: true,
+    });
+    child.on("error", () => {});
+    child.stdin.on("error", () => {});
+    child.stdin.end(input);
+    child.unref();
+  } catch (_) {
+    // Hooks must never block the host
+  }
+}`+o.slice(l);return i+JSON.stringify(a)+`
+`+u.replace(/{{\.(\w+)}}/g,(e,t)=>s[t]??``)}async function l(n,r,i){let s=a(n,r),c=s.slice(0,s.lastIndexOf(`/`));for(let n of await r.fs.readDir(c)??[]){if(n===`gk-hooks.js`||!n.startsWith(`gk-hooks.`))continue;let a=e(c,n);o(await r.fs.readFile(a))&&await t(r.fs,a,i)}}async function u(e,t){let i=a(e.host,t);if(e.blockingEvents?.length)throw new r(`blocking-unsupported`,`${e.host} does not support blocking hooks`,i);let u=await t.fs.readFile(i),d=s(u);if(u!==null&&!o(u))throw new r(`unmanaged-file`,`${i} already exists and was not written by GitKraken`,i);let f=[...new Set([...d?.events??[],...e.events??[]])].sort(),p=e.host===`opencode`?t.openCodeMajor??0:0,m=[];return await n(t.fs,i,c(e.host,f,e.executablePath.replace(/\\/g,`/`),p),m,{mode:384}),await l(e.host,t,m),{host:e.host,path:i,events:[...e.events??[]],blockingEvents:[],files:m}}async function d(e,r,i){let o=a(e,i),u=[],d=await i.fs.readFile(o),f=s(d),p=[],m=[];f&&(p=f.events.filter(e=>(r??f.events).includes(e)),m=f.events.filter(e=>!p.includes(e)).sort(),m.length?await n(i.fs,o,c(e,m,f.executable,f.hostMajor),u,{mode:384}):await t(i.fs,o,u)),await l(e,i,u);let h={host:e,path:o,removedEvents:p,remainingEvents:m,files:u};return p.length||(h.reason=d===null?`file-missing`:`not-installed`),h}export{u as installMarkerHooks,d as uninstallMarkerHooks};

package/dist/hooks/writers.d.ts

@@ -0,0 +1,18 @@
+import { AgentHostConfig } from "../config.js";
+import { HookHost } from "./events.js";
+import { HookInstallResult, HookUninstallResult } from "./results.js";
+
+//#region src/hooks/writers.d.ts
+type JsonHookHost = Extract<HookHost, 'cursor' | 'codex' | 'copilot' | 'antigravity' | 'augment' | 'grok'>;
+interface HookWriteRequest {
+  host: HookHost;
+  executablePath: string;
+  events?: readonly string[];
+  blockingEvents?: readonly string[];
+}
+declare function command(executablePath: string, host: HookHost, config: AgentHostConfig, blocking: boolean): string;
+/** Merges only GitKraken-owned hooks, preserving unrelated entries and document keys. */
+declare function installJsonHooks(request: HookWriteRequest, config: AgentHostConfig): Promise<HookInstallResult>;
+declare function uninstallJsonHooks(host: JsonHookHost, config: AgentHostConfig, events?: readonly string[]): Promise<HookUninstallResult>;
+//#endregion
+export { HookWriteRequest, command, installJsonHooks, uninstallJsonHooks };

package/dist/hooks/writers.js

@@ -0,0 +1 @@
+import{joinPath as e}from"../config.js";import{removeTracked as t,writeFileTracked as n}from"../file-change.js";import{HookConfigError as r}from"./errors.js";import{eventManifest as i}from"./events.js";const a={cursor:{path:t=>e(t.paths.home,`.cursor`,`hooks.json`),key:`hooks`,version:!0,matcher:!1},codex:{path:t=>e(t.paths.home,`.codex`,`hooks.json`),key:`hooks`,version:!1,matcher:!0},copilot:{path:t=>e(t.paths.home,`.copilot`,`hooks`,`gitkraken-hooks.json`),key:`hooks`,version:!0,matcher:!1},antigravity:{path:t=>e(t.paths.home,`.gemini`,`config`,`hooks.json`),key:`gitkraken`,version:!1,matcher:!1},augment:{path:t=>e(t.paths.home,`.augment`,`settings.json`),key:`hooks`,version:!1,matcher:!0,neverDelete:!0},grok:{path:t=>e(t.paths.grokHome??e(t.paths.home,`.grok`),`hooks`,`gitkraken-hooks.json`),key:`hooks`,version:!1,matcher:!0}};function o(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function s(e){return typeof e==`string`&&e.includes(` ai hook run --host `)}function c(e,t,n,r){return`${n.platform===`win32`&&`windowsShell`in i[t]&&i[t].windowsShell===`powershell`?`& `:``}"${e.replaceAll(`\\`,`/`)}" ai hook run --host ${t}${r?` --blocking`:``}`}function l(e){let t=i[e.host],n=e.events?.length||e.blockingEvents?.length?e.events??[]:t.events.filter(e=>!t.skippedDefaultEvents.includes(e)),a=e.blockingEvents??[];for(let i of[...n,...a])if(!t.events.includes(i))throw new r(`invalid-event`,`${i} is not valid for ${e.host}`);return[n,a]}function u(e,t){return e===`antigravity`?t===`PreToolUse`||t===`PostToolUse`:a[e].matcher}function d(e,t,n){if(!Array.isArray(e)||!e.every(o))throw new r(`wrong-shape`,`${n} has the wrong event shape`,n);if(t&&e.some(e=>`command`in e||`hooks`in e&&(!Array.isArray(e.hooks)||!e.hooks.every(o))))throw new r(`wrong-shape`,`${n} has the wrong matcher shape`,n);if(!t&&e.some(e=>`hooks`in e))throw new r(`wrong-shape`,`${n} has the wrong flat shape`,n)}function f(e,t){return Array.isArray(e)?e.some(e=>t&&o(e)&&Array.isArray(e.hooks)?e.hooks.some(e=>o(e)&&s(e.command)):o(e)&&s(e.command)):!1}function p(e,t){return Object.keys(t).filter(n=>f(t[n],u(e,n)))}function m(e,t){return t?e.flatMap(e=>{if(!Array.isArray(e.hooks))return[e];let t=e.hooks.filter(e=>!o(e)||!s(e.command));return t.length===e.hooks.length?[e]:t.length?[{...e,hooks:t}]:[]}):e.filter(e=>!s(e.command))}function h(e,t,n,r,a){let o=86400*(`blockingTimeoutMultiplier`in i[n]?Number(i[n].blockingTimeoutMultiplier):1),c={type:`command`,command:r,...a?{timeout:o}:{}};if(!t)return[...m(e,!1),c];let l=m(e,!0),u=l.find(e=>!e.matcher&&Array.isArray(e.hooks)&&e.hooks.length>0);u||(u=n===`augment`?{hooks:[]}:{matcher:``,hooks:[]},l.push(u));let d=Array.isArray(u.hooks)?u.hooks:[];return u.hooks=[...d.filter(e=>!s(e.command)),c],l}function g(e,t){let n;try{n=JSON.parse(e.replace(/^\uFEFF/,``))}catch{throw new r(`invalid-json`,`Invalid JSON at ${t}`,t)}if(!o(n))throw new r(`wrong-shape`,`Invalid hooks document at ${t}`,t);return n}function _(e,t,n){let i=e[t];if(i!=null){if(!o(i))throw new r(`wrong-shape`,`Invalid hooks wrapper at ${n}`,n);return i}}async function v(e,t){if(!(e.host in a))throw new r(`unsupported-host`,`No JSON writer for ${e.host}`);let o=e.host,s=a[o],f=s.path(t),p=await t.fs.readFile(f),v=p?.trim()?g(p,f):{},y={..._(v,s.key,f)};for(let[e,t]of Object.entries(y))d(t,u(o,e),f);let[b,x]=l(e);for(let[n,r]of[[b,!1],[x,!0]])for(let i of n){let n=u(o,i);y[i]=h(y[i]??[],n,o,c(e.executablePath,o,t,r),r)}if(`legacyEvents`in i[o])for(let e of i[o].legacyEvents){let t=y[e];if(t){let n=m(t,u(o,e));n.length?y[e]=n:delete y[e]}}Object.keys(y).length?v[s.key]=y:delete v[s.key],s.version&&v.version==null&&(v.version=1);let S=[];return await n(t.fs,f,`${JSON.stringify(v,null,2)}\n`,S),{host:o,path:f,events:[...b],blockingEvents:[...x],files:S}}async function y(e,r,o){let s=a[e],c=s.path(r),l=[],f=(t,n=[])=>({host:e,path:c,removedEvents:[],remainingEvents:n,files:l,reason:t}),h=await r.fs.readFile(c);if(h===null)return f(`file-missing`);if(!h.trim())return f(`not-installed`);let v=g(h,c),y=_(v,s.key,c);if(!y)return f(`not-installed`);let b={...y};for(let[t,n]of Object.entries(b))d(n,u(e,t),c);let x=[],S=o?.length?o:i[e].events;for(let t of[...S,...`legacyEvents`in i[e]?i[e].legacyEvents:[]]){let n=b[t];if(!n)continue;let r=m(n,u(e,t));JSON.stringify(r)!==JSON.stringify(n)&&(x.push(t),r.length?b[t]=r:delete b[t])}let C=p(e,b);if(!x.length)return f(`not-installed`,C);Object.keys(b).length?v[s.key]=b:delete v[s.key];let w=Object.keys(v).some(e=>e!==s.key&&!(e===`version`&&s.version&&v.version===1));return!Object.keys(b).length&&!w&&!s.neverDelete?await t(r.fs,c,l):await n(r.fs,c,`${JSON.stringify(v,null,2)}\n`,l),{host:e,path:c,removedEvents:x,remainingEvents:C,files:l}}export{c as command,v as installJsonHooks,y as uninstallJsonHooks};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { AgentHostConfig, AgentHostPaths, AgentOrigin, joinPath } from "./config.js";
+import { HookHost, eventManifest } from "./hooks/events.js";
+import { McpConfigEntry, generateConfigEntry } from "./mcp/config-entry.js";
+import { McpInstallRequest, McpInstallResult, McpInstallState, McpInstallStateReason, McpInstallStatus, inspectMcpInstall, installMcp } from "./mcp/installer.js";
+import { McpLayoutOptions, OpenCodeMcpCleanupError, OpenCodeMcpLayout, OpenCodeMcpLayoutUnknownError, OpenCodeMcpPolicy } from "./mcp/opencode-layout.js";
+import { Client, ClientDetection, ClientDetectionSource, ClientInstallation, ClientNotDetectedReason, ClientType, allClients, antigravityLegacyPath, clientCommand, clientConfigPath, clientConfigPaths, clientDisplayName, clientExecutablePath, clientJSONPath, clientType, clientsForHost, detectClient, getClientInstallation, hostIdentity, hostOf, isInstallable, isLegacy, isSupported, legacyClientIds } from "./mcp/clients.js";
+import { Agent, HookCapability, listAgents, mcpNamesForHook, resolveHookClient } from "./agents.js";
+import { FileChange, FileChangeKind } from "./file-change.js";
+import { HookInstallResult, HookUninstallResult } from "./hooks/results.js";
+import { HookConfigError, HookConfigErrorCode } from "./hooks/errors.js";
+import { HookWriteRequest, installJsonHooks, uninstallJsonHooks } from "./hooks/writers.js";
+import { InstallHooksRequest, installHooks, uninstallHooks } from "./hooks/install.js";
+import { getMcpCliInstallCommand } from "./mcp/cli-install-command.js";
+import { McpUninstallFileResult, McpUninstallRequest, McpUninstallResult, uninstallMcp } from "./mcp/uninstaller.js";
+import { SKILL_MANIFEST_FILE_NAME, SKILL_MANIFEST_SCHEMA_VERSION, SkillManifest } from "./skills/manifest.js";
+import { SkillAgent, allSkillAgents, isSkillAgentSupported, skillDir } from "./skills/skill-dirs.js";
+import { SkillConflictError, SkillFiles, SkillInstallAction, SkillInstallOptions, SkillInstallResult, SkillOperation, SkillReason, SkillState, SkillStatus, SkillUninstallAction, SkillUninstallOptions, SkillUninstallResult, SkillUnsupportedManifestError, inspectSkillStatus, installSkill, uninstallSkill } from "./skills/install.js";
+export { type Agent, type AgentHostConfig, type AgentHostPaths, type AgentOrigin, type Client, type ClientDetection, type ClientDetectionSource, type ClientInstallation, type ClientNotDetectedReason, type ClientType, type FileChange, type FileChangeKind, type HookCapability, HookConfigError, type HookConfigErrorCode, type HookHost, type HookInstallResult, type HookUninstallResult, type HookWriteRequest, type InstallHooksRequest, type McpConfigEntry, type McpInstallRequest, type McpInstallResult, type McpInstallState, type McpInstallStateReason, type McpInstallStatus, type McpLayoutOptions, type McpUninstallFileResult, type McpUninstallRequest, type McpUninstallResult, OpenCodeMcpCleanupError, type OpenCodeMcpLayout, OpenCodeMcpLayoutUnknownError, type OpenCodeMcpPolicy, SKILL_MANIFEST_FILE_NAME, SKILL_MANIFEST_SCHEMA_VERSION, type SkillAgent, SkillConflictError, type SkillFiles, type SkillInstallAction, type SkillInstallOptions, type SkillInstallResult, type SkillManifest, type SkillOperation, type SkillReason, type SkillState, type SkillStatus, type SkillUninstallAction, type SkillUninstallOptions, type SkillUninstallResult, SkillUnsupportedManifestError, allClients, allSkillAgents, antigravityLegacyPath, clientCommand, clientConfigPath, clientConfigPaths, clientDisplayName, clientExecutablePath, clientJSONPath, clientType, clientsForHost, detectClient, eventManifest, generateConfigEntry, getClientInstallation, getMcpCliInstallCommand, hostIdentity, hostOf, inspectMcpInstall, inspectSkillStatus, installHooks, installJsonHooks, installMcp, installSkill, isInstallable, isLegacy, isSkillAgentSupported, isSupported, joinPath, legacyClientIds, listAgents, mcpNamesForHook, resolveHookClient, skillDir, uninstallHooks, uninstallJsonHooks, uninstallMcp, uninstallSkill };

package/dist/index.js

@@ -0,0 +1 @@
+import{joinPath as e}from"./config.js";import{OpenCodeMcpCleanupError as t,OpenCodeMcpLayoutUnknownError as n}from"./mcp/opencode-layout.js";import{allClients as r,antigravityLegacyPath as i,clientCommand as a,clientConfigPath as o,clientConfigPaths as s,clientDisplayName as c,clientExecutablePath as l,clientJSONPath as u,clientType as d,clientsForHost as f,detectClient as p,getClientInstallation as m,hostIdentity as h,hostOf as g,isInstallable as _,isLegacy as v,isSupported as y,legacyClientIds as b}from"./mcp/clients.js";import{listAgents as x,mcpNamesForHook as S,resolveHookClient as C}from"./agents.js";import{HookConfigError as w}from"./hooks/errors.js";import{eventManifest as T}from"./hooks/events.js";import{installJsonHooks as E,uninstallJsonHooks as D}from"./hooks/writers.js";import{installHooks as O,uninstallHooks as k}from"./hooks/install.js";import{generateConfigEntry as A}from"./mcp/config-entry.js";import{inspectMcpInstall as j,installMcp as M}from"./mcp/installer.js";import{getMcpCliInstallCommand as N}from"./mcp/cli-install-command.js";import{uninstallMcp as P}from"./mcp/uninstaller.js";import{SKILL_MANIFEST_FILE_NAME as F,SKILL_MANIFEST_SCHEMA_VERSION as I}from"./skills/manifest.js";import{allSkillAgents as L,isSkillAgentSupported as R,skillDir as z}from"./skills/skill-dirs.js";import{SkillConflictError as B,SkillUnsupportedManifestError as V,inspectSkillStatus as H,installSkill as U,uninstallSkill as W}from"./skills/install.js";export{w as HookConfigError,t as OpenCodeMcpCleanupError,n as OpenCodeMcpLayoutUnknownError,F as SKILL_MANIFEST_FILE_NAME,I as SKILL_MANIFEST_SCHEMA_VERSION,B as SkillConflictError,V as SkillUnsupportedManifestError,r as allClients,L as allSkillAgents,i as antigravityLegacyPath,a as clientCommand,o as clientConfigPath,s as clientConfigPaths,c as clientDisplayName,l as clientExecutablePath,u as clientJSONPath,d as clientType,f as clientsForHost,p as detectClient,T as eventManifest,A as generateConfigEntry,m as getClientInstallation,N as getMcpCliInstallCommand,h as hostIdentity,g as hostOf,j as inspectMcpInstall,H as inspectSkillStatus,O as installHooks,E as installJsonHooks,M as installMcp,U as installSkill,_ as isInstallable,v as isLegacy,R as isSkillAgentSupported,y as isSupported,e as joinPath,b as legacyClientIds,x as listAgents,S as mcpNamesForHook,C as resolveHookClient,z as skillDir,k as uninstallHooks,D as uninstallJsonHooks,P as uninstallMcp,W as uninstallSkill};

package/dist/mcp/cli-install-command.d.ts

@@ -0,0 +1,27 @@
+import { AgentHostConfig } from "../config.js";
+import { McpInstallRequest } from "./installer.js";
+
+//#region src/mcp/cli-install-command.d.ts
+/**
+ * Returns the argv of the client's own CLI shortcut for installing the
+ * GitKraken MCP server, or `undefined` when the host should go straight to
+ * {@link installMcp}. The host runs the argv and falls back to
+ * {@link installMcp} on failure, preserving Go's order (`installVSCode`,
+ * `installClaudeCLI`, `installCodex`, …).
+ *
+ * `undefined` when the client has no shortcut, and also when the shortcut
+ * would not do the job:
+ * - `request.configPath` is set, because no shortcut can target a specific file.
+ * - Cursor: gkcli ignores the outcome of `cursor --add-mcp` and always writes
+ *   `~/.cursor/mcp.json`, so the direct write is the install.
+ * - Codex, when its config still holds the legacy `['mcp_servers.GitKraken']`
+ *   table: `codex mcp add` would leave it behind, so the direct write must
+ *   replace it.
+ *
+ * Excludes gkcli's GitLens deep-link URL scheme (`vscode:mcp/install?…`,
+ * `cursor://…`), which is a browser-launch side effect outside this
+ * library's scope.
+ */
+declare function getMcpCliInstallCommand(request: McpInstallRequest, config: AgentHostConfig): Promise<string[] | undefined>;
+//#endregion
+export { getMcpCliInstallCommand };

package/dist/mcp/cli-install-command.js

@@ -0,0 +1 @@
+import{inspectMcpInstall as e}from"./installer.js";function t(e,t,n){return JSON.stringify({command:t,type:`stdio`,name:e,args:[...n]})}async function n(n,r){if(n.configPath)return;let{client:i,executablePath:a,args:o}=n;switch(i){case`vscode`:return[`code`,`--add-mcp`,t(`GitKraken`,a,o)];case`vscode-insiders`:return[`code-insiders`,`--add-mcp`,t(`GitKraken`,a,o)];case`claude-cli`:return[`claude`,`mcp`,`add`,`GitKraken`,`-s`,`user`,`--`,a,...o];case`trae`:return[`trae`,`--add-mcp`,t(``,a,o)];case`codex`:{let{reason:t}=await e(n,r);return t===`legacy-location`?void 0:[`codex`,`mcp`,`add`,`GitKraken`,a,...o]}default:return}}export{n as getMcpCliInstallCommand};

package/dist/mcp/clients.d.ts

@@ -0,0 +1,96 @@
+import { AgentHostConfig } from "../config.js";
+import { McpLayoutOptions, OpenCodeMcpLayout } from "./opencode-layout.js";
+
+//#region src/mcp/clients.d.ts
+/**
+ * The 16 MCP client ids gkcli knows about. `gemini` is legacy: retained only
+ * so an uninstall can clear a stale GitKraken entry, and excluded from
+ * {@link allClients}.
+ */
+type Client = 'vscode' | 'vscode-insiders' | 'claude' | 'claude-cli' | 'antigravity' | 'antigravity-cli' | 'windsurf' | 'cursor' | 'zed' | 'trae' | 'copilot' | 'codex' | 'gemini' | 'kiro' | 'jetbrains-copilot' | 'opencode';
+/**
+ * How a client runs. Installing into a GUI client may launch its window (VS
+ * Code and Cursor are configured through their own binary); callers that must
+ * not disturb the desktop select `'cli'` clients.
+ */
+type ClientType = 'cli' | 'gui';
+declare const OPEN_CODE_V1_JSON_PATH = "/mcp/GitKraken";
+declare const OPEN_CODE_V2_JSON_PATH = "/mcp/servers/GitKraken";
+/** Every location an OpenCode GitKraken entry may live at: v2 is written, v1 is only recognised and cleaned up. */
+declare const OPEN_CODE_JSON_PATHS: readonly string[];
+/** The OpenCode pointers that can hold a GitKraken entry in `text`; the v2 one only counts under a native `servers` envelope, not a flat server named `servers`. */
+declare function openCodeEntryPointers(text: string): string[];
+declare function isSupported(client: string): boolean;
+/** Whether `client` is retained only for uninstall cleanup (currently only `gemini`). */
+declare function isLegacy(client: Client): boolean;
+/** Safe default for any client-name input: a supported, non-legacy client. */
+declare function isInstallable(client: Client): boolean;
+declare function clientType(client: Client): ClientType | 'unknown';
+declare function clientDisplayName(client: Client): string;
+declare function clientCommand(client: Client): string | undefined;
+/** Every non-legacy client id, in registry order. */
+declare function allClients(): Client[];
+/** Every legacy client id, e.g. `gemini`. */
+declare function legacyClientIds(): Client[];
+/** The `--host=` value the installer bakes into a client's generated args. Rows sharing a host must emit the same value. */
+declare function hostIdentity(client: Client): string;
+/** The client whose configuration surface `client` shares (itself, for every row but the Antigravity pair). */
+declare function hostOf(client: Client): Client;
+/** Every non-legacy row sharing `host`'s configuration surface, `host` itself included, in registry order. */
+declare function clientsForHost(host: Client): Client[];
+/** The JSON pointer OpenCode reads a GitKraken server from in `layout`. */
+declare function openCodeJSONPath(layout: OpenCodeMcpLayout): string;
+/**
+ * The JSON pointer (or, for Codex, dotted TOML table key) for a client's GitKraken entry.
+ * OpenCode's returned pointer depends on `options.openCode` (v2 when omitted); `infer-existing` throws
+ * {@link OpenCodeMcpLayoutUnknownError}, since the pointer then depends on the config file.
+ */
+declare function clientJSONPath(client: Client, options?: McpLayoutOptions): string;
+/** The single config file path this client's GitKraken entry is written to. */
+declare function clientConfigPath(client: Client, config: AgentHostConfig): Promise<string | undefined>;
+/**
+ * Every config file a client's GitKraken entry may live in: write-and-delete
+ * authority. `uninstallMcp` clears the entry from every path.
+ */
+declare function clientConfigPaths(client: Client, config: AgentHostConfig): Promise<string[]>;
+/** The pre-shared-config location Antigravity's IDE used to read; uninstall still covers it for back-compat. */
+declare function antigravityLegacyPath(config: AgentHostConfig): string;
+/**
+ * The resolved path to the client's binary on `PATH`, or `undefined`. Go's
+ * `exec.LookPath` reads `PATH` and stats candidate directories directly; this
+ * library never reads the environment, so the host injects the lookup.
+ */
+declare function clientExecutablePath(client: Client, config: AgentHostConfig): string | undefined;
+/** How {@link detectClient} found a client. */
+type ClientDetectionSource = 'executable' | 'config-file' | 'config-dir';
+/** Why {@link detectClient} did not find a client. `shared-host-row` is a row such as `antigravity-cli`, which has no config signal of its own and no binary on `PATH`. */
+type ClientNotDetectedReason = 'not-found' | 'shared-host-row';
+interface ClientDetection {
+  client: Client;
+  detected: boolean;
+  /** Set when `detected`. */
+  source?: ClientDetectionSource;
+  /** The client's binary on `PATH`, when `resolveExecutable` found it. */
+  executablePath?: string;
+  /** The config file or directory that matched. */
+  path?: string;
+  /** Set when not `detected`. */
+  reason?: ClientNotDetectedReason;
+  /** Every config file or directory probed, in order. */
+  checkedPaths: string[];
+}
+/**
+ * Whether the client's binary or config directory is present, and how it was
+ * found. Mirrors Go's `mcp.Client.IsDetected`.
+ */
+declare function detectClient(client: Client, config: AgentHostConfig): Promise<ClientDetection>;
+interface ClientInstallation {
+  client: Client;
+  installed: boolean;
+  /** The config files that carry a GitKraken entry, so a host can tell when the entry sits in a legacy file. */
+  paths: string[];
+}
+/** Which of the client's config files already carry a GitKraken entry. Mirrors Go's `mcp.Client.IsInstalled`. */
+declare function getClientInstallation(client: Client, config: AgentHostConfig): Promise<ClientInstallation>;
+//#endregion
+export { Client, ClientDetection, ClientDetectionSource, ClientInstallation, ClientNotDetectedReason, ClientType, OPEN_CODE_JSON_PATHS, OPEN_CODE_V1_JSON_PATH, OPEN_CODE_V2_JSON_PATH, allClients, antigravityLegacyPath, clientCommand, clientConfigPath, clientConfigPaths, clientDisplayName, clientExecutablePath, clientJSONPath, clientType, clientsForHost, detectClient, getClientInstallation, hostIdentity, hostOf, isInstallable, isLegacy, isSupported, legacyClientIds, openCodeEntryPointers, openCodeJSONPath };

package/dist/mcp/clients.js

@@ -0,0 +1 @@
+import{joinPath as e}from"../config.js";import{findAtPointer as t}from"./jsonc-edit.js";import{openCodeLayoutFor as n,openCodeNativeServers as r}from"./opencode-layout.js";import{parseTomlSafe as i,tomlDottedPath as a,tomlLiteralKey as o}from"./toml-read.js";const s=`/mcp/GitKraken`,c=`/mcp/servers/GitKraken`,l=[c,s];function u(e){return l.filter(t=>t!==`/mcp/servers/GitKraken`||r(e)!==void 0)}function d(t,...n){return e(t.paths.home,...n)}function f(e){return e.platform===`linux`?e.paths.configHome:e.paths.appSupport}function p(t){return e(t.paths.configHome,`opencode`)}const m=[{id:`vscode`,displayName:`VS Code`,clientType:`gui`,command:`code`,jsonPath:`/servers/GitKraken`,pathFn:t=>e(f(t),`Code`,`User`,`mcp.json`),legacy:!1},{id:`vscode-insiders`,displayName:`VS Code Insiders`,clientType:`gui`,command:`code-insiders`,jsonPath:`/servers/GitKraken`,pathFn:t=>e(f(t),`Code - Insiders`,`User`,`mcp.json`),legacy:!1},{id:`claude`,displayName:`Claude Desktop`,clientType:`gui`,command:`claude`,jsonPath:`/mcpServers/GitKraken`,pathFn:t=>e(f(t),`Claude`,`claude_desktop_config.json`),legacy:!1},{id:`claude-cli`,displayName:`Claude Code`,clientType:`cli`,command:`claude`,jsonPath:`/mcpServers/GitKraken`,pathFn:t=>t.paths.claudeConfigDir?e(t.paths.claudeConfigDir,`.claude.json`):d(t,`.claude.json`),legacy:!1},{id:`antigravity`,displayName:`Antigravity`,clientType:`gui`,command:`antigravity`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.gemini`,`config`,`mcp_config.json`),legacy:!1,host:`antigravity`},{id:`antigravity-cli`,displayName:`Antigravity CLI`,clientType:`cli`,command:`agy`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.gemini`,`config`,`mcp_config.json`),legacy:!1,host:`antigravity`},{id:`windsurf`,displayName:`Windsurf`,clientType:`gui`,command:`windsurf`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.codeium`,`windsurf`,`mcp_config.json`),legacy:!1},{id:`cursor`,displayName:`Cursor`,clientType:`gui`,command:`cursor`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.cursor`,`mcp.json`),legacy:!1},{id:`zed`,displayName:`Zed`,clientType:`gui`,command:`zed`,jsonPath:`/context_servers/GitKraken`,pathFn:t=>t.platform===`win32`?e(t.paths.appSupport,`Zed`,`settings.json`):t.platform===`darwin`?d(t,`.config`,`zed`,`settings.json`):e(t.paths.configHome,`zed`,`settings.json`),legacy:!1},{id:`trae`,displayName:`Trae`,clientType:`gui`,command:`trae`,jsonPath:`/mcpServers/GitKraken`,pathFn:t=>e(f(t),`Trae`,`User`,`mcp.json`),legacy:!1},{id:`copilot`,displayName:`GitHub Copilot CLI`,clientType:`cli`,command:`copilot`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.copilot`,`mcp-config.json`),legacy:!1},{id:`codex`,displayName:`Codex`,clientType:`cli`,command:`codex`,jsonPath:`mcp_servers.GitKraken`,pathFn:e=>d(e,`.codex`,`config.toml`),legacy:!1},{id:`gemini`,displayName:`Gemini CLI`,clientType:`cli`,command:`gemini`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.gemini`,`settings.json`),legacy:!0},{id:`kiro`,displayName:`Kiro`,clientType:`gui`,command:`kiro`,jsonPath:`/mcpServers/GitKraken`,pathFn:e=>d(e,`.kiro`,`settings`,`mcp.json`),legacy:!1},{id:`jetbrains-copilot`,displayName:`JetBrains Copilot`,clientType:`gui`,jsonPath:`/servers/GitKraken`,pathFn:t=>t.platform===`win32`?e(t.paths.localAppData??e(t.paths.home,`AppData`,`Local`),`github-copilot`,`intellij`,`mcp.json`):e(t.paths.configHome,`github-copilot`,`intellij`,`mcp.json`),legacy:!1},{id:`opencode`,displayName:`OpenCode`,clientType:`cli`,command:`opencode`,jsonPath:c,pathFn:t=>e(p(t),`opencode.json`),legacy:!1}];function h(e){return m.find(t=>t.id===e)}function g(e){return h(e)!==void 0}function _(e){return h(e)?.legacy===!0}function v(e){let t=h(e);return t!==void 0&&!t.legacy}function y(e){return h(e)?.clientType??`unknown`}function b(e){return h(e)?.displayName??e}function x(e){return h(e)?.command}function S(){return m.filter(e=>!e.legacy).map(e=>e.id)}function C(){return m.filter(e=>e.legacy).map(e=>e.id)}function w(e){return(h(e)?.host??e).toLowerCase()}function T(e){return h(e)?.host??e}function E(e){return m.filter(t=>!t.legacy&&(t.host??t.id)===e).map(e=>e.id)}function D(e){return e===`v1`?s:c}function O(e,t){return e===`opencode`?D(n(t)):h(e)?.jsonPath??``}async function k(t){let n=p(t),r=e(n,`opencode.jsonc`);return await t.fs.readFile(r)===null?e(n,`opencode.json`):r}async function A(e,t){let n=h(e);if(n)return e===`opencode`?k(t):n.pathFn(t)}async function j(e,t){let n=await A(e,t),r=n?[n]:[];return e===`antigravity`&&r.push(d(t,`.gemini`,`antigravity`,`mcp_config.json`)),r}function M(e){return d(e,`.gemini`,`antigravity`,`mcp_config.json`)}function N(e,t){let n=x(e);if(!(!n||!t.resolveExecutable))return t.resolveExecutable(n)}function P(e,t){let n=h(e);return n?.host?E(n.host).some(n=>n!==e&&N(n,t)!==void 0):!1}async function F(e,t){if(!t)return;let n=t.lastIndexOf(`/`),r=n>0?t.slice(0,n):``;if(r)return r===e.paths.home.replace(/\/+$/,``)?{matched:await e.fs.readFile(t)!==null,source:`config-file`,path:t}:{matched:await e.fs.readDir(r)!==null,source:`config-dir`,path:r}}async function I(e,t,n,r){for(let i of t){let t=await F(n,i);if(t&&(r.push(t.path),t.matched))return{client:e,detected:!0,source:t.source,path:t.path,checkedPaths:r}}return{client:e,detected:!1,reason:`not-found`,checkedPaths:r}}async function L(e,t){let n=N(e,t),r=[];if(n!==void 0)return{client:e,detected:!0,source:`executable`,executablePath:n,checkedPaths:r};let i=h(e);if(i?.host&&i.host!==e)return{client:e,detected:!1,reason:`shared-host-row`,checkedPaths:r};if(e===`antigravity`){let n=i?.pathFn(t);return n&&!P(e,t)&&(r.push(n),await t.fs.readFile(n)!==null)?{client:e,detected:!0,source:`config-file`,path:n,checkedPaths:r}:I(e,[M(t)],t,r)}return I(e,await j(e,t),t,r)}async function R(e,t){let n=[];for(let r of await j(e,t))await z(e,r,t)&&n.push(r);return{client:e,installed:n.length>0,paths:n}}async function z(e,n,r){let s=await r.fs.readFile(n);if(s===null||s.trim()===``)return!1;if(e===`codex`){let e=i(s);if(!e)return!1;let t=O(`codex`);return o(e,t)!==void 0||a(e,t)!==void 0}return(e===`opencode`?u(s):[O(e)]).some(e=>t(s,e)!==void 0)}export{l as OPEN_CODE_JSON_PATHS,s as OPEN_CODE_V1_JSON_PATH,c as OPEN_CODE_V2_JSON_PATH,S as allClients,M as antigravityLegacyPath,x as clientCommand,A as clientConfigPath,j as clientConfigPaths,b as clientDisplayName,N as clientExecutablePath,O as clientJSONPath,y as clientType,E as clientsForHost,L as detectClient,R as getClientInstallation,w as hostIdentity,T as hostOf,v as isInstallable,_ as isLegacy,g as isSupported,C as legacyClientIds,u as openCodeEntryPointers,D as openCodeJSONPath};

package/dist/mcp/config-entry.d.ts

@@ -0,0 +1,15 @@
+import { McpLayoutOptions } from "./opencode-layout.js";
+import { Client } from "./clients.js";
+
+//#region src/mcp/config-entry.d.ts
+/** The shape of an entry `installMcp` writes: keys vary per client family (see {@link generateConfigEntry}). */
+type McpConfigEntry = Record<string, unknown>;
+/**
+ * Builds the entry a client's GitKraken MCP server config carries. Port of
+ * gkcli's `installer.generateConfigs`/`installConfig`: four shapes dispatched
+ * by client family. OpenCode gets its v2 shape unless `options.openCode` selects v1;
+ * `infer-existing` throws {@link OpenCodeMcpLayoutUnknownError} because choosing needs the config file.
+ */
+declare function generateConfigEntry(client: Client, executablePath: string, args: readonly string[], options?: McpLayoutOptions): McpConfigEntry;
+//#endregion
+export { McpConfigEntry, generateConfigEntry };

package/dist/mcp/config-entry.js

@@ -0,0 +1 @@
+import{openCodeLayoutFor as e}from"./opencode-layout.js";function t(t,n,r,i){switch(t){case`zed`:return{source:`custom`,enabled:!0,command:n,args:[...r]};case`copilot`:return{type:`local`,command:n,tools:[`*`],args:[...r]};case`opencode`:return e(i)===`v1`?{type:`local`,command:[n,...r],enabled:!0}:{type:`local`,command:[n,...r],disabled:!1};default:return{type:`stdio`,command:n,args:[...r]}}}export{t as generateConfigEntry};

package/dist/mcp/index.d.ts

@@ -0,0 +1,7 @@
+import { McpConfigEntry, generateConfigEntry } from "./config-entry.js";
+import { McpInstallRequest, McpInstallResult, McpInstallState, McpInstallStateReason, McpInstallStatus, inspectMcpInstall, installMcp } from "./installer.js";
+import { McpLayoutOptions, OpenCodeMcpCleanupError, OpenCodeMcpLayout, OpenCodeMcpLayoutUnknownError, OpenCodeMcpPolicy } from "./opencode-layout.js";
+import { Client, ClientDetection, ClientDetectionSource, ClientInstallation, ClientNotDetectedReason, ClientType, allClients, antigravityLegacyPath, clientCommand, clientConfigPath, clientConfigPaths, clientDisplayName, clientExecutablePath, clientJSONPath, clientType, clientsForHost, detectClient, getClientInstallation, hostIdentity, hostOf, isInstallable, isLegacy, isSupported, legacyClientIds } from "./clients.js";
+import { getMcpCliInstallCommand } from "./cli-install-command.js";
+import { McpUninstallFileResult, McpUninstallRequest, McpUninstallResult, uninstallMcp } from "./uninstaller.js";
+export { type Client, type ClientDetection, type ClientDetectionSource, type ClientInstallation, type ClientNotDetectedReason, type ClientType, type McpConfigEntry, type McpInstallRequest, type McpInstallResult, type McpInstallState, type McpInstallStateReason, type McpInstallStatus, type McpLayoutOptions, type McpUninstallFileResult, type McpUninstallRequest, type McpUninstallResult, OpenCodeMcpCleanupError, type OpenCodeMcpLayout, OpenCodeMcpLayoutUnknownError, type OpenCodeMcpPolicy, allClients, antigravityLegacyPath, clientCommand, clientConfigPath, clientConfigPaths, clientDisplayName, clientExecutablePath, clientJSONPath, clientType, clientsForHost, detectClient, generateConfigEntry, getClientInstallation, getMcpCliInstallCommand, hostIdentity, hostOf, inspectMcpInstall, installMcp, isInstallable, isLegacy, isSupported, legacyClientIds, uninstallMcp };

package/dist/mcp/index.js

@@ -0,0 +1 @@
+import{OpenCodeMcpCleanupError as e,OpenCodeMcpLayoutUnknownError as t}from"./opencode-layout.js";import{allClients as n,antigravityLegacyPath as r,clientCommand as i,clientConfigPath as a,clientConfigPaths as o,clientDisplayName as s,clientExecutablePath as c,clientJSONPath as l,clientType as u,clientsForHost as d,detectClient as f,getClientInstallation as p,hostIdentity as m,hostOf as h,isInstallable as g,isLegacy as _,isSupported as v,legacyClientIds as y}from"./clients.js";import{generateConfigEntry as b}from"./config-entry.js";import{inspectMcpInstall as x,installMcp as S}from"./installer.js";import{getMcpCliInstallCommand as C}from"./cli-install-command.js";import{uninstallMcp as w}from"./uninstaller.js";export{e as OpenCodeMcpCleanupError,t as OpenCodeMcpLayoutUnknownError,n as allClients,r as antigravityLegacyPath,i as clientCommand,a as clientConfigPath,o as clientConfigPaths,s as clientDisplayName,c as clientExecutablePath,l as clientJSONPath,u as clientType,d as clientsForHost,f as detectClient,b as generateConfigEntry,p as getClientInstallation,C as getMcpCliInstallCommand,m as hostIdentity,h as hostOf,x as inspectMcpInstall,S as installMcp,g as isInstallable,_ as isLegacy,v as isSupported,y as legacyClientIds,w as uninstallMcp};