@kilocode/client 0.0.0-stage → 0.0.0-v2-9

package/dist/chunks/contract-skhp7hxc.js

@@ -0,0 +1,81 @@
+import {
+  isRpcError2,
+  isRpcInternalError2
+} from "./contract-c46qzyff.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/chunks/contract-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/contract-ve4aws36.js

@@ -0,0 +1,103 @@
+// 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,
+    windowsHide: 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 contenderPool2(timing) {
+  const contenders = new Set;
+  let failure;
+  let spawnDelay = timing.spawnDelay;
+  let lastSpawn = 0;
+  return {
+    failure: () => failure,
+    serviceAnswered() {
+      spawnDelay = timing.spawnDelay;
+    },
+    evict(pid) {
+      for (const item of contenders) {
+        if (item.child.pid === pid || contenderFinished2(item)) {
+          item.release();
+          contenders.delete(item);
+        }
+      }
+      failure = undefined;
+      lastSpawn = 0;
+    },
+    recruitNow() {
+      lastSpawn = Date.now() - spawnDelay;
+    },
+    reap() {
+      const finished = [...contenders].filter(contenderFinished2);
+      failure ??= finished.map(contenderFailure).find((error) => error !== undefined);
+      if (finished.some((item) => item.child.exitCode === 0))
+        spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
+      finished.forEach((item) => contenders.delete(item));
+      return contenders.size === 0 ? failure : undefined;
+    },
+    shouldRecruit(registered) {
+      if (lastSpawn === 0 && registered)
+        lastSpawn = Date.now();
+      return failure === undefined && contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay;
+    },
+    add(contender) {
+      contenders.add(contender);
+      lastSpawn = Date.now();
+    },
+    releaseAll() {
+      contenders.forEach((contender) => contender.release());
+    }
+  };
+}
+function contenderFailure(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, contenderPool2, contenderFinished2 };

package/dist/chunks/contract-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/contract-vwtmm97t.js

@@ -0,0 +1,30 @@
+import {
+  make7
+} from "./contract-8bbb028w.js";
+import {
+  make6
+} from "./contract-s2hya144.js";
+import {
+  makeRpc2
+} from "./contract-skhp7hxc.js";
+import {
+  __export
+} from "./contract-9rqn6x4v.js";
+
+// src/promise/client.ts
+var exports_client3 = {};
+__export(exports_client3, {
+  OpenCode: () => exports_client3,
+  make: () => make5
+});
+function make5(options) {
+  const raw = make6(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+
+export { make5, exports_client3 };