@opencode/client 2.0.8 → 2.0.9

package/dist/chunks/pty-handoff-frbwqjmf.js

@@ -0,0 +1,145 @@
+import {
+  __export
+} from "./pty-handoff-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/chunks/pty-handoff-n3c99vt5.js

@@ -0,0 +1,11 @@
+// src/promise/generated/client-error.ts
+class ClientError3 extends Error {
+  reason;
+  name = "ClientError";
+  constructor(reason, options) {
+    super(reason, options);
+    this.reason = reason;
+  }
+}
+
+export { ClientError3 };

package/dist/chunks/pty-handoff-nqd0dnpk.js

@@ -0,0 +1,112 @@
+import {
+  __export
+} from "./pty-handoff-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 { ClientError, 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 missing = (error) => error instanceof ClientError && error.reason === "UnexpectedStatus" && typeof error.cause === "object" && error.cause !== null && ("status" in error.cause) && error.cause.status === 404;
+  const result = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then((value) => ({ value }), (cause) => ({ cause }));
+  if ("cause" in result) {
+    const concurrent = await read(file);
+    if (concurrent !== undefined && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    if (!missing(result.cause))
+      throw new Error("Failed to prepare persistent terminals for service replacement", { cause: result.cause });
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement");
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch((cause) => {
+      if (missing(cause))
+        return;
+      throw new Error("Failed to shut down persistent terminals before service replacement", { cause });
+    });
+    await publish(file, info, null);
+    return;
+  }
+  const body = result.value;
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null) {
+    await publish(file, info, null);
+    return;
+  }
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  await publish(file, info, 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 };