agent-relay-runner 0.127.0 → 0.127.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.127.0",
+  "version": "0.127.2",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.127.0",
+  "version": "0.127.2",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/mcp-outbox.ts

@@ -67,7 +67,12 @@ export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Pro
     }
     logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
   } catch (error) {
-    if (isHttpStatusError(error, 409)) return;
+    if (isHttpStatusError(error, 409)) {
+      if (record.kind === "session-message-batch") {
+        logger.error("outbox", `relay reported duplicate session batch; acking row seq=${record.seq} batchKey=${record.idempotencyKey} itemKeys=${sessionBatchItemKeys(record).join(",")} error=${errMessage(error)}`);
+      }
+      return;
+    }
     if (isHttpAuthError(error)) input.recoverRuntimeTokenAfterAuthFailure("outbox");
     throw error;
   }
@@ -89,6 +94,13 @@ function isDeterministicValidationError(error: unknown): boolean {
   return status === 400 || status === 413 || status === 422;
 }
 
+function sessionBatchItemKeys(record: OutboxRecord): string[] {
+  const messages = Array.isArray((record.payload as { messages?: unknown }).messages)
+    ? (record.payload as { messages: SendMessageInput[] }).messages
+    : [];
+  return messages.map((message, index) => message.idempotencyKey ?? `${record.idempotencyKey}:${index}`);
+}
+
 export async function deliverBufferedMcpCall(input: {
   record: OutboxRecord;
   relayUrl: string;

package/src/provisioning.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
@@ -355,6 +356,126 @@ export function writeCodexHooksJson(codexHome: string, hooks: ProvisioningHookSe
     return;
   }
   writeFileSync(join(codexHome, "hooks.json"), JSON.stringify({ hooks }, null, 2), { mode: 0o600 });
+  writeCodexHookTrustState(codexHome, hooks);
+}
+
+const CODEX_HOOK_EVENT_STATE_KEYS: Record<string, string> = {
+  PreToolUse: "pre_tool_use",
+  PermissionRequest: "permission_request",
+  PostToolUse: "post_tool_use",
+  PreCompact: "pre_compact",
+  PostCompact: "post_compact",
+  SessionStart: "session_start",
+  UserPromptSubmit: "user_prompt_submit",
+  SubagentStart: "subagent_start",
+  SubagentStop: "subagent_stop",
+  Stop: "stop",
+};
+
+interface CodexHookTrustEntry {
+  key: string;
+  trustedHash: string;
+}
+
+export function codexHookTrustEntries(codexHome: string, hooks: ProvisioningHookSet): CodexHookTrustEntry[] {
+  const sourcePath = join(codexHome, "hooks.json");
+  const entries: CodexHookTrustEntry[] = [];
+  for (const [eventName, groups] of Object.entries(hooks)) {
+    const eventKey = CODEX_HOOK_EVENT_STATE_KEYS[eventName];
+    if (!eventKey) continue;
+    groups.forEach((group, groupIndex) => {
+      group.hooks.forEach((handler, handlerIndex) => {
+        if (handler.type !== "command") return;
+        entries.push({
+          key: `${sourcePath}:${eventKey}:${groupIndex}:${handlerIndex}`,
+          trustedHash: codexCommandHookHash(eventKey, group.matcher, group, handler),
+        });
+      });
+    });
+  }
+  return entries;
+}
+
+function writeCodexHookTrustState(codexHome: string, hooks: ProvisioningHookSet): void {
+  const entries = codexHookTrustEntries(codexHome, hooks);
+  if (!entries.length) return;
+  const configPath = join(codexHome, "config.toml");
+  let config = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+  for (const entry of entries) {
+    config = upsertCodexHookTrustEntry(config, entry);
+  }
+  writeFileSync(configPath, config, { mode: 0o600 });
+}
+
+function upsertCodexHookTrustEntry(config: string, entry: CodexHookTrustEntry): string {
+  const header = `[hooks.state.${tomlQuotedString(entry.key)}]`;
+  const lines = config.length ? config.split(/\n/) : [];
+  const headerIndex = lines.findIndex((line) => line.trim() === header);
+  if (headerIndex < 0) {
+    const prefix = config.endsWith("\n") || config.length === 0 ? config : `${config}\n`;
+    return `${prefix}\n${header}\ntrusted_hash = ${tomlQuotedString(entry.trustedHash)}\n`;
+  }
+
+  let nextHeaderIndex = lines.length;
+  for (let i = headerIndex + 1; i < lines.length; i += 1) {
+    if (/^\s*\[.*\]\s*$/.test(lines[i] ?? "")) {
+      nextHeaderIndex = i;
+      break;
+    }
+  }
+
+  const trustedHashLine = `trusted_hash = ${tomlQuotedString(entry.trustedHash)}`;
+  const existingIndex = lines
+    .slice(headerIndex + 1, nextHeaderIndex)
+    .findIndex((line) => /^\s*trusted_hash\s*=/.test(line));
+  if (existingIndex >= 0) {
+    lines[headerIndex + 1 + existingIndex] = trustedHashLine;
+  } else {
+    lines.splice(nextHeaderIndex, 0, trustedHashLine);
+  }
+  return lines.join("\n");
+}
+
+function codexCommandHookHash(
+  eventKey: string,
+  matcher: string | undefined,
+  group: ProvisioningHookSet[string][number],
+  handler: ProvisioningHookSet[string][number]["hooks"][number],
+): string {
+  // Mirrors Codex's command_hook_hash: hash the normalized hook identity, not the source file.
+  const normalizedHandler: Record<string, unknown> = {
+    type: "command",
+    command: handler.command,
+    async: false,
+    timeout: Math.max(1, handler.timeout ?? 600),
+  };
+  if (handler.statusMessage !== undefined) normalizedHandler.statusMessage = handler.statusMessage;
+
+  const identity: Record<string, unknown> = {
+    event_name: eventKey,
+    hooks: [normalizedHandler],
+  };
+  if (matcher !== undefined) identity.matcher = matcher;
+
+  const canonical = canonicalJson(identity);
+  const hash = createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return `sha256:${hash}`;
+}
+
+function canonicalJson(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, val]) => [key, canonicalJson(val)]),
+    );
+  }
+  return value;
+}
+
+function tomlQuotedString(value: string): string {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 }
 
 // #1096 — write relay-owned settings into an ISOLATED Claude managed home's `settings.json`

package/src/runner-core.ts

@@ -1598,7 +1598,7 @@ export class AgentRunner {
       });
       this.sessionOutbox.enqueue({
         kind: "session-message-batch",
-        idempotencyKey: `session-batch:${this.agentId}:${++this.sessionBatchSeq}:${messages.length}`,
+        idempotencyKey: `session-batch:${this.agentId}:${this.options.instanceId}:${this.options.startedAt}:${++this.sessionBatchSeq}:${messages.length}`,
         payload: { messages },
       });
     }