@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.161

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

@@ -0,0 +1,145 @@
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/shared-events.ts
+var exports_shared_events = {};
+__export(exports_shared_events, {
+  SharedEvents: () => exports_shared_events,
+  make: () => make7
+});
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop(connection) {
+    connection.connected = undefined;
+    connection.controller.abort();
+    if (current === connection)
+      current = undefined;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error) {
+      completion = { error };
+    } finally {
+      stop(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error) {
+        if (!("error" in completion))
+          completion = { error };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: undefined });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController,
+              subscribers: new Set
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: undefined });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+
+export { make7, exports_shared_events };

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

@@ -0,0 +1,50 @@
+// src/solid/pty.ts
+function createPtyClient2(api, options) {
+  return {
+    async connect(input) {
+      const result = await api.pty.connect.token({
+        ptyID: input.ptyID,
+        location: input.location,
+        "x-opencode-ticket": "1"
+      });
+      const baseUrl = new URL(options.url);
+      if (!baseUrl.pathname.endsWith("/"))
+        baseUrl.pathname += "/";
+      const url = new URL(`api/pty/${encodeURIComponent(input.ptyID)}/connect`, baseUrl);
+      if (input.location?.directory)
+        url.searchParams.set("location[directory]", input.location.directory);
+      if (input.cursor !== undefined)
+        url.searchParams.set("cursor", String(input.cursor));
+      url.searchParams.set("ticket", result.data.ticket);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const socket = options.openSocket?.(url) ?? new WebSocket(url);
+      socket.binaryType = "arraybuffer";
+      return socket;
+    }
+  };
+}
+function createPersistentPtyClient2(api, options) {
+  return {
+    async connect(input) {
+      const token = await api.experimental.persistentPty.connectToken({
+        ptyID: input.ptyID,
+        "x-opencode-ticket": "1"
+      });
+      const baseUrl = new URL(options.url);
+      if (!baseUrl.pathname.endsWith("/"))
+        baseUrl.pathname += "/";
+      const url = new URL(`api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect`, baseUrl);
+      url.searchParams.set("ticket", token.ticket);
+      url.searchParams.set("cursor", String(input.cursor));
+      url.searchParams.set("attachment_id", input.attachmentID);
+      url.searchParams.set("takeover", String(input.takeover ?? false));
+      url.searchParams.set("input_protocol", "1");
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      const socket = options.openSocket?.(url) ?? new WebSocket(url);
+      socket.binaryType = "arraybuffer";
+      return socket;
+    }
+  };
+}
+
+export { createPtyClient2, createPersistentPtyClient2 };

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

@@ -0,0 +1,105 @@
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/pty-handoff.ts
+var exports_pty_handoff = {};
+__export(exports_pty_handoff, {
+  PtyHandoff: () => exports_pty_handoff,
+  clear: () => clear2,
+  complete: () => complete2,
+  environment: () => environment2,
+  prepare: () => prepare2
+});
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+async function prepare2(file, info, timeout) {
+  const existing = await read(file);
+  if (existing !== undefined && existing.expiresAt > Date.now() && same(existing.source, info))
+    return;
+  const { OpenCode } = await import("../promise/index.js");
+  const client = OpenCode.make({
+    baseUrl: info.url,
+    headers: info.password === undefined ? undefined : { authorization: "Basic " + Buffer.from(`opencode:${info.password}`).toString("base64") }
+  });
+  const handoff = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then(parse).catch(async (cause) => {
+    const concurrent = await read(file);
+    if (concurrent !== undefined && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement", cause);
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch(() => {});
+    return null;
+  });
+  if (handoff === undefined)
+    return;
+  await publish(file, info, handoff).catch((cause) => console.warn("Failed to publish persistent terminal handoff", cause));
+}
+function parse(body) {
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null)
+    return null;
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  return body.handoff;
+}
+async function publish(file, info, handoff) {
+  const temporary = `${file}.pty-handoff.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({
+    source: { id: info.id, pid: info.pid, url: info.url },
+    handoff,
+    expiresAt: handoff?.expiresAt ?? Date.now() + 30000
+  }), { mode: 384, flag: "wx" });
+  await rename(temporary, file + ".pty-handoff").finally(() => rm(temporary, { force: true }));
+}
+async function environment2(file, env) {
+  const record = await read(file);
+  const current = await readFile(file, "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const handoff = record !== undefined && record.expiresAt > Date.now() && (current === undefined || same(record.source, current)) ? record.handoff : undefined;
+  return { ...env, OPENCODE_PTY_HANDOFF: handoff == null ? undefined : JSON.stringify(handoff) };
+}
+async function complete2(file, info) {
+  const record = await read(file);
+  if (record !== undefined && !same(record.source, info))
+    await clear2(file);
+}
+async function clear2(file) {
+  await rm(file + ".pty-handoff", { force: true });
+}
+async function read(file) {
+  const value = await readFile(file + ".pty-handoff", "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  if (typeof value !== "object" || value === null || !("source" in value) || !("handoff" in value))
+    return;
+  if (typeof value.source !== "object" || value.source === null)
+    return;
+  if (!("pid" in value.source) || typeof value.source.pid !== "number")
+    return;
+  if (!("url" in value.source) || typeof value.source.url !== "string")
+    return;
+  if ("id" in value.source && typeof value.source.id !== "string")
+    return;
+  if (value.handoff !== null && !isHandoff(value.handoff))
+    return;
+  if (!("expiresAt" in value) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt))
+    return;
+  return {
+    source: {
+      id: "id" in value.source && typeof value.source.id === "string" ? value.source.id : undefined,
+      pid: value.source.pid,
+      url: value.source.url
+    },
+    handoff: value.handoff,
+    expiresAt: value.expiresAt
+  };
+}
+function same(left, right) {
+  return left.id === right.id && left.pid === right.pid && left.url === right.url;
+}
+function isHandoff(value) {
+  return typeof value === "object" && value !== null && "directory" in value && typeof value.directory === "string" && "instanceID" in value && typeof value.instanceID === "string" && "ticket" in value && typeof value.ticket === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt);
+}
+
+export { prepare2, environment2, complete2, clear2, exports_pty_handoff };

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

@@ -0,0 +1,12 @@
+// src/promise/generated/client-error.ts
+class ClientError3 extends Error {
+  reason;
+  name = "ClientError";
+  constructor(reason, options) {
+    const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : undefined);
+    super(detail ? `${reason}: ${detail}` : reason, options);
+    this.reason = reason;
+  }
+}
+
+export { ClientError3 };