@opencode/client 0.0.0-dev-19794 → 0.0.0-dev-19808

package/dist/chunks/rpc-runtime-sxt88q69.js

@@ -0,0 +1,12 @@
+// src/service-version.ts
+function matchesVersion2(version, options) {
+  if (options.version === undefined)
+    return true;
+  if (version === undefined)
+    return false;
+  if (typeof options.version === "function")
+    return options.version(version);
+  return version === options.version;
+}
+
+export { matchesVersion2 };

package/dist/chunks/rpc-runtime-t1xa31vm.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./rpc-runtime-9rqn6x4v.js";
+
+// src/rpc-runtime.ts
+var exports_rpc_runtime = {};
+__export(exports_rpc_runtime, {
+  RpcRuntime: () => exports_rpc_runtime,
+  event: () => event2,
+  eventType: () => eventType2,
+  read: () => read2,
+  readError: () => readError2
+});
+import { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import { Effect, Schema } from "effect";
+function read2(schema, value) {
+  return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+function readError2(method, error) {
+  if (!(error instanceof RpcError) && !(error instanceof RpcInternalError))
+    return Effect.fail(error);
+  if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+    return Effect.fail(error.data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data });
+  }
+  return read2(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data })));
+}
+var event2 = Effect.fn("Client.Rpc.event")(function* (definition, name, schema, event) {
+  const data = yield* read2(schema.schema, event.data);
+  return {
+    ...event,
+    type: eventType2(definition, name),
+    data
+  };
+});
+function eventType2(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+export { read2, readError2, event2, eventType2, exports_rpc_runtime };

package/dist/chunks/rpc-runtime-tr4b6894.js

@@ -0,0 +1,21 @@
+// src/service-timing.ts
+var timings = new WeakMap;
+var defaultEnsureTiming2 = {
+  pollInterval: 100,
+  attempts: 1200,
+  requestTimeout: 2000,
+  spawnDelay: 5000,
+  maxSpawnDelay: 30000,
+  promiseTimeout: 120000,
+  stopPollInterval: 50,
+  stopPollAttempts: 100
+};
+function ensureTiming2(options) {
+  return timings.get(options) ?? defaultEnsureTiming2;
+}
+function withEnsureTiming2(options, overrides) {
+  timings.set(options, { ...defaultEnsureTiming2, ...overrides });
+  return options;
+}
+
+export { defaultEnsureTiming2, ensureTiming2, withEnsureTiming2 };

package/dist/chunks/rpc-runtime-txckps9j.js

@@ -0,0 +1,57 @@
+// src/service-contender.ts
+import { spawn } from "node:child_process";
+var stderrLimit = 8 * 1024;
+function spawnServiceContender2(command, args, env) {
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  let error;
+  let closed = false;
+  let stderr = Buffer.alloc(0);
+  const onStderr = (chunk) => {
+    const tail = chunk.subarray(-stderrLimit);
+    stderr = tail.length === stderrLimit ? Buffer.from(tail) : Buffer.concat([stderr.subarray(-(stderrLimit - tail.length)), tail]);
+  };
+  child.stderr?.on("data", onStderr);
+  if (child.stderr !== null && "unref" in child.stderr && typeof child.stderr.unref === "function")
+    child.stderr.unref();
+  child.once("error", (cause) => {
+    error = new Error("Failed to start server", { cause });
+  });
+  child.once("close", () => {
+    closed = true;
+  });
+  child.unref();
+  return {
+    child,
+    error: () => error,
+    closed: () => closed,
+    stderr: () => stderr.toString("utf8").trim(),
+    release: () => {
+      child.stderr?.off("data", onStderr);
+      child.stderr?.resume();
+      stderr = Buffer.alloc(0);
+    }
+  };
+}
+function contenderFailure2(contender) {
+  const error = contender.error();
+  if (error !== undefined)
+    return error;
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return startupError(`Server process exited with code ${contender.child.exitCode}`, contender.stderr());
+  if (contender.child.signalCode !== null)
+    return startupError(`Server process terminated by ${contender.child.signalCode}`, contender.stderr());
+  return;
+}
+function contenderFinished2(contender) {
+  return contender.error() !== undefined || contender.closed();
+}
+function startupError(message, stderr) {
+  return new Error(stderr ? `${message}
+${stderr}` : message);
+}
+
+export { spawnServiceContender2, contenderFailure2, contenderFinished2 };

package/dist/chunks/rpc-runtime-vmytr4q8.js

@@ -0,0 +1,4 @@
+// src/contract.ts
+import { ClientApi as ClientApi2, effectOmitEndpoints as effectOmitEndpoints2, groupNames as groupNames2, promiseOmitEndpoints as promiseOmitEndpoints2 } from "@opencode/protocol/client";
+
+export { ClientApi2, effectOmitEndpoints2, groupNames2, promiseOmitEndpoints2 };

package/dist/chunks/rpc-runtime-y2etg5bs.js

@@ -0,0 +1,9 @@
+// src/effect/generated/client-error.ts
+import { Schema } from "effect";
+
+class ClientError2 extends Schema.TaggedError()("ClientError", {
+  cause: Schema.Defect()
+}) {
+}
+
+export { ClientError2 };

package/dist/chunks/rpc-runtime-ydhz1zrh.js

@@ -0,0 +1,238 @@
+// src/solid/connection.ts
+import { batch, onCleanup } from "solid-js";
+import { createStore } from "solid-js/store";
+var connectTimeout = 2000;
+var reconnectDelay = 1000;
+var connectionHistoryLimit = 50;
+var defaultIdleTimeout2 = 45000;
+var foregroundIdleThreshold2 = 20000;
+function createClientConnection2(initialApi, options) {
+  const abort = new AbortController;
+  const history = [];
+  const idleTimeout = options.idleTimeout ?? defaultIdleTimeout2;
+  const [connection, setConnection] = createStore({ status: "connecting", attempt: 0 });
+  let api = initialApi;
+  let pending = [];
+  let flushTimer;
+  let stream;
+  let current;
+  let run;
+  let started = false;
+  let generation = 0;
+  let lastActivity = 0;
+  let forced = false;
+  function record(status, attempt, error) {
+    history.push({ type: "client.connection", created: Date.now(), data: { status, attempt, error } });
+    if (history.length > connectionHistoryLimit)
+      history.shift();
+  }
+  function publish(event) {
+    pending.push(event);
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      const events = pending;
+      pending = [];
+      batch(() => events.forEach(options.onEvent));
+    }, options.flushInterval ?? 10);
+  }
+  async function connect(signal, attempt) {
+    let connectedAt;
+    const request = new AbortController;
+    current = request;
+    const cancel = () => request.abort(signal.reason);
+    const timeout = setTimeout(() => request.abort(new Error("Timed out connecting to server")), connectTimeout);
+    signal.addEventListener("abort", cancel, { once: true });
+    let watchdog;
+    const touch = () => {
+      lastActivity = Date.now();
+      if (connectedAt === undefined)
+        return;
+      clearTimeout(watchdog);
+      watchdog = setTimeout(() => request.abort(new Error("Event stream stalled")), idleTimeout);
+    };
+    try {
+      record(attempt === 0 ? "connecting" : "reconnecting", attempt);
+      options.log?.info?.("event stream connecting", { attempt });
+      const iterator = api.event.subscribe({ signal: request.signal, onActivity: touch })[Symbol.asyncIterator]();
+      const first = await iterator.next();
+      if (signal.aborted)
+        return { error: undefined, connectedAt };
+      if (first.done)
+        return {
+          error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+          connectedAt
+        };
+      if (first.value.type !== "server.connected")
+        return { error: new Error("Event stream did not start with server.connected"), connectedAt };
+      clearTimeout(timeout);
+      record("connected", attempt);
+      connectedAt = Date.now();
+      touch();
+      options.log?.info?.("event stream connected");
+      publish(first.value);
+      setConnection({ status: "connected", attempt: 0, error: undefined });
+      while (!signal.aborted) {
+        const event = await iterator.next();
+        if (signal.aborted)
+          return { error: undefined, connectedAt };
+        if (event.done)
+          return {
+            error: request.signal.reason instanceof Error ? request.signal.reason : new Error("Event stream disconnected"),
+            connectedAt
+          };
+        touch();
+        if ("durable" in event.value && event.value.durable)
+          options.log?.debug?.("event", {
+            type: event.value.type,
+            aggregateID: event.value.durable.aggregateID,
+            seq: event.value.durable.seq
+          });
+        publish(event.value);
+      }
+      return { error: undefined, connectedAt };
+    } catch (error) {
+      return { error, connectedAt };
+    } finally {
+      request.abort();
+      if (current === request)
+        current = undefined;
+      clearTimeout(timeout);
+      clearTimeout(watchdog);
+      signal.removeEventListener("abort", cancel);
+    }
+  }
+  async function runStream(active) {
+    let attempt = 0;
+    while (!abort.signal.aborted && started && generation === active) {
+      setConnection({ status: attempt === 0 ? "connecting" : "reconnecting", attempt });
+      const controller = new AbortController;
+      stream = controller;
+      const cancel = () => controller.abort(abort.signal.reason);
+      abort.signal.addEventListener("abort", cancel);
+      const result = await connect(controller.signal, attempt);
+      abort.signal.removeEventListener("abort", cancel);
+      if (abort.signal.aborted || !started || generation !== active)
+        return;
+      if (result.connectedAt !== undefined && Date.now() - result.connectedAt >= reconnectDelay)
+        attempt = 0;
+      attempt += 1;
+      const message = errorMessage(result.error);
+      record("disconnected", attempt, message);
+      options.log?.info?.("event stream disconnected", { attempt, error: message });
+      setConnection({ status: "reconnecting", attempt, error: message });
+      if (options.reconnect) {
+        const next = await options.reconnect(controller.signal).catch((error) => {
+          if (!controller.signal.aborted)
+            options.log?.info?.("server resolution failed", { attempt, error: errorMessage(error) });
+        });
+        if (abort.signal.aborted || controller.signal.aborted || !started || generation !== active)
+          return;
+        if (next) {
+          api = next;
+          if (attempt === 1)
+            continue;
+        }
+      }
+      if (forced) {
+        forced = false;
+        continue;
+      }
+      await wait(reconnectDelay, controller.signal);
+    }
+  }
+  function start() {
+    if (started)
+      return run;
+    started = true;
+    forced = false;
+    const active = ++generation;
+    const previous = run;
+    const current = (async () => {
+      if (previous)
+        await previous;
+      await runStream(active);
+    })().finally(() => {
+      if (run !== current)
+        return;
+      run = undefined;
+    });
+    run = current;
+    return run;
+  }
+  function stop() {
+    if (!started)
+      return;
+    started = false;
+    generation += 1;
+    stream?.abort();
+    setConnection({ status: "connecting", attempt: 0, error: undefined });
+  }
+  function resync(reason) {
+    if (!started || connection.status !== "connected")
+      return;
+    options.log?.info?.("event stream resync", { reason, idle: Date.now() - lastActivity });
+    forced = true;
+    current?.abort(new Error(reason));
+  }
+  if (options.pageLifecycle) {
+    const pagehide = () => stop();
+    const pageshow = () => void start();
+    const visibility = () => {
+      if (document.visibilityState !== "visible")
+        return;
+      if (Date.now() - lastActivity < foregroundIdleThreshold2)
+        return;
+      resync("Page returned to the foreground after the event stream went quiet");
+    };
+    const online = () => resync("Network connection restored");
+    window.addEventListener("pagehide", pagehide);
+    window.addEventListener("pageshow", pageshow);
+    window.addEventListener("online", online);
+    document.addEventListener("visibilitychange", visibility);
+    onCleanup(() => {
+      window.removeEventListener("pagehide", pagehide);
+      window.removeEventListener("pageshow", pageshow);
+      window.removeEventListener("online", online);
+      document.removeEventListener("visibilitychange", visibility);
+    });
+  }
+  start();
+  onCleanup(() => {
+    stop();
+    abort.abort();
+    if (flushTimer)
+      clearTimeout(flushTimer);
+    pending = [];
+  });
+  return {
+    status: () => connection.status,
+    attempt: () => connection.attempt,
+    error: () => connection.error,
+    internal: {
+      history: () => history.slice(),
+      resync
+    }
+  };
+}
+function errorMessage(error) {
+  if (error === undefined)
+    return;
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
+function wait(delay, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, delay);
+    signal.addEventListener("abort", done, { once: true });
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+  });
+}
+
+export { defaultIdleTimeout2, foregroundIdleThreshold2, createClientConnection2 };

package/dist/chunks/rpc-runtime-yepdgb80.js

@@ -0,0 +1,44 @@
+// 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 url = new URL(`/api/pty/${encodeURIComponent(input.ptyID)}/connect`, options.url);
+      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 url = new URL(`/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect`, options.url);
+      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/contract.js

@@ -1 +1,12 @@
-export { ClientApi, effectOmitEndpoints, groupNames, promiseOmitEndpoints } from "@opencode/protocol/client";
+import {
+  ClientApi2,
+  effectOmitEndpoints2,
+  groupNames2,
+  promiseOmitEndpoints2
+} from "./chunks/rpc-runtime-vmytr4q8.js";
+export {
+  ClientApi2 as ClientApi,
+  effectOmitEndpoints2 as effectOmitEndpoints,
+  groupNames2 as groupNames,
+  promiseOmitEndpoints2 as promiseOmitEndpoints
+};

package/dist/effect/client.js

@@ -1,29 +1,15 @@
-export * as OpenCode from "./client.js";
-import { Cause, Context, Effect, Stream } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { SharedEvents } from "../shared-events.js";
-import { ClientError, OpenCode } from "./generated/index.js";
-import { RpcClientRuntime } from "./rpc.js";
-const CurrentHeaders = Context.Reference("@opencode/client/effect/rpc/headers", {
-    defaultValue: () => undefined,
-});
-export const make = Effect.fn("OpenCode.make")(function* (options) {
-    const httpClient = yield* HttpClient.HttpClient;
-    const raw = yield* OpenCode.make(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();
-    // Async iterators throw a squashed cause; retain the native typed failures and defects intact.
-    class EventFailure {
-        cause;
-        constructor(cause) {
-            this.cause = cause;
-        }
-    }
-    const shared = SharedEvents.make((signal) => Stream.toAsyncIterableWith(native.pipe(Stream.interruptWhen(RpcClientRuntime.aborted(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 ClientError({ cause: error })))));
-    return {
-        ...raw,
-        event: { ...raw.event, subscribe },
-        rpc: Object.assign(RpcClientRuntime.make((input, options) => raw.rpc.call(input).pipe(Effect.provideService(CurrentHeaders, options?.headers)), subscribe), raw.rpc),
-    };
-});
+import {
+  make2,
+  exports_client
+} from "../chunks/rpc-runtime-fcxvjmkt.js";
+import"../chunks/rpc-runtime-65kht65h.js";
+import"../chunks/rpc-runtime-6mptkzbc.js";
+import"../chunks/rpc-runtime-bssvn03b.js";
+import"../chunks/rpc-runtime-y2etg5bs.js";
+import"../chunks/rpc-runtime-t1xa31vm.js";
+import"../chunks/rpc-runtime-vmytr4q8.js";
+import"../chunks/rpc-runtime-frbwqjmf.js";
+export {
+  exports_client as OpenCode,
+  make2 as make
+};

package/dist/effect/generated/client-error.js

@@ -1,5 +1,6 @@
-import { Schema } from "effect";
-export class ClientError extends Schema.TaggedError()("ClientError", {
-    cause: Schema.Defect(),
-}) {
-}
+import {
+  ClientError2
+} from "../../chunks/rpc-runtime-y2etg5bs.js";
+export {
+  ClientError2 as ClientError
+};