@keb-org/consol 0.1.1 → 0.3.0

package/dist/index.js

@@ -1,5 +1,3 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -7,30 +5,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
 }
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  if (mod && typeof mod === "object" || typeof mod === "function") {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(to, key))
-        __defProp(to, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-  }
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
 var __toCommonJS = (from) => {
   var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
@@ -84,7 +58,6 @@ class ConsolError extends Error {
   field;
   tool;
   status;
-  stderrTail;
   result;
   constructor(code, message, details = {}) {
     super(message, details.cause === undefined ? undefined : { cause: details.cause });
@@ -97,8 +70,6 @@ class ConsolError extends Error {
       this.tool = details.tool;
     if (details.status !== undefined)
       this.status = details.status;
-    if (details.stderrTail !== undefined)
-      this.stderrTail = details.stderrTail;
     if (details.result !== undefined)
       this.result = details.result;
     Object.defineProperty(this, BRAND, { value: true });
@@ -118,11 +89,8 @@ function replyError(reply, tool) {
     result: reply
   });
 }
-// src/stdio.ts
-var import_node_child_process = require("node:child_process");
-var import_node_fs = require("node:fs");
-var readline = __toESM(require("node:readline"));
-var import_node_string_decoder = require("node:string_decoder");
+// src/native.ts
+var import_node_path = require("node:path");
 
 // src/transport.ts
 var DEFAULT_TIMEOUT_MS = 300000;
@@ -211,409 +179,164 @@ class HttpTransport {
   }
 }
 
-// src/stdio.ts
-var STDERR_TAIL_BYTES = 4096;
-var EXIT_WAIT_MS = 2000;
-var KILL_WAIT_MS = 4000;
-function engineEnv(o) {
-  const env = {};
+// src/native.ts
+function engineSettings(o) {
+  const s = {};
   const db = o.db ?? process.env.CONSOL_DB_URL;
   if (db !== undefined)
-    env.CONSOL_DB_URL = db;
+    s.CONSOL_DB_URL = db;
   const e = o.embedding;
   if (e !== undefined) {
-    env.CONSOL_EMBED_URL = e.url;
+    s.CONSOL_EMBED_URL = e.url;
     if (e.apiKey !== undefined)
-      env.CONSOL_EMBED_API_KEY = e.apiKey;
-    env.CONSOL_EMBED_MODEL = e.model;
+      s.CONSOL_EMBED_API_KEY = e.apiKey;
+    s.CONSOL_EMBED_MODEL = e.model;
     if (e.dims !== undefined)
-      env.CONSOL_EMBED_DIMS = String(e.dims);
-    if (e.queryPrefix !== undefined)
-      env.CONSOL_EMBED_QUERY_PREFIX = e.queryPrefix;
-    if (e.batchSize !== undefined)
-      env.CONSOL_EMBED_BATCH = String(e.batchSize);
+      s.CONSOL_EMBED_DIMS = String(e.dims);
     if (e.timeoutMs !== undefined)
-      env.CONSOL_EMBED_TIMEOUT_MS = String(e.timeoutMs);
+      s.CONSOL_EMBED_TIMEOUT_MS = String(e.timeoutMs);
   }
   const j = o.jev;
   if (j !== undefined) {
     if (j.url !== undefined)
-      env.CONSOL_JEV_URL = j.url;
+      s.CONSOL_JEV_URL = j.url;
     if (j.apiKey !== undefined)
-      env.CONSOL_JEV_API_KEY = j.apiKey;
+      s.CONSOL_JEV_API_KEY = j.apiKey;
     if (j.model !== undefined)
-      env.CONSOL_JEV_MODEL = j.model;
+      s.CONSOL_JEV_MODEL = j.model;
     if (j.auto === false)
-      env.CONSOL_JEV_AUTO = "0";
+      s.CONSOL_JEV_AUTO = "0";
   }
-  return env;
-}
-function platformExe() {
-  return process.platform === "win32" ? "consol.exe" : "consol";
+  return { ...s, ...o.env };
 }
-function isFile(path) {
+function loadAddon(explicit) {
+  const fromEnv = process.env.CONSOL_ADDON;
+  const spec = `@keb-org/consol-${process.platform}-${process.arch}/consol.node`;
+  const [attempt, target] = explicit ? [`addonPath:${explicit}`, import_node_path.resolve(explicit)] : fromEnv ? [`CONSOL_ADDON:${fromEnv}`, import_node_path.resolve(fromEnv)] : [`package:${spec}`, spec];
   try {
-    return import_node_fs.statSync(path).isFile();
-  } catch {
-    return false;
+    const sdkRequire = require;
+    return sdkRequire(target);
+  } catch (cause) {
+    throw new ConsolError("addon_not_found", `addon not found: ${attempt} (${String(cause?.message).split(`
+`)[0]})`, { cause });
   }
 }
-function missingBinary(attempt) {
-  return new ConsolError("binary_not_found", `binary not found: ${attempt}`, { stderrTail: attempt });
+var logSinks = new Set;
+var fanOut = (line) => {
+  for (const sink of logSinks)
+    sink(line);
+};
+function subscribe(addon, onLog, level) {
+  const sink = (line) => {
+    try {
+      onLog(line);
+    } catch {}
+  };
+  logSinks.add(sink);
+  addon.setLogSink(fanOut, level);
+  return () => {
+    if (logSinks.delete(sink) && logSinks.size === 0)
+      addon.setLogSink(null);
+  };
 }
-function resolveBinary(explicit) {
-  const exe = platformExe();
-  if (explicit) {
-    if (!isFile(explicit))
-      throw missingBinary(`explicit:${explicit}`);
-    return { path: explicit, attempts: [`explicit:${explicit}`] };
-  }
-  const fromEnv = process.env.CONSOL_BIN;
-  if (fromEnv) {
-    if (!isFile(fromEnv))
-      throw missingBinary(`CONSOL_BIN:${fromEnv}`);
-    return { path: fromEnv, attempts: [`CONSOL_BIN:${fromEnv}`] };
-  }
-  const spec = `@keb-org/consol-${process.platform}-${process.arch}/bin/${exe}`;
+function engineError(error) {
+  if (ConsolError.is(error))
+    return error;
+  const text = error instanceof Error ? error.message : String(error);
   try {
-    const sdkRequire = require;
-    return { path: sdkRequire.resolve(spec), attempts: [`package:${spec}`] };
-  } catch {
-    return { path: exe, attempts: [`package:${spec}`, `PATH:${exe}`] };
-  }
-}
-function childEnv(base = {}, extra = {}) {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    const name = process.platform === "win32" ? key.toUpperCase() : key;
-    if (value === undefined || name.startsWith("CONSOL_") || name === "RUST_LOG")
-      continue;
-    env[key] = value;
-  }
-  return { ...env, ...base, ...extra };
+    const { code, message, field } = JSON.parse(text);
+    if (typeof code === "string") {
+      return new ConsolError(code, typeof message === "string" ? message : code, {
+        field: typeof field === "string" ? field : undefined,
+        cause: error
+      });
+    }
+  } catch {}
+  return new ConsolError("internal", text, { cause: error });
 }
-function lastBytes(text) {
-  const bytes = Buffer.from(text, "utf8");
-  if (bytes.length <= STDERR_TAIL_BYTES)
-    return text;
-  let start = bytes.length - STDERR_TAIL_BYTES;
-  while ((bytes[start] & 192) === 128)
-    start++;
-  return bytes.subarray(start).toString("utf8");
+function race(work, label, ms, closed, user) {
+  const timer = ms > 0 ? AbortSignal.timeout(ms) : undefined;
+  const stop = anySignal([closed, user, timer].filter((s) => s !== undefined));
+  return new Promise((resolve, reject) => {
+    const onStop = () => reject(closed?.aborted ? new ConsolError("closed", "vault is closed") : user?.aborted ? new ConsolError("aborted", `${label} aborted`, { cause: user.reason }) : new ConsolError("timeout", `${label} timed out after ${ms}ms`));
+    stop.addEventListener("abort", onStop, { once: true });
+    work.then(resolve, reject).finally(() => stop.removeEventListener("abort", onStop));
+  });
 }
-var READY = 0;
 
-class StdioTransport {
-  opts;
-  attempts;
-  binary;
+class NativeTransport {
+  engine;
+  version;
   timeoutMs;
-  child = null;
-  reader = null;
-  generation = 0;
-  nextId = 1;
-  pending = new Map;
-  starting = null;
-  started = false;
-  closed = false;
+  unsubscribe;
+  closed = new AbortController;
   closing = null;
-  stderrTail = [];
-  stderrTailBytes = 0;
-  version = null;
-  constructor(opts) {
-    this.timeoutMs = deadline(opts.timeoutMs, DEFAULT_TIMEOUT_MS);
-    this.opts = opts;
-    const resolved = resolveBinary(opts.binaryPath);
-    this.binary = resolved.path;
-    this.attempts = resolved.attempts;
-  }
-  decoder = new import_node_string_decoder.StringDecoder("utf8");
-  stderrPartial = "";
-  onStderr(chunk) {
-    const lines = (this.stderrPartial + this.decoder.write(chunk)).split(/\r?\n/);
-    this.stderrPartial = lastBytes(lines.pop() ?? "");
-    for (const line of lines)
-      this.pushLine(line);
-  }
-  flushStderr() {
-    const rest = (this.stderrPartial + this.decoder.end()).trim();
-    this.stderrPartial = "";
-    this.decoder = new import_node_string_decoder.StringDecoder("utf8");
-    if (rest)
-      this.pushLine(rest);
-  }
-  pushLine(line) {
-    const text = lastBytes(line.trim().replace(/\x1b\[[0-9;]*[A-Za-z]/g, ""));
-    if (!text)
-      return;
-    this.stderrTail.push(text);
-    this.stderrTailBytes += Buffer.byteLength(text, "utf8");
-    while (this.stderrTailBytes > STDERR_TAIL_BYTES && this.stderrTail.length > 1) {
-      const dropped = this.stderrTail.shift();
-      this.stderrTailBytes -= Buffer.byteLength(dropped, "utf8");
-    }
-    try {
-      this.opts.onLog?.(text);
-    } catch {}
-  }
-  tailText() {
-    return this.stderrTail.join(`
-`);
-  }
-  updateRef() {
-    const child = this.child;
-    if (!child || child.exitCode !== null || child.signalCode !== null)
-      return;
-    try {
-      if (this.pending.size > 0 || this.starting !== null)
-        child.ref();
-      else
-        child.unref();
-    } catch {}
-  }
-  onDeath(error) {
-    const child = this.child;
-    this.child = null;
-    this.reader?.close();
-    this.reader = null;
+  constructor(engine, version, timeoutMs, unsubscribe) {
+    this.engine = engine;
+    this.version = version;
+    this.timeoutMs = timeoutMs;
+    this.unsubscribe = unsubscribe;
+  }
+  static async start(opts) {
+    const timeoutMs = deadline(opts.timeoutMs, DEFAULT_TIMEOUT_MS);
+    const addon = loadAddon(opts.addonPath);
+    const version = checkVersion(addon.version(), opts.sdkVersion);
+    const unsubscribe = opts.onLog ? subscribe(addon, opts.onLog, opts.logLevel) : () => {};
+    let opening;
+    let engine;
     try {
-      child?.kill();
-    } catch {}
-    const failure = this.closed ? new ConsolError("closed", "vault is closed", { cause: error }) : error;
-    for (const pending of this.pending.values())
-      pending.reject(failure);
-    this.pending.clear();
-    this.updateRef();
+      opening = addon.openEngine(JSON.stringify(opts.location), engineSettings(opts));
+      engine = await race(opening, "start", timeoutMs);
+    } catch (error) {
+      unsubscribe();
+      opening?.then((late) => late.close()).catch(() => {});
+      throw engineError(error);
+    }
+    const transport = new NativeTransport(engine, version, timeoutMs, unsubscribe);
+    const { boot } = opts;
+    if (boot) {
+      try {
+        const error = replyError(await transport.vaultOp(boot.create ? "create_vault" : "open_vault", boot.vault));
+        if (error)
+          throw error;
+      } catch (error) {
+        await transport.close().catch(() => {});
+        throw error;
+      }
+    }
+    return transport;
   }
   close() {
     this.closing ??= this.shutdown();
     return this.closing;
   }
   async shutdown() {
-    this.closed = true;
-    const child = this.child;
-    this.child = null;
-    this.reader?.close();
-    this.reader = null;
-    const failure = new ConsolError("closed", "vault is closed");
-    for (const pending of this.pending.values())
-      pending.reject(failure);
-    this.pending.clear();
-    if (!child)
-      return;
-    await new Promise((resolve) => {
-      if (!child.pid || child.exitCode !== null || child.signalCode !== null) {
-        resolve();
-        return;
-      }
-      const terminate = setTimeout(() => {
-        try {
-          child.kill();
-        } catch {}
-      }, EXIT_WAIT_MS);
-      const force = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {}
-      }, KILL_WAIT_MS);
-      child.once("close", () => {
-        clearTimeout(terminate);
-        clearTimeout(force);
-        resolve();
-      });
-      try {
-        child.stdin?.end();
-      } catch {
-        resolve();
-      }
-    });
-  }
-  async start() {
-    if (this.closed)
-      throw new ConsolError("closed", "vault is closed");
-    if (!this.starting && !this.child)
-      this.starting = this.spawn();
-    if (this.starting) {
-      try {
-        await this.starting;
-      } finally {
-        this.starting = null;
-        this.updateRef();
-      }
-    }
-    if (this.closed)
-      throw new ConsolError("closed", "vault is closed");
-  }
-  async spawn() {
-    const generation = ++this.generation;
-    const child = import_node_child_process.spawn(this.binary, ["stdio", ...this.opts.location], {
-      stdio: ["pipe", "pipe", "pipe"],
-      env: childEnv(engineEnv(this.opts), this.opts.env)
-    });
-    this.child = child;
-    for (const stream of [child.stdin, child.stdout, child.stderr])
-      stream?.unref?.();
-    this.updateRef();
-    child.stderr?.on("data", (chunk) => this.onStderr(chunk));
-    child.stderr?.on("error", () => {});
-    const dead = (reason, cause) => {
-      if (this.child !== child)
-        return;
-      this.flushStderr();
-      const tail = this.stderrTail.slice(-3).join(" | ");
-      this.onDeath(new ConsolError("server_exited", `${reason}${tail ? `: ${tail}` : ""}`, {
-        stderrTail: this.tailText() || undefined,
-        ...cause === undefined ? {} : { cause }
-      }));
-    };
-    child.once("error", (error) => {
-      if (error?.code === "ENOENT") {
-        if (this.child !== child)
-          return;
-        this.onDeath(new ConsolError("binary_not_found", `binary not found: ${this.binary}`, {
-          stderrTail: this.attempts.join(`
-`),
-          cause: error
-        }));
-      } else {
-        dead(`server failed to start: ${error.message}`, error);
-      }
-    });
-    child.once("exit", (code, signal) => {
-      dead(`server exited (${signal ?? code})`);
-    });
-    child.stdin?.on("error", () => {
-      dead("server stdin failed");
-    });
-    const reader = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
-    this.reader = reader;
-    reader.once("close", () => {
-      dead("server closed output");
-    });
-    reader.on("line", (line) => {
-      if (this.child === child && generation === this.generation)
-        this.onLine(line);
-    });
+    this.closed.abort();
+    this.unsubscribe();
     try {
-      checkVersion(await this.call("ready", READY, null, {}), this.opts.sdkVersion);
-      const boot = this.opts.boot;
-      if (boot) {
-        const op = boot.create && !this.started ? "create_vault" : "open_vault";
-        const reply = await this.call(op, this.nextId++, { op, vault: boot.vault }, {});
-        const error = replyError(reply);
-        if (error)
-          throw error;
-      }
-      this.started = true;
-      this.stderrTail = [];
-      this.stderrTailBytes = 0;
+      await this.engine.close();
     } catch (error) {
-      if (this.child === child) {
-        this.child = null;
-        this.reader?.close();
-        this.reader = null;
-        try {
-          child.kill();
-        } catch {}
-      }
-      throw error instanceof ConsolError ? error : new ConsolError("internal", String(error), { cause: error });
+      throw engineError(error);
     }
   }
-  onLine(line) {
-    if (!line.trim())
-      return;
-    let msg;
+  async send(frame, options) {
+    const { signal } = options;
+    if (this.closed.signal.aborted)
+      throw new ConsolError("closed", "vault is closed");
+    if (signal?.aborted)
+      throw new ConsolError("aborted", `${frame.op} aborted before dispatch`, { cause: signal.reason });
+    const ms = deadline(options.timeoutMs, this.timeoutMs);
+    let text;
     try {
-      msg = JSON.parse(line);
-    } catch {
-      this.onDeath(new ConsolError("server_exited", "invalid JSON from server", {
-        stderrTail: this.tailText() || undefined
-      }));
-      return;
-    }
-    const id = msg?.ready === true ? READY : msg?.id;
-    if (typeof id !== "number")
-      return;
-    const pending = this.pending.get(id);
-    if (!pending || pending.settled)
-      return;
-    this.pending.delete(id);
-    if (id === READY) {
-      pending.resolve(msg.version);
-    } else {
-      try {
-        this.version = checkVersion(msg.reply?.version, this.opts.sdkVersion);
-        pending.resolve(msg.reply);
-      } catch (error) {
-        pending.reject(error);
-      }
+      text = JSON.stringify(frame);
+    } catch (cause) {
+      throw new ConsolError("invalid_argument", `${frame.op}: body is not JSON`, { cause });
     }
-    this.updateRef();
-  }
-  call(label, id, frame, options) {
-    return new Promise((resolve, reject) => {
-      const signal = options.signal;
-      if (signal?.aborted) {
-        reject(new ConsolError("aborted", `${label} aborted before dispatch`, { cause: signal.reason }));
-        return;
-      }
-      let line = null;
-      let timeoutMs;
-      try {
-        timeoutMs = deadline(options.timeoutMs, this.timeoutMs);
-        line = frame ? JSON.stringify({ id, ...frame }) + `
-` : null;
-      } catch (error) {
-        reject(ConsolError.is(error) ? error : new ConsolError("invalid_argument", `${label}: body is not JSON`, { cause: error }));
-        return;
-      }
-      const input = this.child?.stdin;
-      if (line && !input?.writable) {
-        reject(new ConsolError(this.closed ? "closed" : "server_exited", "server is not running"));
-        return;
-      }
-      const pending = { resolve, reject, settled: false };
-      const done = (error, value) => {
-        if (pending.settled)
-          return;
-        pending.settled = true;
-        if (pending.timer !== undefined)
-          clearTimeout(pending.timer);
-        if (pending.onAbort && signal)
-          signal.removeEventListener("abort", pending.onAbort);
-        this.pending.delete(id);
-        if (error)
-          reject(error);
-        else
-          resolve(value);
-        this.updateRef();
-      };
-      pending.resolve = (value) => done(null, value);
-      pending.reject = (error) => done(error);
-      if (timeoutMs > 0) {
-        pending.timer = setTimeout(() => done(new ConsolError("timeout", `${label} timed out after ${timeoutMs}ms`)), timeoutMs);
-        pending.timer.unref?.();
-      }
-      if (signal) {
-        pending.onAbort = () => done(new ConsolError("aborted", `${label} aborted`, { cause: signal.reason }));
-        signal.addEventListener("abort", pending.onAbort, { once: true });
-      }
-      this.pending.set(id, pending);
-      this.updateRef();
-      if (line) {
-        input.write(line, (error) => {
-          if (error)
-            done(new ConsolError("server_exited", "server stdin failed", { cause: error }));
-        });
-      }
-    });
-  }
-  async send(frame, options) {
-    if (options.signal?.aborted) {
-      throw new ConsolError("aborted", `${frame.op} aborted before dispatch`, { cause: options.signal.reason });
+    try {
+      return JSON.parse(await race(this.engine.request(text), frame.op, ms, this.closed.signal, signal));
+    } catch (error) {
+      throw engineError(error);
     }
-    await this.start();
-    return await this.call(frame.op, this.nextId++, frame, options);
   }
   handle(body, ctx, options = {}) {
     return this.send({ op: "handle", ctx: { vaults: ctx.vaults, agent: ctx.agent ?? null }, body }, options);
@@ -624,7 +347,7 @@ class StdioTransport {
 }
 
 // src/vault.ts
-var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
 
 // src/types.ts
 function sliceUtf8(text, start, end) {
@@ -646,7 +369,7 @@ function sliceUtf8(text, start, end) {
 }
 
 // src/vault.ts
-var CLIENT_INFO = { name: "consol-js-client", version: "0.1.1" };
+var CLIENT_INFO = { name: "consol-js-client", version: "0.3.0" };
 var LOCAL = "default";
 function payload(tool, reply) {
   const error = replyError(reply, tool);
@@ -709,19 +432,13 @@ function required(options, fields) {
 }
 async function local(options, create) {
   required(options, ["path", "agent"]);
-  const path = options.path.startsWith("s3://") ? options.path : import_node_path.resolve(options.path);
-  const transport = new StdioTransport({
+  const path = options.path.startsWith("s3://") ? options.path : import_node_path2.resolve(options.path);
+  const transport = await NativeTransport.start({
     ...options,
-    location: ["--vault", path],
+    location: { vault: path },
     boot: { vault: LOCAL, create },
     sdkVersion: CLIENT_INFO.version
   });
-  try {
-    await transport.start();
-  } catch (error) {
-    await transport.close();
-    throw error;
-  }
   return construct(transport, LOCAL, options.agent);
 }
 function createVault(options) {
@@ -777,18 +494,11 @@ class Consol {
     if (vaultRoot === undefined === (vault === undefined)) {
       throw new ConsolError("invalid_argument", "give exactly one of vaultRoot or vault", { field: "vaultRoot" });
     }
-    const transport = new StdioTransport({
+    return new Consol(await NativeTransport.start({
       ...engine,
-      location: vaultRoot === undefined ? ["--vault", vault] : ["--vault-root", vaultRoot],
+      location: vaultRoot === undefined ? { vault } : { vaultRoot },
       sdkVersion: CLIENT_INFO.version
-    });
-    try {
-      await transport.start();
-    } catch (error) {
-      await transport.close();
-      throw error;
-    }
-    return new Consol(transport);
+    }));
   }
   async handle(body, ctx, options) {
     if (ctx === null || typeof ctx !== "object" || ctx.vaults !== null && !Array.isArray(ctx.vaults)) {

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};