@pushary/agent-hooks 0.87.2 → 0.87.3

package/dist/chunk-ZGC3W23N.js

@@ -0,0 +1,371 @@
+import {
+  HOOK_BUDGETS,
+  OPENCODE_APPROVAL_EVENT
+} from "./chunk-DMW54VWK.js";
+
+// src/opencode-plugin.ts
+var OPENCODE_PLUGIN_MARKER = "pushary-opencode-plugin w1";
+var OPENCODE_PLUGIN_PLACEHOLDER = "__PUSHARY_COMMAND__";
+var OPENCODE_PLUGIN_FILE = "pushary.js";
+var OPENCODE_PLUGIN_DIR = "plugins";
+var OPENCODE_PLUGIN_SIBLING = "package.json";
+var OPENCODE_PLUGIN_SIBLING_CONTENTS = `${JSON.stringify({ type: "module" }, null, 2)}
+`;
+var OPENCODE_ASKED_EVENTS = ["permission.asked", "permission.updated"];
+var OPENCODE_REPLIED_EVENT = "permission.replied";
+var OPENCODE_IDLE_EVENT = "session.idle";
+var approvalTimeoutMs = () => (HOOK_BUDGETS.opencode.budgetSeconds - HOOK_BUDGETS.opencode.guardSeconds) * 1e3;
+var openCodePluginSource = () => `// Pushary for OpenCode. Generated by @pushary/agent-hooks \u2014 do not edit.
+// ${OPENCODE_PLUGIN_MARKER}
+//
+// OpenCode finds a plugin by globbing {plugin,plugins}/*.{ts,js} under its config
+// directory and importing it, so this file is the whole install.
+//
+// It decides nothing. Each hook builds the payload OpenCode handed it, writes it
+// to the Pushary hook command on stdin, and reads a verdict back. The policy
+// engine, the phone, the wait and the settlement all live behind that command.
+//
+// Approvals ride the event stream rather than the "permission.ask" hook, which is
+// declared in @opencode-ai/plugin and called by nothing. Permission.ask publishes
+// "permission.asked" and blocks on a Deferred that only a reply resolves, so this
+// answers that reply on the person's behalf when Pushary has a verdict.
+//
+// Failure is silence. A missing command, a crash, a timeout, unreadable bytes and
+// an unparseable reply all leave OpenCode's own prompt exactly as it was. The
+// worst this file may do to somebody is nothing at all.
+
+import { spawn } from "node:child_process"
+
+const COMMAND = ${OPENCODE_PLUGIN_PLACEHOLDER}
+const APPROVAL_TIMEOUT_MS = ${approvalTimeoutMs()}
+const TELEMETRY_TIMEOUT_MS = 10000
+const MAX_REPLY_BYTES = 65536
+// One entry per call in flight. Bounded because a long session must not grow them
+// without limit, and evicted oldest-first because whatever is still waiting on an
+// answer is the newest thing in here, never the oldest.
+const MAX_TRACKED = 256
+
+const text = (value) => (typeof value === "string" && value.length > 0 ? value : undefined)
+
+const remember = (map, key, value) => {
+  if (!key || value === undefined) return
+  if (map.size >= MAX_TRACKED) map.delete(map.keys().next().value)
+  map.set(key, value)
+}
+
+const run = (payload, timeoutMs, onSpawn) =>
+  new Promise((resolve) => {
+    let settled = false
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve(value)
+    }
+
+    let child
+    try {
+      child = spawn(COMMAND[0], COMMAND.slice(1), { stdio: ["pipe", "pipe", "ignore"] })
+    } catch {
+      return finish(null)
+    }
+    if (onSpawn) onSpawn(child)
+
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL")
+      } catch {}
+      finish(null)
+    }, timeoutMs)
+    if (typeof timer.unref === "function") timer.unref()
+
+    let out = ""
+    child.stdout.on("data", (chunk) => {
+      if (out.length < MAX_REPLY_BYTES) out += chunk
+    })
+    child.on("error", () => finish(null))
+    child.on("close", () => {
+      const body = out.trim()
+      if (!body) return finish(null)
+      try {
+        finish(JSON.parse(body))
+      } catch {
+        finish(null)
+      }
+    })
+
+    try {
+      child.stdin.on("error", () => {})
+      child.stdin.end(JSON.stringify(payload))
+    } catch {
+      finish(null)
+    }
+  })
+
+// Telemetry is fire and forget: the agent has already acted and is only being
+// observed, so nothing here may hold up the next turn.
+const tell = (payload) => {
+  void run(payload, TELEMETRY_TIMEOUT_MS)
+}
+
+// What OpenCode gates on, and what it hands over with it. Verified against its own
+// tools: bash asks with { command }, write and edit both ask under "edit" with
+// { filepath, diff }, webfetch with { url }, and a shell command reaching outside
+// the worktree asks a second time under "external_directory".
+const inputFrom = (permission, metadata) => {
+  const meta = metadata && typeof metadata === "object" ? metadata : {}
+  const command = text(meta.command)
+  if (command) return { command }
+  const filepath = text(meta.filepath) ?? text(meta.file_path)
+  // The diff rides along, because it is what the person is actually approving.
+  // OpenCode computes it before raising the permission and hands it over; without
+  // it the phone shows a filename and nothing to judge.
+  if (filepath) return { file_path: filepath, ...(text(meta.diff) ? { diff: meta.diff } : {}) }
+  const url = text(meta.url)
+  if (url) return { url }
+  return { permission }
+}
+
+// Two spellings of one request: the runtime publishes PermissionV1.Request
+// ({ permission, patterns }), the generated SDK types say Permission ({ type,
+// pattern }). Whichever arrives, the id and the session are what we need.
+const askedFrom = (properties) => {
+  if (!properties || typeof properties !== "object") return null
+  const id = text(properties.id)
+  const sessionID = text(properties.sessionID)
+  if (!id || !sessionID) return null
+  return {
+    id,
+    sessionID,
+    permission: text(properties.permission) ?? text(properties.type) ?? "unknown",
+    metadata: properties.metadata,
+    title: text(properties.title),
+    callID: text(properties.callID) ?? text(properties.tool && properties.tool.callID),
+  }
+}
+
+const repliedID = (properties) => {
+  if (!properties || typeof properties !== "object") return undefined
+  return text(properties.requestID) ?? text(properties.permissionID) ?? text(properties.id)
+}
+
+export const PusharyPlugin = async ({ client, directory, worktree }) => {
+  const cwd = worktree || directory || process.cwd()
+  // OpenCode raises a permission under a coarse key \u2014 "edit" covers both write and
+  // edit \u2014 and names the actual tool only on tool.execute.before. Keeping the
+  // pairing is what lets a rule written for Write mean Write here too.
+  const tools = new Map()
+  // Every gate still waiting. Held so a person answering in the terminal can end
+  // ours: whoever answers first wins, and the loser stops asking.
+  const waiting = new Map()
+
+  const base = (sessionID) => ({ session_id: sessionID ?? "", cwd })
+
+  // Replying is the whole approval. Two shapes, because the client handed to a
+  // plugin is generated: v1 exposes postSessionIdPermissionsPermissionId against
+  // /session/{id}/permissions/{permissionID}, v2 exposes permission.reply against
+  // /permission/{requestID}/reply. Both routes are live in the server today.
+  const respond = async (asked, allow) => {
+    const legacy = client && typeof client.postSessionIdPermissionsPermissionId === "function"
+      ? () => client.postSessionIdPermissionsPermissionId({
+          path: { id: asked.sessionID, permissionID: asked.id },
+          body: { response: allow ? "once" : "reject" },
+        })
+      : null
+    const current = client && client.permission && typeof client.permission.reply === "function"
+      ? () => client.permission.reply({
+          path: { requestID: asked.id },
+          body: { reply: allow ? "once" : "reject" },
+        })
+      : null
+
+    for (const attempt of [legacy, current]) {
+      if (!attempt) continue
+      try {
+        await attempt()
+        return
+      } catch {
+        // The person answered first, or this client does not serve that route.
+        // Either way the next shape is the only thing left to try.
+      }
+    }
+  }
+
+  const gate = async (asked) => {
+    const reply = await run({
+      ...base(asked.sessionID),
+      hook_event_name: "${OPENCODE_APPROVAL_EVENT}",
+      tool_name: tools.get(asked.callID) ?? asked.permission,
+      tool_input: inputFrom(asked.permission, asked.metadata),
+      permission_id: asked.id,
+      permission_type: asked.permission,
+      title: asked.title,
+    }, APPROVAL_TIMEOUT_MS, (child) => remember(waiting, asked.id, child))
+
+    // Gone means the terminal already answered while we were asking. Replying now
+    // would be answering a question nobody is holding open any more.
+    if (!waiting.delete(asked.id)) return
+
+    const status = reply && typeof reply === "object" ? reply.status : undefined
+    if (status !== "allow" && status !== "deny") return
+    await respond(asked, status === "allow")
+  }
+
+  const withdraw = (id) => {
+    const child = id && waiting.get(id)
+    if (!child) return
+    waiting.delete(id)
+    // SIGTERM rather than SIGKILL: the hook cancels its outstanding question on
+    // the way out, so the phone stops showing a decision the terminal has taken.
+    try {
+      child.kill("SIGTERM")
+    } catch {}
+  }
+
+  return {
+    "tool.execute.before": async (input) => {
+      remember(tools, input && input.callID, input && input.tool)
+    },
+
+    "tool.execute.after": async (input, output) => {
+      const call = input && input.callID
+      if (call) tools.delete(call)
+      tell({
+        ...base(input && input.sessionID),
+        hook_event_name: "tool.execute.after",
+        tool_name: text(input && input.tool) ?? "unknown",
+        tool_input: input && input.args && typeof input.args === "object" ? input.args : {},
+        tool_result: { title: text(output && output.title), output: text(output && output.output) },
+      })
+    },
+
+    "chat.message": async (input, output) => {
+      const parts = output && Array.isArray(output.parts) ? output.parts : []
+      const prompt = parts
+        .filter((part) => part && part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\\n")
+        .trim()
+      if (!prompt) return
+      tell({ ...base(input && input.sessionID), hook_event_name: "chat.message", prompt })
+    },
+
+    event: async ({ event }) => {
+      // Never allowed to throw: the host calls this hook without awaiting it, so a
+      // rejection here is an unhandled rejection in somebody's editor.
+      try {
+        const type = event && event.type
+        const properties = event && event.properties
+        if (${JSON.stringify(OPENCODE_ASKED_EVENTS)}.includes(type)) {
+          const asked = askedFrom(properties)
+          if (asked) void gate(asked)
+          return
+        }
+        if (type === ${JSON.stringify(OPENCODE_REPLIED_EVENT)}) {
+          withdraw(repliedID(properties))
+          return
+        }
+        // session.idle is the turn boundary \u2014 OpenCode's equivalent of Claude's
+        // Stop, not of its SessionEnd. Nothing else on the stream is relayed: the
+        // receipts already arrive through the hooks above, and reporting the same
+        // moment twice would double every row on the account.
+        if (type === ${JSON.stringify(OPENCODE_IDLE_EVENT)}) {
+          tell({
+            ...base(properties && properties.sessionID),
+            hook_event_name: ${JSON.stringify(OPENCODE_IDLE_EVENT)},
+          })
+        }
+      } catch {}
+    },
+
+    dispose: async () => {
+      for (const id of Array.from(waiting.keys())) withdraw(id)
+      tools.clear()
+    },
+  }
+}
+`;
+var openCodePluginModule = () => ({
+  marker: OPENCODE_PLUGIN_MARKER,
+  source: openCodePluginSource(),
+  placeholder: OPENCODE_PLUGIN_PLACEHOLDER,
+  sibling: {
+    path: OPENCODE_PLUGIN_SIBLING,
+    contents: OPENCODE_PLUGIN_SIBLING_CONTENTS
+  }
+});
+var renderOpenCodePlugin = (module, argv) => module.source.replace(module.placeholder, JSON.stringify(argv));
+var isOpenCodePluginOurs = (contents) => contents.includes(OPENCODE_PLUGIN_MARKER);
+
+// src/opencode-config.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var OPENCODE_HOOK_BINARY = "pushary-opencode-hook";
+var openCodeConfigDirFrom = (home, env = process.env) => env.OPENCODE_CONFIG_DIR?.trim() || join(env.XDG_CONFIG_HOME?.trim() || join(home, ".config"), "opencode");
+var openCodeConfigDir = () => openCodeConfigDirFrom(homedir());
+var OPENCODE_PLUGIN_PATH = `${OPENCODE_PLUGIN_DIR}/${OPENCODE_PLUGIN_FILE}`;
+var openCodePluginDir = () => join(openCodeConfigDir(), OPENCODE_PLUGIN_DIR);
+var openCodePluginFile = () => join(openCodePluginDir(), OPENCODE_PLUGIN_FILE);
+var OPENCODE_HOOK_EVENTS = [
+  { event: OPENCODE_APPROVAL_EVENT, delivery: "approval", timeout: HOOK_BUDGETS.opencode.budgetSeconds },
+  { event: "tool.execute.after", delivery: "telemetry", timeout: 10 },
+  { event: "chat.message", delivery: "telemetry", timeout: 10 },
+  { event: OPENCODE_IDLE_EVENT, delivery: "telemetry", timeout: 10 }
+];
+var hasForeignPlugins = (entries) => entries.some((entry) => entry !== OPENCODE_PLUGIN_FILE && /\.(ts|js)$/.test(entry));
+var installOpenCodePlugin = (argv, dir = openCodePluginDir()) => {
+  mkdirSync(dir, { recursive: true });
+  const plugin = join(dir, OPENCODE_PLUGIN_FILE);
+  writeFileSync(plugin, renderOpenCodePlugin(openCodePluginModule(), argv), "utf-8");
+  const sibling = join(dir, OPENCODE_PLUGIN_SIBLING);
+  if (existsSync(sibling)) return { plugin, wroteSibling: false };
+  writeFileSync(sibling, OPENCODE_PLUGIN_SIBLING_CONTENTS, "utf-8");
+  return { plugin, wroteSibling: true };
+};
+var openCodeWired = (dir = openCodePluginDir()) => {
+  try {
+    return isOpenCodePluginOurs(readFileSync(join(dir, OPENCODE_PLUGIN_FILE), "utf-8"));
+  } catch {
+    return false;
+  }
+};
+var OPENCODE_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var OPENCODE_CONFIG_FILE = "opencode.json";
+var openCodeConfigFile = () => join(openCodeConfigDir(), OPENCODE_CONFIG_FILE);
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var addOpenCodeMcpServer = (config, apiKey) => {
+  const servers = asRecord(config.mcp) ?? {};
+  servers.pushary = {
+    type: "remote",
+    url: OPENCODE_MCP_URL,
+    enabled: true,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+  config.mcp = servers;
+};
+var removeOpenCodeMcpServer = (config) => {
+  const servers = asRecord(config.mcp);
+  if (!servers || !("pushary" in servers)) return false;
+  delete servers.pushary;
+  if (Object.keys(servers).length === 0) delete config.mcp;
+  return true;
+};
+
+export {
+  OPENCODE_PLUGIN_PLACEHOLDER,
+  OPENCODE_PLUGIN_SIBLING,
+  OPENCODE_PLUGIN_SIBLING_CONTENTS,
+  isOpenCodePluginOurs,
+  OPENCODE_HOOK_BINARY,
+  openCodeConfigDirFrom,
+  openCodeConfigDir,
+  openCodePluginDir,
+  openCodePluginFile,
+  hasForeignPlugins,
+  installOpenCodePlugin,
+  openCodeWired,
+  openCodeConfigFile,
+  addOpenCodeMcpServer,
+  removeOpenCodeMcpServer
+};

package/dist/src/index.js

@@ -1,8 +1,8 @@
 import {
   handlePreToolUse
-} from "../chunk-HJ44HIUW.js";
+} from "../chunk-OMA2OZRE.js";
 import "../chunk-ATBKJNWS.js";
-import "../chunk-7MBDFNUC.js";
+import "../chunk-VIHRP25S.js";
 import "../chunk-YHG74UFF.js";
 import {
   fetchModeOverride,
@@ -12,16 +12,17 @@ import {
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-V2XPF77V.js";
+} from "../chunk-VOE4SYPR.js";
 import {
   askUser,
   cancelQuestion,
   waitForAnswer
 } from "../chunk-J3YDT4HM.js";
+import "../chunk-7J67NYK4.js";
 import "../chunk-RN3NOEJF.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
-import "../chunk-Y3UTTFTZ.js";
+import "../chunk-KBS53WOE.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
 import {
@@ -30,7 +31,7 @@ import {
 } from "../chunk-2UMNXADU.js";
 import {
   resolvePolicy
-} from "../chunk-7YJS2VTG.js";
+} from "../chunk-DMW54VWK.js";
 export {
   askUser,
   cancelQuestion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.87.2",
+  "version": "0.87.3",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",
@@ -56,6 +56,7 @@
     "pushary-codex-hook": "./dist/bin/pushary-codex-hook.js",
     "pushary-gemini-hook": "./dist/bin/pushary-gemini-hook.js",
     "pushary-gemini-bridge": "./dist/bin/pushary-gemini-bridge.js",
+    "pushary-opencode-hook": "./dist/bin/pushary-opencode-hook.js",
     "pushary-setup": "./dist/bin/pushary-setup.js",
     "pushary-clean": "./dist/bin/pushary-clean.js",
     "pushary-status": "./dist/bin/pushary-status.js",