@ken-jo/agent-connector 0.4.79 → 0.4.92

package/dist/{crush-NYDBHIJE.js → crush-ESERLVLT.js}

@@ -9,14 +9,14 @@ import {
 import {
   BaseAdapter,
   renderSkillMd
-} from "./chunk-VVFDU4IX.js";
+} from "./chunk-WFEHWTLM.js";
 import {
   buildHomeBinHookCommand,
   buildWrappedStdio,
   isHomeBinHookCommand
-} from "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+} from "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 
 // src/adapters/crush/index.ts
 import { existsSync, statSync } from "fs";
@@ -495,4 +495,4 @@ export {
   adapter,
   crush_default as default
 };
-//# sourceMappingURL=crush-NYDBHIJE.js.map
+//# sourceMappingURL=crush-ESERLVLT.js.map

package/dist/{cursor-AOELDNZU.js → cursor-FUDOV5VK.js}

@@ -5,13 +5,13 @@ import {
   CursorAdapter,
   adapter,
   cursor_default
-} from "./chunk-NBUEL74R.js";
+} from "./chunk-JFXL4HYA.js";
 import "./chunk-H53QZQJI.js";
 import "./chunk-BEFVJ2OE.js";
-import "./chunk-VVFDU4IX.js";
-import "./chunk-HORHRHNG.js";
-import "./chunk-YYNXIUR2.js";
-import "./chunk-IXOQDZWC.js";
+import "./chunk-WFEHWTLM.js";
+import "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
 export {
   CURSOR_EVENT_MAP,
   CURSOR_HOOKS_VERSION,
@@ -19,4 +19,4 @@ export {
   adapter,
   cursor_default as default
 };
-//# sourceMappingURL=cursor-AOELDNZU.js.map
+//# sourceMappingURL=cursor-FUDOV5VK.js.map

package/dist/{detect-ALAKE54S.js → detect-Z5BDTY6B.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   print
-} from "./chunk-VKRGQLY4.js";
+} from "./chunk-5Z36KVU2.js";
 import {
   detectInstalledPlatforms
-} from "./chunk-S4E6QQEM.js";
-import "./chunk-X457NOFE.js";
+} from "./chunk-FO5CEXXN.js";
+import "./chunk-KA55FISM.js";
 
 // src/cli/commands/detect.ts
 import { parseArgs } from "util";
@@ -71,4 +71,4 @@ async function run(argv) {
 export {
   run
 };
-//# sourceMappingURL=detect-ALAKE54S.js.map
+//# sourceMappingURL=detect-Z5BDTY6B.js.map

package/dist/devin-Y7PWKVHY.js

@@ -0,0 +1,510 @@
+#!/usr/bin/env node
+import {
+  normalizeSessionSource
+} from "./chunk-H53QZQJI.js";
+import {
+  rewriteEnvRefs
+} from "./chunk-BEFVJ2OE.js";
+import {
+  BaseAdapter
+} from "./chunk-WFEHWTLM.js";
+import {
+  buildWrappedStdio,
+  isHomeBinHookCommand
+} from "./chunk-4NHXLXSD.js";
+import "./chunk-M2H7JURF.js";
+import "./chunk-GZGLCCEE.js";
+
+// src/adapters/devin/index.ts
+import { existsSync } from "fs";
+import { homedir, platform as osPlatform } from "os";
+import { join } from "path";
+var HOST = "devin";
+var MCP_ROOT_KEY = "mcpServers";
+function devinUserConfigDir() {
+  if (osPlatform() === "win32") {
+    const appData = process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return join(appData, "devin");
+  }
+  return join(homedir(), ".config", "devin");
+}
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "PermissionRequest",
+  "UserPromptSubmit",
+  "Stop",
+  "PostCompact",
+  "SessionStart",
+  "SessionEnd"
+]);
+var DEVIN_POSTCOMPACT = "PostCompaction";
+var DevinAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Devin CLI (Cognition)";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Memory surface: AGENTS.md-first managed block — project <projectDir>/AGENTS.md
+    // via the base default; user scope → ~/.config/devin/AGENTS.md (override below).
+    // Devin reads AGENTS.md / AGENT.md / CLAUDE.md identically as always-on rules
+    // (docs.devin.ai/cli/extensibility/rules).
+    supportsMemory: true,
+    preToolUse: true,
+    postToolUse: true,
+    userPromptSubmit: true,
+    stop: true,
+    sessionStart: true,
+    sessionEnd: true,
+    // PermissionRequest is a documented Devin hook event (decision-capable).
+    permissionRequest: true,
+    // PostCompaction (canonical PostCompact) — observe-only post-compaction hook.
+    postCompact: true,
+    // Devin documents NO Notification / PreCompact / SubagentStart / SubagentStop /
+    // PostToolUseFailure event — those stay unset (install reports the skip-warn).
+    notification: false,
+    preCompact: false,
+    // Devin's PreToolUse/PermissionRequest can block/deny via the simple
+    // {decision} reply, but it documents no tool-arg/-output rewrite and no
+    // context-injection reply channel.
+    canModifyArgs: false,
+    canModifyOutput: false,
+    canInjectSessionContext: false,
+    // Devin registers stdio and remote MCP servers. Remote is Streamable HTTP
+    // ("http", the URL default) with a legacy "sse" fallback — both map to our
+    // remote-transport handling; advertise both.
+    transports: ["stdio", "http", "sse"],
+    // Devin natively interpolates ${env:VAR} / ${file:/path} in secret-bearing
+    // server fields, so the token survives into the host config (pass-through).
+    nativeServerEnvInterpolation: true,
+    // Content surfaces. Devin reads Agent Skills from its `.devin` config tree
+    // at <configDir>/skills/<name>/SKILL.md — the SKILL.md format + frontmatter
+    // are byte-confirmed (docs.devin.ai/cli/extensibility/skills/creating-skills),
+    // so skills IS wired.
+    supportsSkills: true
+    // Devin ALSO documents native slash commands (/cli/reference/commands) and
+    // subagents (/cli/subagents), but their exact on-disk dir names are NOT
+    // byte-confirmed from a first-party config reference — to avoid fabricating a
+    // path, commands/subagents stay unset (BaseAdapter skip-warn) in v1. See the
+    // module header CEILING note.
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(projectDir) {
+    const userDir = devinUserConfigDir();
+    const userCfg = join(userDir, "config.json");
+    const projDir = join(projectDir, ".devin");
+    const projCfg = join(projDir, "config.json");
+    const binMarker = join(homedir(), ".local", "bin", "devin");
+    const userInstalled = existsSync(userDir) || existsSync(userCfg) || existsSync(binMarker);
+    const projInstalled = existsSync(projDir) || existsSync(projCfg);
+    const installed = userInstalled || projInstalled;
+    const scope = projInstalled && !userInstalled ? "project" : "user";
+    const configPath = scope === "project" ? projCfg : userCfg;
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      configPath,
+      scope,
+      reason: installed ? `found Devin CLI config (${scope}) at ${configPath}` : `no Devin CLI config at ${userDir} or ${projDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ─────────────────────────────────────────────────────────
+  getConfigDir(ctx) {
+    return ctx.scope === "project" ? join(ctx.projectDir, ".devin") : devinUserConfigDir();
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "config.json");
+  }
+  /** Hooks live under the `"hooks"` key in the SAME config.json. */
+  getHookConfigPath(ctx) {
+    return this.getServerConfigPath(ctx);
+  }
+  // ── Memory surface: user-scope AGENTS.md ─────────────────────────────────
+  // Project scope rides on the AGENTS.md base default (project root). User scope
+  // targets ~/.config/devin/AGENTS.md (%APPDATA%\devin\AGENTS.md on Windows) —
+  // Devin's documented global-rules file (docs.devin.ai/cli/extensibility/rules).
+  memoryTargets(ctx) {
+    if (this.memoryOverride(ctx)?.path || ctx.scope !== "user") {
+      return super.memoryTargets(ctx);
+    }
+    return [
+      {
+        path: join(devinUserConfigDir(), "AGENTS.md"),
+        reason: "Devin CLI global rules file (~/.config/devin/AGENTS.md)"
+      }
+    ];
+  }
+  // ── MCP server install / uninstall ───────────────────────────────────────
+  installServer(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: connector.server ? "server registration disabled for devin" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const serverPath = this.getServerConfigPath(ctx);
+    const entry = this.renderServerEntry(ctx, server);
+    return [
+      this.upsertServerInJson(serverPath, MCP_ROOT_KEY, connector.id, entry, ctx.dryRun)
+    ];
+  }
+  uninstallServer(ctx) {
+    const serverPath = this.getServerConfigPath(ctx);
+    return [
+      this.removeServerFromJson(serverPath, MCP_ROOT_KEY, ctx.connector.id, ctx.dryRun)
+    ];
+  }
+  /** Render a normalized ServerDef into Devin's native mcpServers entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      ({ command, args } = buildWrappedStdio(ctx, server, this.id, command, args));
+      const entry2 = { command };
+      if (args.length > 0) entry2.args = args;
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      return entry2;
+    }
+    const entry = {
+      url: rewriteEnvRefs(server.url ?? "", devinEnvToken)
+    };
+    if (transport === "sse") entry.transport = "sse";
+    const headers = this.renderEnv(server.headers);
+    if (headers) entry.headers = headers;
+    return entry;
+  }
+  /**
+   * Render env/header values. Devin interpolates ${env:VAR} natively, so each
+   * ${env:VAR} token is passed THROUGH (rewriteEnvRefs/devinEnvToken) rather
+   * than baked to a literal — secrets never land in the committed config.
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(env)) {
+      out[k] = rewriteEnvRefs(v, devinEnvToken);
+    }
+    return out;
+  }
+  // ── Hook install / uninstall (config.json "hooks" key, nested-rule shape) ──
+  installHooks(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.hooks === false) {
+      return [{ platform: this.id, action: "skip", detail: "hooks disabled for devin" }];
+    }
+    if (connector.hookEvents.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no hooks" }];
+    }
+    const pending = connector.hookEvents.map((event) => ({
+      event,
+      matcher: connector.hooks[event]?.matcher ?? ""
+    }));
+    return this.upsertHookEntries(
+      ctx,
+      this.getHookConfigPath(ctx),
+      pending,
+      this.hookDescriptor(ctx)
+    );
+  }
+  uninstallHooks(ctx) {
+    return this.removeHookEntries(ctx, this.getHookConfigPath(ctx), this.hookDescriptor(ctx));
+  }
+  /**
+   * Devin's hook-merge descriptor (NESTED shape `{ matcher, hooks: [...] }`).
+   * Bound to `ctx` because Devin's ownership is CONNECTOR-GENERIC (ANY of our
+   * commands in the entry's inner `hooks`):
+   *  - mapEvent = drop events outside SUPPORTED_EVENTS; the canonical
+   *    PostCompact is rewritten to Devin's on-wire "PostCompaction" key while
+   *    all other supported events map 1:1.
+   *  - entryOwnsCommand reuses isOurCommand over the inner commands.
+   *  - uninstall = inner-strip ONLY (ownsEntryForRemove never-true).
+   */
+  hookDescriptor(ctx) {
+    return {
+      mapEvent: (e) => {
+        if (!SUPPORTED_EVENTS.has(e)) return void 0;
+        return e === "PostCompact" ? DEVIN_POSTCOMPACT : e;
+      },
+      unmappedWarnDetail: (e) => `${e} has no Devin hook equivalent \u2014 skipped`,
+      renderEntry: (_event, matcher, command) => ({
+        matcher,
+        hooks: [{ type: "command", command }]
+      }),
+      entryOwnsCommand: (entry, _command) => (entry.hooks ?? []).some((h) => this.isOurCommand(h.command, ctx)),
+      ownsEntryForRemove: () => () => false,
+      stripInner: (c) => (entry) => {
+        const innerBefore = entry.hooks?.length ?? 0;
+        const inner = (entry.hooks ?? []).filter((h) => !this.isOurCommand(h.command, c));
+        return {
+          next: inner.length > 0 ? { matcher: entry.matcher ?? "", hooks: inner } : null,
+          removed: innerBefore - inner.length
+        };
+      },
+      skipDetail: (event) => `hooks.${event} already registered`,
+      removeDetail: (event, removed) => `hooks.${event} (${removed})`,
+      absentDetail: "no hooks section present",
+      noMatchDetail: "no matching hook entries"
+    };
+  }
+  /** True when a hook command references our home binary AND this connector id
+   *  (anchored so a shared-prefix id can't collide — see isHomeBinHookCommand). */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Content surfaces: skills ──────────────────────────────────────────────
+  // CEILING (v1): only the byte-confirmed SKILL.md layout is wired. Devin
+  // documents the SKILL.md format + frontmatter
+  // (docs.devin.ai/cli/extensibility/skills/creating-skills) under the `.devin`
+  // tree (<configDir>/skills/<name>/SKILL.md). Commands/subagents on-disk dir
+  // names are NOT byte-confirmed from a first-party config reference, so they
+  // stay on the BaseAdapter skip-warn rather than guessing a path.
+  /** Native skill dir: <configDir>/skills/<name>. */
+  skillDir(ctx, name) {
+    return join(this.getConfigDir(ctx), "skills", name);
+  }
+  installSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.platforms[HOST]?.skills === false) {
+      return [{ platform: this.id, action: "skip", detail: "skills disabled for devin" }];
+    }
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(
+        this.writeContentFile(join(dir, "SKILL.md"), this.renderSkill(skill), ctx.dryRun)
+      );
+      for (const [rel, contents] of Object.entries(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) {
+          changes.push({
+            platform: this.id,
+            action: "warn",
+            detail: `skill resource "${rel}" escapes the skill dir; skipped`
+          });
+          continue;
+        }
+        changes.push(this.writeContentFile(target, contents, ctx.dryRun));
+      }
+    }
+    return changes;
+  }
+  uninstallSkills(ctx) {
+    const { connector } = ctx;
+    if (connector.skills.length === 0) {
+      return [{ platform: this.id, action: "skip", detail: "connector declares no skills" }];
+    }
+    const changes = [];
+    for (const skill of connector.skills) {
+      const dir = this.skillDir(ctx, skill.name);
+      changes.push(this.removeContentFile(join(dir, "SKILL.md"), ctx.dryRun));
+      for (const rel of Object.keys(skill.resources ?? {})) {
+        const target = this.resolveWithin(dir, rel);
+        if (target === null) continue;
+        changes.push(this.removeContentFile(target, ctx.dryRun));
+      }
+      changes.push(this.removeDirIfEmpty(dir, ctx.dryRun));
+    }
+    return changes;
+  }
+  /**
+   * Render a skill's SKILL.md: frontmatter (name, description) + body. Devin's
+   * SKILL.md frontmatter documents name/description; extra keys pass through
+   * verbatim. No model/allowed-tools skill field is emitted.
+   */
+  renderSkill(skill) {
+    const frontmatter = {
+      name: skill.name,
+      description: skill.description
+    };
+    if (skill.extra) Object.assign(frontmatter, skill.extra);
+    return this.renderFrontmatterMd(frontmatter, skill.body);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const cfgPath = this.getServerConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    return [
+      {
+        name: `${this.name}: config.json present`,
+        check: () => existsSync(cfgPath) ? { status: "OK", detail: cfgPath } : { status: "FAIL", detail: `not found: ${cfgPath}` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const cfg = this.readJson(cfgPath);
+          const bucket = cfg?.[MCP_ROOT_KEY];
+          if (!cfg || !bucket) {
+            return { status: "FAIL", detail: `no ${MCP_ROOT_KEY} in ${cfgPath}` };
+          }
+          return connectorId in bucket ? { status: "OK", detail: `${MCP_ROOT_KEY}.${connectorId} present` } : {
+            status: "FAIL",
+            detail: `no ${MCP_ROOT_KEY}.${connectorId} in ${cfgPath}`
+          };
+        }
+      },
+      {
+        name: `${this.name}: hook command registered`,
+        check: () => {
+          if (hookEvents.length === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const file = this.readJson(cfgPath);
+          if (!file) return { status: "FAIL", detail: `cannot read ${cfgPath}` };
+          const hooks = file.hooks ?? {};
+          const registered = Object.values(hooks).some(
+            (entries) => (entries ?? []).some(
+              (e) => (e.hooks ?? []).some(
+                (h) => isHomeBinHookCommand(h.command, homeBin, connectorId)
+              )
+            )
+          );
+          return registered ? { status: "OK", detail: "hook command present" } : { status: "FAIL", detail: `no hook for ${connectorId} in ${cfgPath}` };
+        }
+      }
+    ];
+  }
+  // ── Runtime: parse Devin stdin JSON → normalized event ─────────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = typeof input.session_id === "string" ? input.session_id : "";
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {},
+          ...toolResponseToString(input.tool_response) !== void 0 ? { toolOutput: toolResponseToString(input.tool_response) } : {}
+        };
+        return ev;
+      }
+      case "PermissionRequest": {
+        const ev = {
+          ...base,
+          toolName: input.tool_name ?? "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.prompt === "string" ? input.prompt : ""
+        };
+        return ev;
+      }
+      case "Stop": {
+        const ev = {
+          ...base,
+          ...typeof input.stop_hook_active === "boolean" ? { stopHookActive: input.stop_hook_active } : {}
+        };
+        return ev;
+      }
+      case "PostCompact": {
+        const ev = { ...base };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "SessionEnd": {
+        const ev = {
+          ...base,
+          ...typeof input.reason === "string" ? { reason: input.reason } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported devin hook event: ${String(event)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Devin native (simple {decision}) reply ──
+  formatReply(event, response) {
+    const decision = response.decision ?? "allow";
+    if (event === "PostCompact" || event === "SessionEnd") {
+      return { exitCode: 0 };
+    }
+    if (event === "PermissionRequest") {
+      if (decision === "deny") {
+        return this.stdout({
+          decision: "deny",
+          reason: response.reason ?? "Denied by hook"
+        });
+      }
+      if (decision === "allow") {
+        return this.stdout({ decision: "approve" });
+      }
+      return { exitCode: 0 };
+    }
+    if (decision === "deny") {
+      return this.stdout({
+        decision: "block",
+        reason: response.reason ?? "Blocked by hook"
+      });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function devinEnvToken(name, def) {
+  return def !== void 0 ? `\${env:${name}:-${def}}` : `\${env:${name}}`;
+}
+function toolResponseToString(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var adapter = new DevinAdapter();
+var devin_default = adapter;
+export {
+  DevinAdapter,
+  adapter,
+  devin_default as default
+};
+//# sourceMappingURL=devin-Y7PWKVHY.js.map