@opencode/client 2.0.8 → 2.0.9

package/dist/promise/service.js

@@ -1,263 +1,266 @@
+import {
+  spawnServiceContender2,
+  contenderFailure2,
+  contenderFinished2
+} from "../chunks/pty-handoff-txckps9j.js";
+import {
+  defaultEnsureTiming2,
+  ensureTiming2
+} from "../chunks/pty-handoff-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "../chunks/pty-handoff-sxt88q69.js";
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2
+} from "../chunks/pty-handoff-nqd0dnpk.js";
+import"../chunks/pty-handoff-qav6mfdz.js";
+
+// src/promise/service.ts
 import { readFile, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { contenderFailure, contenderFinished, spawnServiceContender, } from "../service-contender.js";
-import { defaultEnsureTiming, ensureTiming } from "../service-timing.js";
-import { matchesVersion } from "../service-version.js";
-import { PtyHandoff } from "../pty-handoff.js";
-export * from "../service.js";
-// Find, start, and stop the local opencode background service.
-//
-// The registration file is the complete discovery contract. This module is
-// intentionally implemented with Node APIs so Promise clients do not need
-// Effect or @effect/platform-node at runtime.
-/** Discover a healthy, compatible local service without starting one. */
-export async function discover(options = {}) {
-    const found = (await registered(options.file)).service;
-    if (found?.state !== "ready")
-        return undefined;
-    if (!found.compatible)
-        return undefined;
-    if (!matchesVersion(found.version, options))
-        return undefined;
-    return found.endpoint;
+async function discover(options = {}) {
+  const found = (await registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
 }
-/** Ensure a healthy, compatible local service is running. */
-export async function ensure(options = {}) {
-    const timing = ensureTiming(options);
-    const deadline = Date.now() + timing.promiseTimeout;
-    const contenders = new Set();
-    let timeouts;
-    let announced = false;
-    let lastSpawn = 0;
-    let spawnDelay = timing.spawnDelay;
-    const announce = (reason, previousVersion) => {
-        if (announced)
+async function ensure(options = {}) {
+  const timing = ensureTiming2(options);
+  const deadline = Date.now() + timing.promiseTimeout;
+  const contenders = new Set;
+  let timeouts;
+  let announced = false;
+  let lastSpawn = 0;
+  let spawnDelay = timing.spawnDelay;
+  const announce = (reason, previousVersion) => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  };
+  const spawnContender = async () => {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === undefined)
+      throw new Error("Missing service command");
+    try {
+      return spawnServiceContender2(command, args, await environment2(options.file ?? fallback(), options.env));
+    } catch (cause) {
+      throw new Error("Failed to start server", { cause });
+    }
+  };
+  try {
+    while (true) {
+      if (Date.now() >= deadline)
+        throw new Error("Timed out waiting for the background service to start");
+      const registration = await registered(options.file, timing.requestTimeout);
+      if (registration.timedOut && registration.info !== undefined) {
+        timeouts = {
+          info: registration.info,
+          count: timeouts !== undefined && same(timeouts.info, registration.info) ? timeouts.count + 1 : 1
+        };
+        if (timeouts.count >= 3) {
+          announce("missing");
+          console.warn("Background service is unresponsive; recovery cannot preserve persistent terminals");
+          await clear2(options.file ?? fallback());
+          await terminate(registration.info, options, timing);
+          timeouts = undefined;
+          lastSpawn = Date.now() - spawnDelay;
+        }
+      } else
+        timeouts = undefined;
+      if (registration.service !== undefined) {
+        spawnDelay = timing.spawnDelay;
+        const service2 = registration.service;
+        const compatible = service2.compatible && matchesVersion2(service2.version, options);
+        if (compatible && service2.state === "ready") {
+          await complete2(options.file ?? fallback(), service2.info);
+          return service2.endpoint;
+        }
+        if (compatible && service2.state === "failed")
+          throw new Error("Background service failed to start");
+        if (!compatible) {
+          announce("version-mismatch", service2.version);
+          if (service2.state !== "ready")
+            console.warn("Background service is not ready; replacement cannot preserve persistent terminals");
+          await stop({
+            file: options.file,
+            pty: service2.state === "ready" ? "handoff" : "clear"
+          }).catch(() => {
             return;
-        announced = true;
-        options.onStart?.(reason, previousVersion);
-    };
-    const spawnContender = async () => {
-        const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
-        if (command === undefined)
-            throw new Error("Missing service command");
-        try {
-            return spawnServiceContender(command, args, await PtyHandoff.environment(options.file ?? fallback(), options.env));
+          });
+          lastSpawn = 0;
         }
-        catch (cause) {
-            throw new Error("Failed to start server", { cause });
+      } else {
+        if (lastSpawn === 0 && registration.info !== undefined)
+          lastSpawn = Date.now();
+        const finished = [...contenders].filter(contenderFinished2);
+        const failure = finished.map(contenderFailure2).find((error) => error !== undefined);
+        if (finished.some((item) => item.child.exitCode === 0)) {
+          spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
         }
-    };
-    try {
-        while (true) {
-            if (Date.now() >= deadline)
-                throw new Error("Timed out waiting for the background service to start");
-            const registration = await registered(options.file, timing.requestTimeout);
-            if (registration.timedOut && registration.info !== undefined) {
-                timeouts = {
-                    info: registration.info,
-                    count: timeouts !== undefined && same(timeouts.info, registration.info) ? timeouts.count + 1 : 1,
-                };
-                if (timeouts.count >= 3) {
-                    announce("missing");
-                    console.warn("Background service is unresponsive; recovery cannot preserve persistent terminals");
-                    await PtyHandoff.clear(options.file ?? fallback());
-                    await terminate(registration.info, options, timing);
-                    timeouts = undefined;
-                    lastSpawn = Date.now() - spawnDelay;
-                }
-            }
-            else
-                timeouts = undefined;
-            if (registration.service !== undefined) {
-                spawnDelay = timing.spawnDelay;
-                const service = registration.service;
-                const compatible = service.compatible && matchesVersion(service.version, options);
-                if (compatible && service.state === "ready") {
-                    await PtyHandoff.complete(options.file ?? fallback(), service.info);
-                    return service.endpoint;
-                }
-                if (compatible && service.state === "failed")
-                    throw new Error("Background service failed to start");
-                if (!compatible) {
-                    announce("version-mismatch", service.version);
-                    if (service.state !== "ready")
-                        console.warn("Background service is not ready; replacement cannot preserve persistent terminals");
-                    await stop({
-                        file: options.file,
-                        pty: service.state === "ready" ? "handoff" : "clear",
-                    }).catch(() => undefined);
-                    lastSpawn = 0;
-                }
-            }
-            else {
-                if (lastSpawn === 0 && registration.info !== undefined)
-                    lastSpawn = Date.now();
-                const finished = [...contenders].filter(contenderFinished);
-                const 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));
-                if (failure !== undefined && contenders.size === 0)
-                    throw failure;
-                // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
-                if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
-                    announce("missing");
-                    contenders.add(await spawnContender());
-                    lastSpawn = Date.now();
-                }
-            }
-            await delay(timing.pollInterval);
+        finished.forEach((item) => contenders.delete(item));
+        if (failure !== undefined && contenders.size === 0)
+          throw failure;
+        if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
+          announce("missing");
+          contenders.add(await spawnContender());
+          lastSpawn = Date.now();
         }
+      }
+      await delay(timing.pollInterval);
     }
-    finally {
-        contenders.forEach((contender) => contender.release());
-    }
+  } finally {
+    contenders.forEach((contender) => contender.release());
+  }
 }
-/** Stop the registered local service. */
-export async function stop(options = {}) {
-    const info = await read(options.file);
-    if (options.pty === "handoff" && info !== undefined)
-        await PtyHandoff.prepare(options.file ?? fallback(), info, defaultEnsureTiming.requestTimeout);
-    else
-        await PtyHandoff.clear(options.file ?? fallback());
-    if (info !== undefined)
-        await terminate(info, options, defaultEnsureTiming);
+async function stop(options = {}) {
+  const info = await read(options.file);
+  if (options.pty === "handoff" && info !== undefined)
+    await prepare2(options.file ?? fallback(), info, defaultEnsureTiming2.requestTimeout);
+  else
+    await clear2(options.file ?? fallback());
+  if (info !== undefined)
+    await terminate(info, options, defaultEnsureTiming2);
 }
 function fallback() {
-    return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
+  return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
 }
-/** Create HTTP authentication headers for a service endpoint. */
-export function headers(endpoint) {
-    if (endpoint.auth === undefined)
-        return undefined;
-    return {
-        authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64"),
-    };
+function headers(endpoint) {
+  if (endpoint.auth === undefined)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
 }
 async function read(file) {
-    const text = await readFile(file ?? fallback(), "utf8").catch(() => undefined);
-    if (text === undefined)
-        return undefined;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
+  const text = await readFile(file ?? fallback(), "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
 }
-async function probeResult(info, timeout = defaultEnsureTiming.requestTimeout) {
-    const endpoint = {
-        url: info.url,
-        auth: info.password === undefined
-            ? undefined
-            : { type: "basic", username: "opencode", password: info.password },
+async function probeResult(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: headers(endpoint), signal }).then(async (response) => ({
+    response,
+    body: response.status === 404 ? undefined : await response.json()
+  })).then((value) => ({ value }), (cause) => ({ cause }));
+  if ("cause" in result)
+    return { service: undefined, timedOut: signal.aborted };
+  const response = result.value.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
     };
-    const signal = AbortSignal.timeout(timeout);
-    const result = await fetch(new URL("/api/info", info.url), { headers: headers(endpoint), signal })
-        .then(async (response) => ({
-        response,
-        body: response.status === 404 ? undefined : (await response.json()),
-    }))
-        .then((value) => ({ value }), (cause) => ({ cause }));
-    if ("cause" in result)
-        return { service: undefined, timedOut: signal.aborted };
-    const response = result.value.response;
-    // The previous V2 service exposes /api/status instead. Its authenticated 404 is enough
-    // to recognize the registered daemon as incompatible and route it through replacement.
-    if (response.status === 404)
-        return {
-            service: {
-                info,
-                endpoint,
-                version: info.version,
-                state: "ready",
-                compatible: false,
-            },
-            timedOut: false,
-        };
-    const serverInfo = decodeInfo(result.value.body);
-    if (serverInfo !== undefined) {
-        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,
-        };
-    }
-    return { service: undefined, timedOut: false };
+  const serverInfo = decodeInfo(result.value.body);
+  if (serverInfo !== undefined) {
+    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
+    };
+  }
+  return { service: undefined, timedOut: false };
 }
 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 };
+  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 };
 }
 async function registered(file, timeout) {
-    const info = await read(file);
-    if (info === undefined)
-        return { info: undefined, service: undefined, timedOut: false };
-    return { info, ...(await probeResult(info, timeout)) };
+  const info = await read(file);
+  if (info === undefined)
+    return { info: undefined, service: undefined, timedOut: false };
+  return { info, ...await probeResult(info, timeout) };
 }
 function signal(pid, name) {
-    try {
-        process.kill(pid, name);
-    }
-    catch { }
+  try {
+    process.kill(pid, name);
+  } catch {}
 }
 function stopped(pid) {
-    try {
-        process.kill(pid, 0);
-        return false;
-    }
-    catch {
-        return true;
-    }
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
 }
 async function waitUntilStopped(pid, timing) {
-    for (let attempt = 0; attempt <= timing.stopPollAttempts; attempt++) {
-        if (stopped(pid))
-            return true;
-        if (attempt < timing.stopPollAttempts)
-            await delay(timing.stopPollInterval);
-    }
-    return false;
+  for (let attempt = 0;attempt <= timing.stopPollAttempts; attempt++) {
+    if (stopped(pid))
+      return true;
+    if (attempt < timing.stopPollAttempts)
+      await delay(timing.stopPollInterval);
+  }
+  return false;
 }
 function same(left, right) {
-    return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
 }
 async function terminate(info, options, timing) {
-    const current = await read(options.file);
-    if (current === undefined || !same(current, info))
-        return;
-    signal(info.pid, "SIGTERM");
-    if (!(await waitUntilStopped(info.pid, timing))) {
-        const latest = await read(options.file);
-        if (latest === undefined || !same(latest, info))
-            return;
-        signal(info.pid, "SIGKILL");
-        if (!(await waitUntilStopped(info.pid, timing)))
-            throw new Error(`Server process ${info.pid} is still running`);
-    }
+  const current = await read(options.file);
+  if (current === undefined || !same(current, info))
+    return;
+  signal(info.pid, "SIGTERM");
+  if (!await waitUntilStopped(info.pid, timing)) {
     const latest = await read(options.file);
     if (latest === undefined || !same(latest, info))
-        return;
-    await rm(options.file ?? fallback(), { force: true });
+      return;
+    signal(info.pid, "SIGKILL");
+    if (!await waitUntilStopped(info.pid, timing))
+      throw new Error(`Server process ${info.pid} is still running`);
+  }
+  const latest = await read(options.file);
+  if (latest === undefined || !same(latest, info))
+    return;
+  await rm(options.file ?? fallback(), { force: true });
 }
 function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-/** Promise-based local service lifecycle operations. */
-export const Service = { discover, ensure, stop, headers };
+var Service = { discover, ensure, stop, headers };
+export {
+  Service,
+  discover,
+  ensure,
+  headers,
+  stop
+};

package/dist/pty-handoff.js

@@ -1,121 +1,14 @@
-export * as PtyHandoff from "./pty-handoff.js";
-import { readFile, rename, rm, writeFile } from "node:fs/promises";
-/** Publish the ticket before stopping its owner so every replacement contender can adopt it. */
-export async function prepare(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) {
-        // Another caller may already have prepared and stopped this server.
-        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() + 30_000,
-    }), { mode: 0o600, flag: "wx" });
-    await rename(temporary, file + ".pty-handoff").finally(() => rm(temporary, { force: true }));
-}
-export async function environment(file, env) {
-    const record = await read(file);
-    const current = await readFile(file, "utf8")
-        .then((text) => JSON.parse(text))
-        .catch(() => undefined);
-    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) };
-}
-export async function complete(file, info) {
-    const record = await read(file);
-    if (record !== undefined && !same(record.source, info))
-        await clear(file);
-}
-export async function clear(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(() => undefined);
-    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));
-}
+import {
+  prepare2,
+  environment2,
+  complete2,
+  clear2,
+  exports_pty_handoff
+} from "./chunks/pty-handoff-nqd0dnpk.js";
+export {
+  exports_pty_handoff as PtyHandoff,
+  clear2 as clear,
+  complete2 as complete,
+  environment2 as environment,
+  prepare2 as prepare
+};