@zhivex-ai/harness 1.2.0 → 1.3.0-rc.3

package/dist/index-77h9qr5h.js

@@ -0,0 +1,326 @@
+// src/client/acp.ts
+import { randomUUID } from "node:crypto";
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+var envelope = z.object({ jsonrpc: z.literal("2.0"), id: z.union([z.string(), z.number().int()]).optional(), method: z.string(), params: z.unknown().optional() }).strict();
+var sessionParams = z.object({ sessionId: z.string().min(1) }).strict();
+var permissionResult = z.object({ outcome: z.union([
+  z.object({ outcome: z.literal("cancelled") }).strict(),
+  z.object({ outcome: z.literal("selected"), optionId: z.enum(["allow_once", "reject_once"]) }).strict()
+]) });
+
+class AcpFault extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+var createAcpConnection = (adapter, options) => {
+  if (!isAbsolute(options.workspace))
+    throw new Error("ACP workspace must be absolute");
+  const negotiated = adapter.negotiate([1]);
+  if (!negotiated.ok)
+    throw new Error(negotiated.error.code);
+  let initialized = false;
+  const sessions = new Set;
+  let active;
+  const command = async (value) => {
+    const response = await adapter.dispatch({
+      protocolVersion: 1,
+      requestId: randomUUID(),
+      connectionId: negotiated.connectionId,
+      command: { ...value, projectId: negotiated.projectId }
+    });
+    if (!response.ok)
+      throw new AcpFault(-32000, response.error.code);
+    return response.data;
+  };
+  const requireSession = (id) => {
+    if (!sessions.has(id))
+      throw new AcpFault(-32602, "Unknown session");
+  };
+  const execute = async (method, params) => {
+    if (method === "initialize") {
+      const input2 = z.object({ protocolVersion: z.literal(1), clientCapabilities: z.record(z.string(), z.unknown()).optional(), clientInfo: z.unknown().optional(), _meta: z.unknown().optional() }).parse(params);
+      initialized = true;
+      return {
+        protocolVersion: 1,
+        agentCapabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: false }, mcpCapabilities: { http: false, sse: false } },
+        authMethods: [],
+        agentInfo: { name: "zhivex-harness", title: "Zhivex Harness (text-session subset)", version: "1" },
+        _meta: { zhivex: { subset: true, fixedWorkspace: true, clientMcp: false } }
+      };
+    }
+    if (!initialized)
+      throw new AcpFault(-32002, "Initialize first");
+    if (method === "session/new") {
+      if (sessions.size >= 256)
+        throw new AcpFault(-32000, "Session capacity exceeded");
+      if (active)
+        throw new AcpFault(-32000, "BUSY");
+      const input2 = z.object({ cwd: z.string(), mcpServers: z.array(z.unknown()).max(0) }).strict().parse(params);
+      if (!isAbsolute(input2.cwd) || resolve(input2.cwd) !== resolve(options.workspace))
+        throw new AcpFault(-32602, "Workspace is host-owned");
+      const data = await command({ method: "session.create", idempotencyKey: randomUUID() });
+      if (data.kind !== "session")
+        throw new AcpFault(-32603, "Invalid adapter response");
+      sessions.add(data.session.sessionId);
+      return { sessionId: data.session.sessionId };
+    }
+    if (method === "session/cancel") {
+      const input2 = sessionParams.parse(params);
+      requireSession(input2.sessionId);
+      if (active?.sessionId === input2.sessionId) {
+        active.cancelled = true;
+        active.cancel();
+        await adapter.cancelActive();
+      }
+      return {};
+    }
+    if (method !== "session/prompt")
+      throw new AcpFault(-32601, "Method not supported");
+    const input = sessionParams.extend({ prompt: z.array(z.object({ type: z.literal("text"), text: z.string().max(64 * 1024) }).strict()).min(1).max(64) }).parse(params);
+    requireSession(input.sessionId);
+    const prompt = input.prompt.map((block) => block.text).join(`
+`);
+    if (!prompt.trim() || prompt.length > 64 * 1024)
+      throw new AcpFault(-32602, "Invalid prompt size");
+    if (active)
+      throw new AcpFault(-32000, "BUSY");
+    const permissionController = new AbortController;
+    let cancel;
+    const current = { sessionId: input.sessionId, cancelled: false, cancellation: new Promise((resolve2) => {
+      cancel = resolve2;
+    }), cancel: () => {
+      permissionController.abort();
+      cancel();
+    } };
+    active = current;
+    try {
+      const session = await command({ method: "session.get", sessionId: input.sessionId });
+      if (session.kind !== "session")
+        throw new AcpFault(-32603, "Invalid adapter response");
+      if (current.cancelled)
+        return { stopReason: "cancelled" };
+      let data = await command({
+        method: "run.start",
+        sessionId: input.sessionId,
+        expectedRevision: session.session.revision,
+        prompt,
+        idempotencyKey: randomUUID()
+      });
+      while (data.kind === "run" && data.run.status === "waiting_approval" && !current.cancelled) {
+        const decisions = [];
+        for (const approval of data.run.approvals) {
+          const answer = await Promise.race([
+            options.requestPermission({
+              sessionId: input.sessionId,
+              toolCall: { toolCallId: approval.approvalId, title: "Review pending action", kind: "other", status: "pending", rawInput: approval.action },
+              options: [{ optionId: "allow_once", name: "Allow once", kind: "allow_once" }, { optionId: "reject_once", name: "Reject once", kind: "reject_once" }]
+            }, permissionController.signal),
+            current.cancellation.then(() => ({ outcome: { outcome: "cancelled" } }))
+          ]);
+          const result = permissionResult.parse(answer);
+          if (result.outcome.outcome === "cancelled" || current.cancelled) {
+            current.cancelled = true;
+            break;
+          }
+          decisions.push({ approvalId: approval.approvalId, digest: approval.digest, approve: result.outcome.optionId === "allow_once" });
+        }
+        if (current.cancelled)
+          break;
+        if (!decisions.length)
+          throw new AcpFault(-32603, "Missing pending approval");
+        data = await command({
+          method: "approval.resolve",
+          sessionId: input.sessionId,
+          runId: data.run.runId,
+          expectedRevision: data.run.revision,
+          decisions,
+          idempotencyKey: randomUUID()
+        });
+      }
+      if (data.kind !== "run")
+        throw new AcpFault(-32603, "Invalid adapter response");
+      if (current.cancelled && !["completed", "failed", "cancelled", "timed_out"].includes(data.run.status)) {
+        await command({
+          method: "run.cancel",
+          sessionId: input.sessionId,
+          runId: data.run.runId,
+          expectedRevision: data.run.revision,
+          idempotencyKey: randomUUID()
+        });
+      }
+      if (data.run.output)
+        await options.notify({ jsonrpc: "2.0", method: "session/update", params: {
+          sessionId: input.sessionId,
+          update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: data.run.output } }
+        } });
+      return { stopReason: current.cancelled || data.run.status === "cancelled" ? "cancelled" : data.run.status === "completed" ? "end_turn" : "refusal" };
+    } catch (error) {
+      if (current.cancelled)
+        return { stopReason: "cancelled" };
+      throw error;
+    } finally {
+      permissionController.abort();
+      active = undefined;
+    }
+  };
+  return {
+    async cancelActive() {
+      if (active) {
+        active.cancelled = true;
+        active.cancel();
+      }
+      await adapter.cancelActive();
+    },
+    async handle(value) {
+      const parsed = envelope.safeParse(value);
+      if (!parsed.success)
+        return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid request" } };
+      const request = parsed.data;
+      if (request.id === undefined && request.method !== "session/cancel")
+        return;
+      try {
+        const result = await execute(request.method, request.params);
+        return request.id === undefined ? undefined : { jsonrpc: "2.0", id: request.id, result };
+      } catch (error) {
+        if (request.id === undefined)
+          return;
+        return { jsonrpc: "2.0", id: request.id, error: {
+          code: error instanceof AcpFault ? error.code : error instanceof z.ZodError ? -32602 : -32603,
+          message: error instanceof AcpFault ? error.message : error instanceof z.ZodError ? "Invalid params" : "Internal error"
+        } };
+      }
+    }
+  };
+};
+
+// src/client/acp-stdio.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var serveAcpStdio = async (adapter, options) => {
+  const timeoutMs = options.permissionTimeoutMs ?? 15 * 60000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 15 * 60000)
+    throw new Error("Invalid ACP permission timeout");
+  const pending = new Map;
+  const jobs = new Set;
+  const inflight = new Set;
+  const write = (value) => new Promise((resolve2, reject) => {
+    options.output.write(JSON.stringify(value) + `
+`, (error) => error ? reject(error) : resolve2());
+  });
+  let transportFailure;
+  const connection = createAcpConnection(adapter, {
+    workspace: options.workspace,
+    notify: write,
+    requestPermission: async (params, signal) => {
+      const id = `permission_${randomUUID2()}`;
+      const cancel = () => {
+        const request = pending.get(id);
+        if (request) {
+          clearTimeout(request.timer);
+          pending.delete(id);
+          request.resolve({ outcome: { outcome: "cancelled" } });
+        }
+      };
+      const response = new Promise((resolve2) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          resolve2({ outcome: { outcome: "cancelled" } });
+        }, timeoutMs);
+        timer.unref();
+        pending.set(id, { resolve: resolve2, timer });
+      });
+      signal?.addEventListener("abort", cancel, { once: true });
+      if (signal?.aborted)
+        cancel();
+      try {
+        if (!signal?.aborted)
+          await write({ jsonrpc: "2.0", id, method: "session/request_permission", params });
+        return await response;
+      } finally {
+        signal?.removeEventListener("abort", cancel);
+        const request = pending.get(id);
+        if (request)
+          clearTimeout(request.timer);
+        pending.delete(id);
+      }
+    }
+  });
+  const dispatch = async (line) => {
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      await write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+      return;
+    }
+    if (value?.jsonrpc === "2.0" && typeof value.id === "string" && value.method === undefined) {
+      const request = pending.get(value.id);
+      if (request) {
+        clearTimeout(request.timer);
+        pending.delete(value.id);
+        request.resolve("result" in value && !("error" in value) ? value.result : { outcome: { outcome: "cancelled" } });
+      }
+      return;
+    }
+    const key = value?.id === undefined ? undefined : JSON.stringify(value.id);
+    if (key && inflight.has(key)) {
+      await write({ jsonrpc: "2.0", id: value.id, error: { code: -32600, message: "Request ID already active" } });
+      return;
+    }
+    if (key)
+      inflight.add(key);
+    try {
+      const response = await connection.handle(value);
+      if (response !== undefined)
+        await write(response);
+    } finally {
+      if (key)
+        inflight.delete(key);
+    }
+  };
+  const launch = (line) => {
+    if (!line.trim())
+      return;
+    if (jobs.size >= 64)
+      throw new Error("ACP request capacity exceeded");
+    const job = dispatch(line).catch((error) => {
+      transportFailure = error;
+      options.input.destroy();
+    });
+    jobs.add(job);
+    job.finally(() => jobs.delete(job));
+  };
+  let buffer = Buffer.alloc(0);
+  try {
+    for await (const chunk of options.input) {
+      buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+      let newline;
+      while ((newline = buffer.indexOf(10)) !== -1) {
+        if (newline > 1024 * 1024)
+          throw new Error("ACP frame exceeds 1 MiB");
+        const line = buffer.subarray(0, newline).toString("utf8");
+        buffer = buffer.subarray(newline + 1);
+        launch(line);
+      }
+      if (buffer.length > 1024 * 1024)
+        throw new Error("ACP frame exceeds 1 MiB");
+    }
+    if (buffer.length)
+      launch(buffer.toString("utf8"));
+  } finally {
+    for (const request of pending.values()) {
+      clearTimeout(request.timer);
+      request.resolve({ outcome: { outcome: "cancelled" } });
+    }
+    pending.clear();
+    await connection.cancelActive();
+    await Promise.allSettled(jobs);
+  }
+  if (transportFailure)
+    throw transportFailure;
+};
+
+export { createAcpConnection, serveAcpStdio };