@anhlp/alp-client 0.0.0-stage → 0.10.0

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+export function alpHome(env?: NodeJS.ProcessEnv): string;
+/** Windows uses named pipes; long Unix homes get a short socket in the temp directory. */
+export function daemonPaths(home: any): {
+    home: any;
+    lock: string;
+    socket: string;
+    log: string;
+    install: string;
+};
+/**
+ * Finds alpd.js for a client that cannot locate it beside itself, such as the Paseo
+ * plugin, which Paseo re-bundles: the first existing candidate, then where alpd last
+ * recorded itself ($ALP_HOME/alpd.json), then the ALP CLI (`alp`) on PATH.
+ */
+export function findDaemonEntry({ home, env, candidates }?: {
+    home?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    candidates?: (string | undefined)[] | undefined;
+}): Promise<string | undefined>;
+/** Wall-clock boot time; a lock from an earlier boot is stale even if its pid is reused. */
+export function bootTime(): number;
+export function readLock(home: any): Promise<any>;
+export function lockAlive(lock: any): boolean;
+/** Connects and performs the version handshake. */
+export function connect(socketPath: any, client?: {
+    name: string;
+    version: string;
+}): Promise<AlpClient>;
+/**
+ * Returns the socket of a ready daemon, starting one when none runs.
+ * `entry` is the daemon script; it is started through its own detaching launcher so the
+ * daemon outlives the client that started it.
+ */
+export function ensureDaemon({ home, entry, env, execPath, timeoutMs }?: {
+    home?: string | undefined;
+    entry?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    execPath?: string | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<any>;
+export function discoverIntegration(name?: string, options?: {}): Promise<string | undefined>;
+export function startIntegration(nameOrOptions?: string): Promise<any>;
+/** One JSON-RPC 2.0 connection to alpd; events arrive as `event` notifications. */
+export class AlpClient {
+    constructor(socket: any);
+    get closed(): boolean;
+    request(method: any, params?: {}): Promise<any>;
+    onEvent(listener: any): () => boolean;
+    onRequest(handler: any): () => boolean;
+    onClose(listener: any): () => boolean;
+    close(): void;
+    #private;
+}
+export { PROTOCOL_VERSION, MAX_FRAME, AlpRpcError, encodeFrame } from "@anhlp/alp-protocol";

package/dist/index.js

@@ -0,0 +1,391 @@
+// packages/client/src/index.js
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { PROTOCOL_VERSION, MAX_FRAME, AlpRpcError, encodeFrame } from "@anhlp/alp-protocol";
+import { PROTOCOL_VERSION as PROTOCOL_VERSION2, MAX_FRAME as MAX_FRAME2, AlpRpcError as AlpRpcError2, encodeFrame as encodeFrame2 } from "@anhlp/alp-protocol";
+function alpHome(env = process.env) {
+  return path.resolve(env.ALP_HOME || path.join(os.homedir(), ".alp"));
+}
+function daemonPaths(home) {
+  const preferred = path.join(home, "alpd.sock");
+  const socket = process.platform === "win32" ? `\\\\.\\pipe\\alpd-${createHash("sha256").update(home).digest("hex").slice(0, 24)}` : Buffer.byteLength(preferred) < 100 ? preferred : path.join(os.tmpdir(), `alpd-${createHash("sha256").update(home).digest("hex").slice(0, 12)}.sock`);
+  return { home, lock: path.join(home, "alpd.lock"), socket, log: path.join(home, "logs", "alpd.log"), install: path.join(home, "alpd.json") };
+}
+var isFile = (file) => stat(file).then((info) => info.isFile(), () => false);
+var BIN_DIRECTORIES = [path.join(os.homedir(), ".npm-global", "bin"), path.join(os.homedir(), ".local", "bin"), "/opt/homebrew/bin", "/usr/local/bin"];
+var CLI_PACKAGES = ["@anhlp/alp", "@anhlp/alp-cli"];
+async function findDaemonEntry({ home = alpHome(), env = process.env, candidates = (
+  /** @type {Array<string | undefined>} */
+  []
+) } = {}) {
+  for (const candidate of candidates) if (candidate && await isFile(candidate)) return candidate;
+  try {
+    const { entry } = JSON.parse(await readFile(daemonPaths(home).install, "utf8"));
+    if (typeof entry === "string" && await isFile(entry)) return entry;
+  } catch {
+  }
+  for (const directory of [...(env.PATH ?? "").split(path.delimiter).filter(Boolean), ...BIN_DIRECTORIES]) {
+    const cli = await realpath(path.join(directory, "alp")).catch(() => void 0);
+    if (!cli || path.basename(cli) !== "cli.js") continue;
+    const root = path.resolve(path.dirname(cli), "..");
+    const name = await readFile(path.join(root, "package.json"), "utf8").then((text) => JSON.parse(text).name, () => void 0);
+    const entry = path.join(root, "dist", "alpd.js");
+    if (CLI_PACKAGES.includes(name) && await isFile(entry)) return entry;
+  }
+  return void 0;
+}
+function bootTime() {
+  return Math.round((Date.now() - os.uptime() * 1e3) / 1e3);
+}
+async function readLock(home) {
+  try {
+    return JSON.parse(await readFile(daemonPaths(home).lock, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT" || error instanceof SyntaxError) return void 0;
+    throw error;
+  }
+}
+function lockAlive(lock) {
+  if (!lock || !Number.isSafeInteger(lock.pid) || Math.abs((lock.bootTime ?? 0) - bootTime()) > 30) return false;
+  try {
+    process.kill(lock.pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+var AlpClient = class {
+  #socket;
+  #sequence = 0;
+  #pending = /* @__PURE__ */ new Map();
+  #events = /* @__PURE__ */ new Set();
+  #closes = /* @__PURE__ */ new Set();
+  #requestHandlers = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(socket) {
+    this.#socket = socket;
+    let buffer = "";
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      if (buffer.length > MAX_FRAME) {
+        socket.destroy(new Error("ALP daemon frame exceeds size limit"));
+        return;
+      }
+      for (let index = buffer.indexOf("\n"); index >= 0; index = buffer.indexOf("\n")) {
+        const line = buffer.slice(0, index);
+        buffer = buffer.slice(index + 1);
+        if (line.trim()) this.#receive(line);
+      }
+    });
+    socket.on("close", () => this.#finish(new Error("ALP daemon connection closed")));
+    socket.on("error", (error) => this.#finish(error));
+  }
+  #receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      this.#socket.destroy(new Error("Invalid frame from ALP daemon"));
+      return;
+    }
+    if (message.method === "event") {
+      for (const listener of this.#events) listener(message.params);
+      return;
+    }
+    if (message.method && (message.id !== void 0 && message.id !== null) && !Object.prototype.hasOwnProperty.call(message, "result") && !Object.prototype.hasOwnProperty.call(message, "error")) {
+      const handler = [...this.#requestHandlers][0];
+      if (handler) {
+        Promise.resolve().then(async () => {
+          try {
+            const result = await handler(message.method, message.params ?? {});
+            this.#socket.write(encodeFrame({ jsonrpc: "2.0", id: message.id, result: result === void 0 ? {} : result }));
+          } catch (error) {
+            const code = error && typeof error.code === "number" ? error.code : 1e3;
+            const msg = error instanceof Error ? error.message : String(error);
+            const data = error && error.data !== void 0 ? { data: error.data } : {};
+            this.#socket.write(encodeFrame({ jsonrpc: "2.0", id: message.id, error: { code, message: msg.length > 2e3 ? msg.slice(0, 2e3) + "..." : msg, ...data } }));
+          }
+        });
+        return;
+      }
+      this.#socket.write(encodeFrame({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: `Unknown method '${message.method}'` } }));
+      return;
+    }
+    const waiter = this.#pending.get(message.id);
+    if (!waiter) return;
+    this.#pending.delete(message.id);
+    if (message.error) waiter.reject(new AlpRpcError(message.error));
+    else waiter.resolve(message.result);
+  }
+  #finish(error) {
+    if (this.#closed) return;
+    this.#closed = true;
+    for (const waiter of this.#pending.values()) waiter.reject(error);
+    this.#pending.clear();
+    for (const listener of this.#closes) listener(error);
+  }
+  get closed() {
+    return this.#closed;
+  }
+  request(method, params = {}) {
+    if (this.#closed) return Promise.reject(new Error("ALP daemon connection closed"));
+    const id = ++this.#sequence;
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      this.#socket.write(encodeFrame({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+  onEvent(listener) {
+    this.#events.add(listener);
+    return () => this.#events.delete(listener);
+  }
+  onRequest(handler) {
+    this.#requestHandlers.add(handler);
+    return () => this.#requestHandlers.delete(handler);
+  }
+  onClose(listener) {
+    this.#closes.add(listener);
+    return () => this.#closes.delete(listener);
+  }
+  close() {
+    this.#socket.end();
+    this.#finish(new Error("ALP daemon connection closed"));
+  }
+};
+async function connect(socketPath, client = { name: "alp", version: "0" }) {
+  const socket = await new Promise((resolve, reject) => {
+    const candidate = net.createConnection(socketPath);
+    candidate.once("connect", () => {
+      candidate.off("error", reject);
+      resolve(candidate);
+    });
+    candidate.once("error", reject);
+  });
+  const connection = new AlpClient(socket);
+  try {
+    await connection.request("daemon.hello", { protocolVersion: PROTOCOL_VERSION, client });
+  } catch (error) {
+    connection.close();
+    throw error;
+  }
+  return connection;
+}
+async function tail(file, lines = 30) {
+  try {
+    return (await readFile(file, "utf8")).split("\n").slice(-lines).join("\n");
+  } catch {
+    return "";
+  }
+}
+async function ensureDaemon({ home = alpHome(), entry = (
+  /** @type {string | undefined} */
+  void 0
+), env = process.env, execPath = process.execPath, timeoutMs = 15e3 } = {}) {
+  const ready = async () => {
+    const lock = await readLock(home);
+    return lockAlive(lock) && lock.ready ? lock.socket : void 0;
+  };
+  const live = await ready();
+  if (live) return live;
+  if (!lockAlive(await readLock(home))) {
+    entry ??= await findDaemonEntry({ home, env });
+    if (!entry) throw new Error("ALP daemon is not running and alpd.js was not found. Install the ALP CLI and run `alp daemon start`, or set ALP_DAEMON_ENTRY to alpd.js");
+    await new Promise((resolve, reject) => {
+      const launcher = spawn(execPath, [entry, "--detach"], {
+        env: { ...env, ALP_HOME: home, ELECTRON_RUN_AS_NODE: "1" },
+        stdio: "ignore",
+        windowsHide: true
+      });
+      launcher.once("error", reject);
+      launcher.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`ALP daemon launcher exited (${code})`)));
+    });
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const socket = await ready();
+    if (socket) return socket;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  const log = await tail(daemonPaths(home).log);
+  throw new Error(`ALP daemon did not become ready within ${timeoutMs} ms${log ? `
+${log}` : ""}`);
+}
+var INTEGRATION_DESCRIPTOR_FIELDS = ["main", "entry", "path", "command"];
+async function readIntegrationDescriptor(file, baseDirs = []) {
+  try {
+    const raw = JSON.parse(await readFile(file, "utf8"));
+    for (const field of INTEGRATION_DESCRIPTOR_FIELDS) {
+      const value = raw?.[field];
+      if (typeof value !== "string" || !value.trim()) continue;
+      if (path.isAbsolute(value)) {
+        if (await isFile(value)) return value;
+      } else {
+        const bases = [path.dirname(file), ...baseDirs];
+        for (const base of bases) {
+          const resolved = path.resolve(base, value);
+          if (await isFile(resolved)) return resolved;
+        }
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function integrationCandidateFromHome(home, name) {
+  const descriptors = [
+    path.join(home, "integrations", `${name}.json`),
+    path.join(home, "integrations", name, "integration.json")
+  ];
+  for (const descriptor of descriptors) {
+    const entry = await readIntegrationDescriptor(descriptor, [home]);
+    if (entry) return entry;
+  }
+  const legacy = path.join(home, "integrations", name, "main.js");
+  return await isFile(legacy) ? legacy : void 0;
+}
+function integrationBinaryName(name) {
+  return name === "web" ? "alp-web-integration" : `alp-${name}-integration`;
+}
+async function distributionRoots() {
+  const roots = [];
+  const argv = process.argv[1] ? await realpath(process.argv[1]).catch(() => process.argv[1]) : void 0;
+  if (argv) {
+    let directory = path.dirname(argv);
+    for (let depth = 0; depth < 4; depth += 1) {
+      roots.push(path.resolve(directory, ".."));
+      directory = path.resolve(directory, "..");
+    }
+    for (let ancestor = path.dirname(argv); ; ancestor = path.dirname(ancestor)) {
+      if (await isFile(path.join(ancestor, "package.json"))) roots.push(ancestor);
+      if (path.dirname(ancestor) === ancestor) break;
+    }
+  }
+  roots.push(process.cwd());
+  return [...new Set(roots)];
+}
+async function discoverIntegration(name = "web", options = {}) {
+  const envCandidates = [
+    process.env.ALP_WEB_INTEGRATION,
+    process.env.ALP_INTEGRATION_ENTRY,
+    name !== "web" ? process.env[`ALP_${name.toUpperCase()}_INTEGRATION`] : void 0
+  ].filter(Boolean);
+  for (const candidate of envCandidates) if (await isFile(candidate)) return candidate;
+  const home = options?.home ? path.resolve(options.home) : alpHome();
+  const fromHome = await integrationCandidateFromHome(home, name);
+  if (fromHome) return fromHome;
+  for (const root of await distributionRoots()) {
+    for (const descriptorPath of [path.join(root, "integrations", `${name}.json`), path.join(root, "integrations", name, "integration.json")]) {
+      const entry = await readIntegrationDescriptor(descriptorPath, [root]);
+      if (entry) return entry;
+    }
+  }
+  const binary = integrationBinaryName(name);
+  for (const directory of [...(process.env.PATH ?? "").split(path.delimiter).filter(Boolean), ...BIN_DIRECTORIES]) {
+    const candidate = await realpath(path.join(directory, binary)).catch(() => void 0);
+    if (candidate && await isFile(candidate)) return candidate;
+  }
+  return void 0;
+}
+function integrationAlive(lock) {
+  if (!lock || !Number.isSafeInteger(lock.pid)) return false;
+  try {
+    process.kill(lock.pid, 0);
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+  if (typeof lock.bootTime === "number" && Math.abs(lock.bootTime - bootTime()) > 30) return false;
+  return true;
+}
+async function startIntegration(nameOrOptions = "web") {
+  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions ?? {};
+  const name = options.name ?? "web";
+  const fs = await import("node:fs/promises");
+  const pathMod = await import("node:path");
+  const home = options.home ? pathMod.resolve(options.home) : alpHome();
+  const lockPath = pathMod.join(home, "integrations", `${name}.lock`);
+  const webPath = pathMod.join(home, `${name}.json`);
+  let settings = {};
+  try {
+    settings = JSON.parse(await fs.readFile(pathMod.join(home, "settings.json"), "utf8"));
+  } catch {
+  }
+  if (settings?.web?.enabled === false) {
+    throw new Error('ALP web app is disabled by settings ("web.enabled": false).');
+  }
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const readLock2 = async () => {
+    try {
+      return JSON.parse(await fs.readFile(lockPath, "utf8"));
+    } catch {
+      return void 0;
+    }
+  };
+  const readWeb = async () => {
+    try {
+      return JSON.parse(await fs.readFile(webPath, "utf8"));
+    } catch {
+      return void 0;
+    }
+  };
+  async function waitForReady() {
+    const deadline = Date.now() + 3e4;
+    while (Date.now() < deadline) {
+      const lock2 = await readLock2();
+      if (lock2 && integrationAlive(lock2) && lock2.ready) {
+        const info = await readWeb();
+        if (info && info.pid === lock2.pid) return lock2;
+      }
+      await sleep(100);
+    }
+    const lock = await readLock2();
+    if (lock && !lock.ready) throw new Error("ALP web integration started but did not become ready; see ~/.alp/logs/integrations/paseo.log");
+    if (!lock) throw new Error("ALP web app is provided by an optional integration package. Install it (for example `npm install -g alp-paseo-plugin`) and run `alp web` again.");
+    throw new Error("ALP web integration did not publish a matching web.json lock");
+  }
+  const existing = await readLock2();
+  if (existing && integrationAlive(existing)) {
+    return waitForReady();
+  }
+  const entry = await discoverIntegration(name, { home });
+  if (!entry) {
+    throw new Error("ALP web app is provided by an optional integration package. Install it (for example `npm install -g alp-paseo-plugin`) and run `alp web` again.");
+  }
+  const { spawn: spawn2 } = await import("node:child_process");
+  const child = spawn2(process.execPath, [entry, "--service"], { stdio: "ignore", detached: true, env: { ...process.env, ALP_HOME: home } });
+  let spawnError = null;
+  child.on("error", (error) => {
+    spawnError = error;
+  });
+  let exited = false;
+  child.on("exit", (code) => {
+    if (code !== 0 && code !== null) exited = true;
+  });
+  child.unref();
+  if (spawnError) throw spawnError;
+  await sleep(150);
+  if (spawnError) throw spawnError;
+  if (exited) throw new Error("ALP web integration failed to start; see ~/.alp/logs/integrations/paseo.log");
+  return waitForReady();
+}
+export {
+  AlpClient,
+  AlpRpcError2 as AlpRpcError,
+  MAX_FRAME2 as MAX_FRAME,
+  PROTOCOL_VERSION2 as PROTOCOL_VERSION,
+  alpHome,
+  bootTime,
+  connect,
+  daemonPaths,
+  discoverIntegration,
+  encodeFrame2 as encodeFrame,
+  ensureDaemon,
+  findDaemonEntry,
+  lockAlive,
+  readLock,
+  startIntegration
+};

package/dist/library-test.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Tries an MCP server, a hook or an ACP provider out (ALPD §43, §46). An MCP server is
+ * started and its tools listed; a provider is started and initialized; a hook runs once with a sample payload for its event, in the project (or the
+ * library when there is none), with the variables ALP gives hooks.
+ */
+export function testEntry(kind: any, name: any, { root, library, templates, scope, timeoutMs }?: {}): Promise<{
+    server?: {
+        name?: string;
+        version?: string;
+    };
+    tools: Array<{
+        name: string;
+        description?: string;
+    }>;
+    kind: any;
+    name: any;
+    source: "project" | "builtin" | "library";
+    ok: boolean;
+} | {
+    exitCode: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    payload: {
+        branch?: string | undefined;
+        files?: never[] | undefined;
+        task?: any;
+        reason?: string | undefined;
+        handoff?: {
+            outcome: string;
+            summary: string;
+        } | undefined;
+        event: any;
+        sample: boolean;
+        project: any;
+        session: string;
+        agent: string;
+    };
+    wouldBlock?: boolean | undefined;
+    kind: any;
+    name: any;
+    source: "project" | "builtin" | "library";
+    ok: boolean;
+} | {
+    protocolVersion: number;
+    agent?: {
+        name?: string;
+        title?: string;
+        version?: string;
+    };
+    loadSession: boolean;
+    mcpHttp: boolean;
+    authMethods: string[];
+    models?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+    currentModel?: string;
+    modes?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+    currentMode?: string;
+    kind: any;
+    name: any;
+    source: "project" | "builtin" | "library";
+    ok: boolean;
+} | {
+    version: string;
+    agent: {
+        name: string;
+        title: string;
+        version: string;
+    };
+    models: {
+        id: any;
+        label: any;
+    }[];
+    currentModel: any;
+    modes: {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    currentMode: string;
+    kind: any;
+    name: any;
+    source: "project" | "builtin" | "library";
+    ok: boolean;
+}>;

package/dist/library-test.js

@@ -0,0 +1,37 @@
+// packages/client/src/library-test.js
+import path from "node:path";
+import { AlpError } from "@anhlp/alp-core/errors";
+import { getEntry } from "@anhlp/alp-core/library-edit";
+import { runHook, samplePayload } from "@anhlp/alp-core/hook-run";
+import { normalizeMcp } from "@anhlp/alp-core/validation";
+import { probeMcp } from "./mcp-probe.js";
+import { probeAcp } from "./acp-probe.js";
+import { probeAntigravity } from "./antigravity-probe.js";
+import { loadProvider } from "@anhlp/alp-core/providers";
+async function testEntry(kind, name, { root, library, templates, scope, timeoutMs } = {}) {
+  const entry = await getEntry(kind, name, { root, library, templates, scope });
+  const home = entry.source === "project" ? path.join(path.resolve(root), ".alp") : library;
+  if (kind === "mcp") {
+    const server = normalizeMcp({ mcpServers: { [name]: entry.content.server } }, path.join(home, "mcp"), `${name}.json`).mcpServers[name];
+    const result = await probeMcp(server, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} });
+    return { kind, name, source: entry.source, ok: true, ...result };
+  }
+  if (kind === "hooks") {
+    const hook = entry.content.hook;
+    const project = root ? path.resolve(root) : void 0;
+    const payload = samplePayload(hook.event, { project, agent: hook.match?.agent ?? "main" });
+    const env = { ALP_EVENT: hook.event, ALP_SESSION: payload.session, ALP_AGENT: payload.agent, ALP_PROJECT: project ?? "", ALP_TASK: payload.task ?? "" };
+    const result = await runHook(hook, payload, { cwd: project ?? library, env, ...timeoutMs ? { timeoutMs } : {} });
+    const ok = result.exitCode === 0 && !result.timedOut;
+    return { kind, name, source: entry.source, ok, ...hook.blocking && !ok ? { wouldBlock: true } : {}, payload, ...result };
+  }
+  if (kind === "providers") {
+    const provider = await loadProvider(library, name);
+    const result = provider.kind === "antigravity" ? await probeAntigravity(provider, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} }) : await probeAcp(provider, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} });
+    return { kind, name, source: entry.source, ok: true, ...result };
+  }
+  throw new AlpError("INVALID_KIND", `Only mcp servers, hooks and providers can be tested, not ${kind}`);
+}
+export {
+  testEntry
+};

package/dist/mcp-probe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Starts an MCP server once and lists its tools (ALPD §43), for the Test button and
+ * `alp mcp test`. `server` is a normalized definition: { command, args, env, cwd } for
+ * stdio, or { url, headers } for HTTP. The server is stopped afterwards.
+ * @returns {Promise<{ server?: { name?: string, version?: string }, tools: Array<{ name: string, description?: string }> }>}
+ */
+export function probeMcp(server: any, { cwd, timeoutMs }?: {
+    timeoutMs?: number | undefined;
+}): Promise<{
+    server?: {
+        name?: string;
+        version?: string;
+    };
+    tools: Array<{
+        name: string;
+        description?: string;
+    }>;
+}>;
+/** A JSON-RPC session with a process over stdio; ACP providers are probed with it too. */
+export function stdioSession(server: any, cwd: any, timeoutMs: any): {
+    request(method: any, params: any): Promise<any>;
+    notify(method: any): Promise<void>;
+    close(): Promise<void>;
+};