@deksden-com/dd-flow-cli 0.9.0-beta.133 → 0.9.0-beta.135

package/dist/harness-runtime/lib/native-hook-command.mjs

@@ -117,7 +117,7 @@ export async function terminateCommandTree(child, { platform = process.platform,
 }
 
 /** Preserve the native hook protocol across the CLI process boundary. */
-export async function runBoundedCommand({ bin, args, input = null, cwd, env = {}, timeoutMs = 15_000, timeoutCode = "native_hook_timeout", inheritDeadline = true, cleanupWithinBudget = false, maintenanceProgress = null, signal }) {
+export async function runBoundedCommand({ bin, args, nodeBin = process.execPath, input = null, cwd, env = {}, timeoutMs = 15_000, timeoutCode = "native_hook_timeout", inheritDeadline = true, cleanupWithinBudget = false, maintenanceProgress = null, signal }) {
   if (signal?.aborted) throw Object.assign(new Error("Bounded CLI request cancelled before launch"), { code: "process_maintenance_cancelled", details: { effect: "no_effect" } });
   const inherited = inheritDeadline ? env.DD_FLOW_HOOK_DEADLINE_AT ?? process.env.DD_FLOW_HOOK_DEADLINE_AT : undefined;
   if (inherited !== undefined) {
@@ -137,7 +137,7 @@ export async function runBoundedCommand({ bin, args, input = null, cwd, env = {}
   const deadlineAt = Math.floor(Date.now() + Math.max(0, commandMs - Math.min(250, commandMs / 10)));
   const script = /\.[cm]?js$/.test(bin);
   const output = await new Promise((resolve, reject) => {
-    const child = spawn(script ? process.execPath : bin, [...(script ? [bin] : []), ...args], {
+    const child = spawn(script ? nodeBin : bin, [...(script ? [bin] : []), ...args], {
       cwd, env: { ...process.env, ...env, DD_FLOW_HOOK_DEADLINE_AT: String(deadlineAt) }, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "", stderr = "", failure, cleanupTimer, settled = false, termination;
@@ -241,8 +241,8 @@ function hookDiagnostics(stderr) {
   }).slice(-16);
 }
 
-export async function invokeNativeHook({ bin, args, payload, home, cwd, env, timeoutMs = 15_000 }) {
-  const output = await runBoundedCommand({ bin, args, input: `${JSON.stringify(payload)}\n`, cwd, env: { ...env, DD_FLOW_HOME: home }, timeoutMs });
+export async function invokeNativeHook({ bin, args, nodeBin, payload, home, cwd, env, timeoutMs = 15_000 }) {
+  const output = await runBoundedCommand({ bin, args, nodeBin, input: `${JSON.stringify(payload)}\n`, cwd, env: { ...env, DD_FLOW_HOME: home }, timeoutMs });
   let result;
   try { result = JSON.parse(output); } catch { throw Object.assign(new Error("Invalid native hook JSON response"), { code: "native_hook_response_invalid" }); }
   if (result?.ok === false && typeof result.error?.code === "string") throw Object.assign(new Error(result.error.message ?? "Native hook failed"), { code: result.error.code, details: result.error.details });

package/dist/harness-runtime/lib/opencode-plugin.mjs

@@ -0,0 +1,60 @@
+import path from "node:path";
+import * as Plugin from "../vendor/opencode-plugin.mjs";
+import { hookBudget, invokeNativeHook } from "./native-hook-command.mjs";
+
+/** Launch-bound server plugin; never uses a process-global 'last Session'. */
+export function makeOpenCodePlugin(binding, invoke = invokeNativeHook) {
+  return Plugin.define({ id: binding.ddFlowBin ? "dd-flow" : "dd-flow-security", async setup(ctx) {
+    const participating = new Map();
+    const key = event => JSON.stringify([binding.daemonId, event.sessionID, event.messageID, event.id]);
+    const envelope = async (phase, event, budget, outcome) => {
+      const info = await budget.run(() => ctx.session.get({ sessionID: event.sessionID }), "identity");
+      if (!info?.id || info.id !== event.sessionID || !info.location?.directory) throw new Error("OpenCode Session identity is unavailable");
+      const input = event.input;
+      if (!input || typeof input !== "object" || typeof input.command !== "string") throw new Error("OpenCode shell input is unavailable");
+      const cwd = path.resolve(info.location.directory, input.workdir ?? ".");
+      return { schema_id: "dd-flow/opencode-tool-event@1", native_protocol: 2,
+        event_id: [binding.daemonId, event.sessionID, event.messageID, event.id].join(":"), phase,
+        daemon_id: binding.daemonId, server_version: binding.version, plugin_sha256: process.env.DD_OPENCODE_PLUGIN_SHA256,
+        session: { provider_session_id: info.id, parent_provider_session_id: info.parentID ?? null,
+          agent_id: event.agent, directory: cwd, project_id: info.projectID },
+        message_id: event.messageID, tool_call_id: event.id, tool: "shell", native_tool: event.tool,
+        profile: { provider: info.model?.providerID, model: info.model?.id, variant: info.model?.variant ?? "default", agent: event.agent },
+        input: { ...input, workdir: cwd }, ...(outcome ? { outcome } : {}) };
+    };
+    const deliver = (payload, budget) => invoke({ bin: binding.ddFlowBin, nodeBin: binding.nodeBin,
+      args: ["opencode", "event", "handle", "--project-root", binding.projectRoot, "--json"],
+      payload, home: binding.ddFlowHome, timeoutMs: budget.remaining("admission", 15000) });
+    await ctx.shell.hook("create.before", event => {
+      delete event.env.OPENCODE_PASSWORD; delete event.env.OPENCODE_SERVER_PASSWORD;
+    });
+    await ctx.tool.hook("execute.before", async event => {
+      if (event.tool !== "shell" || !binding.ddFlowBin) return;
+      const budget = hookBudget(), payload = await envelope("before", event, budget);
+      event.input = { ...event.input, workdir: payload.session.directory };
+      const result = await deliver({ ...payload, input: event.input }, budget);
+      if (result?.permissionDecision === "deny" || result?.hookSpecificOutput?.permissionDecision === "deny") throw new Error("dd-flow denied native shell admission");
+      if (result?.observed) {
+        participating.set(key(event), payload);
+        await ctx.storage.set(key(event), JSON.parse(JSON.stringify(payload)));
+        // The common observer, not OpenCode's fixed 120-second cutoff, owns
+        // flow CLI inactivity. No lifecycle process is detached here.
+        event.input = { ...event.input, ...(result.hookSpecificOutput?.updatedInput ?? {}), timeout: 0, background: false };
+      } else if (event.input.timeout === undefined) event.input.timeout = 0;
+    });
+    await ctx.tool.hook("execute.after", async event => {
+      if (event.tool !== "shell") return;
+      const budget = hookBudget(), original = participating.get(key(event)) ?? await ctx.storage.get(key(event));
+      if (!original) return; // Ordinary shell tools do not create lifecycle receipts.
+      const output = event.result?.output;
+      const success = event.status === "completed" && output?.status !== "running" && output?.exit === 0 && !output?.timeout && !output?.signal;
+      const outcome = { status: success ? "completed" : output?.status === "running" ? "running" : "failed",
+        exit_code: output?.exit ?? null, signal: output?.signal ?? null, shell_id: output?.shellID ?? null };
+      const payload = await envelope("after", event, budget, outcome);
+      await deliver({ ...payload, ...(original ? { event_id: original.event_id } : {}) }, budget);
+      participating.delete(key(event));
+      await ctx.storage.remove(key(event));
+    });
+    return () => participating.clear();
+  } });
+}

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-1y4a697q.js

@@ -0,0 +1,81 @@
+import {
+  isRpcError2,
+  isRpcInternalError2
+} from "./service-probe-vt9jbch8.js";
+
+// src/promise/rpc.ts
+function makeRpc2(raw, events) {
+  return (definition) => {
+    const subscribe = (name, options) => {
+      if (!Object.hasOwn(definition.events, name))
+        throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+      const type = eventType(definition, name);
+      return {
+        [Symbol.asyncIterator]() {
+          const controller = new AbortController;
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = async function* () {
+            try {
+              for await (const published of events.subscribe({ signal })) {
+                if (signal.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal.aborted)
+                throw error;
+            } finally {
+              controller.abort();
+            }
+          }();
+          return {
+            next: () => iterator.next(),
+            return: () => {
+              controller.abort();
+              return iterator.return();
+            }
+          };
+        }
+      };
+    };
+    return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+      name,
+      async (input, options) => {
+        try {
+          const result = await raw.rpc.call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, { signal: options?.signal, headers: options?.headers });
+          return result.output;
+        } catch (error) {
+          if (!isRpcError2(error) && !isRpcInternalError2(error))
+            throw error;
+          throw error.data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data };
+        }
+      }
+    ])), {
+      events: {
+        subscribe,
+        on: (name, handler, options) => {
+          const controller = new AbortController;
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal });
+          (async () => {
+            for await (const event of source)
+              await handler(event);
+          })().catch((error) => console.error(error));
+          return () => controller.abort();
+        }
+      }
+    });
+  };
+}
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+export { makeRpc2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-2ny4vxct.js

@@ -0,0 +1,92 @@
+import {
+  defaultEnsureTiming2
+} from "./service-probe-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "./service-probe-sxt88q69.js";
+
+// src/service-probe.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function decide2(service, options) {
+  if (!matchesVersion2(service.version, options))
+    return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
+  if (!service.compatible)
+    return fail("Background service uses an incompatible health protocol. Update this client or explicitly restart the service.");
+  if (service.state === "ready")
+    return { _tag: "reuse" };
+  if (service.state === "failed")
+    return fail("Background service failed to start");
+  return { _tag: "wait" };
+}
+function fail(message) {
+  return { _tag: "fail", error: new Error(message) };
+}
+function fallback2() {
+  return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
+}
+function same2(left, right) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+async function probeResult2(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers2(endpoint), signal }).then(async (response) => ({
+    response,
+    body: response.status === 404 ? undefined : await response.json()
+  })).catch(() => {
+    return;
+  });
+  if (result === undefined)
+    return { service: undefined, timedOut: signal.aborted };
+  const response = result.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.body);
+  if (serverInfo === undefined)
+    return { service: undefined, timedOut: false };
+  if (serverInfo.pid !== info.pid)
+    return { service: undefined, timedOut: false };
+  if (info.version !== undefined && serverInfo.version !== info.version)
+    return { service: undefined, timedOut: false };
+  return {
+    service: {
+      info,
+      endpoint,
+      version: serverInfo.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      compatible: true
+    },
+    timedOut: false
+  };
+}
+function headers2(endpoint) {
+  if (endpoint.auth === undefined)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+function decodeInfo(input) {
+  if (typeof input !== "object" || input === null)
+    return;
+  if (!("version" in input) || typeof input.version !== "string")
+    return;
+  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+    return;
+  return { version: input.version, pid: input.pid };
+}
+
+export { decide2, fallback2, same2, probeResult2, headers2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-7x67cf1q.js

@@ -0,0 +1,52 @@
+import {
+  make7
+} from "./service-probe-frbwqjmf.js";
+import {
+  ClientError2
+} from "./service-probe-y2etg5bs.js";
+import {
+  make3
+} from "./service-probe-q4g3afnw.js";
+import {
+  make4,
+  aborted2
+} from "./service-probe-z6qdwcsf.js";
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/effect/client.ts
+var exports_client = {};
+__export(exports_client, {
+  OpenCode: () => exports_client,
+  make: () => make2
+});
+import { Cause, Context, Effect, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+var CurrentHeaders = Context.Reference("@opencode/client/effect/rpc/headers", {
+  defaultValue: () => {
+    return;
+  }
+});
+var make2 = Effect.fn("OpenCode.make")(function* (options) {
+  const httpClient = yield* HttpClient.HttpClient;
+  const raw = yield* make3(options).pipe(Effect.provideService(HttpClient.HttpClient, HttpClient.mapRequestEffect(httpClient, (request) => Effect.map(CurrentHeaders, (headers) => headers ? HttpClientRequest.setHeaders(request, new Headers(headers)) : request))));
+  const context = yield* Effect.context();
+  const native = raw.event.subscribe();
+
+  class EventFailure {
+    cause;
+    constructor(cause) {
+      this.cause = cause;
+    }
+  }
+  const shared = make7((signal) => Stream.toAsyncIterableWith(native.pipe(Stream.interruptWhen(aborted2(signal)), Stream.catchCause((cause) => Stream.fail(new EventFailure(cause)))), context));
+  const subscribe = () => Stream.fromAsyncIterable(shared.subscribe(), (error) => error).pipe(Stream.catch((error) => Stream.failCause(error instanceof EventFailure ? error.cause : Cause.fail(new ClientError2({ cause: error })))));
+  return {
+    ...raw,
+    event: { ...raw.event, subscribe },
+    rpc: Object.assign(make4((input, options) => raw.rpc.call(input).pipe(Effect.provideService(CurrentHeaders, options?.headers)), subscribe), raw.rpc)
+  };
+});
+
+export { make2, exports_client };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };