@holon-run/uxc-daemon-client 0.12.3

package/dist/index.cjs

@@ -0,0 +1,283 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DaemonRpcError: () => DaemonRpcError,
+  UxcDaemonClient: () => UxcDaemonClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_net = __toESM(require("net"), 1);
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var JSONRPC_VERSION = "2.0";
+var DaemonRpcError = class extends Error {
+  constructor(message, code, method) {
+    super(message);
+    this.code = code;
+    this.method = method;
+    this.name = "DaemonRpcError";
+  }
+};
+var UxcDaemonClient = class {
+  socketPath;
+  binaryPath;
+  autoStart;
+  connectTimeoutMs;
+  requestTimeoutMs;
+  env;
+  ensureDaemonPromise;
+  constructor(options = {}) {
+    this.socketPath = options.socketPath ?? defaultSocketPath(options.env);
+    this.binaryPath = options.binaryPath ?? "uxc";
+    this.autoStart = options.autoStart ?? true;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? 2e3;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
+    this.env = { ...process.env, ...options.env };
+  }
+  async daemonStatus() {
+    return this.request("daemon.status");
+  }
+  async daemonSessions() {
+    return this.request("daemon.sessions");
+  }
+  async call(args) {
+    return this.request("runtime.invoke", {
+      request_id: requestId("call"),
+      endpoint: args.endpoint,
+      action: "execute",
+      operation_id: args.operation,
+      args: args.payload ?? null,
+      options: normalizeOptions(args.options)
+    });
+  }
+  async subscribeStart(args) {
+    return this.request("subscription.start", {
+      request_id: requestId("subscribe"),
+      endpoint: args.endpoint,
+      sink: args.sink ?? "memory:",
+      operation_id: args.operationId ?? null,
+      args: args.args ?? null,
+      resource_uri: args.resourceUri ?? null,
+      read_resource: args.readResource ?? false,
+      transport_hint: args.transportHint ?? null,
+      subprotocols: [],
+      initial_text_frames: [],
+      mode: args.mode ?? "stream",
+      poll_config: null,
+      ephemeral: args.ephemeral ?? (args.sink ?? "memory:") === "memory:",
+      options: normalizeOptions(args.options)
+    });
+  }
+  async subscribeList() {
+    return this.request("subscription.list");
+  }
+  async subscribeStatus(jobId) {
+    return this.request("subscription.status", { job_id: jobId });
+  }
+  async subscribeStop(jobId) {
+    return this.request("subscription.stop", { job_id: jobId });
+  }
+  async subscriptionEvents(args) {
+    return this.request("subscription.events", {
+      job_id: args.jobId,
+      after_seq: args.afterSeq ?? 0,
+      limit: args.limit ?? 100,
+      wait_ms: args.waitMs ?? 15e3
+    });
+  }
+  async *subscribeEvents(jobId, options = {}) {
+    let afterSeq = options.afterSeq ?? 0;
+    while (true) {
+      if (options.signal?.aborted) {
+        return;
+      }
+      const batch = await this.subscriptionEvents({
+        jobId,
+        afterSeq,
+        limit: options.limit,
+        waitMs: options.waitMs
+      });
+      for (const event of batch.events) {
+        afterSeq = event.seq;
+        yield event;
+      }
+      if (batch.status !== "running" && batch.events.length === 0) {
+        return;
+      }
+      if (batch.events.length === 0 && batch.status === "running") {
+        continue;
+      }
+      afterSeq = batch.next_after_seq;
+    }
+  }
+  async request(method, params) {
+    await this.ensureDaemon();
+    try {
+      return await this.requestOnce(method, params);
+    } catch (error) {
+      if (!this.autoStart || !isSocketError(error)) {
+        throw error;
+      }
+      await this.ensureDaemon(true);
+      return this.requestOnce(method, params);
+    }
+  }
+  async ensureDaemon(force = false) {
+    if (!this.autoStart) {
+      return;
+    }
+    if (!this.ensureDaemonPromise || force) {
+      this.ensureDaemonPromise = execFileAsync(this.binaryPath, ["daemon", "start"], {
+        env: this.env,
+        timeout: this.requestTimeoutMs
+      }).then(() => void 0);
+    }
+    await this.ensureDaemonPromise;
+  }
+  async requestOnce(method, params) {
+    const socket = import_node_net.default.createConnection(this.socketPath);
+    const response = await new Promise((resolve, reject) => {
+      let timer;
+      let buffer = Buffer.alloc(0);
+      let resolved = false;
+      const cleanup = () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        socket.removeAllListeners();
+        socket.end();
+        socket.destroy();
+      };
+      const fail = (error) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        cleanup();
+        reject(error);
+      };
+      timer = setTimeout(() => fail(new Error(`Timed out waiting for ${method}`)), this.requestTimeoutMs);
+      socket.once("error", fail);
+      socket.once("connect", () => {
+        const body = Buffer.from(
+          JSON.stringify({
+            jsonrpc: JSONRPC_VERSION,
+            id: 1,
+            method,
+            params: params ?? null
+          })
+        );
+        const header = Buffer.from(`Content-Length: ${body.length}\r
+\r
+`);
+        socket.write(Buffer.concat([header, body]));
+      });
+      socket.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        const parsed = tryParseFrame(buffer);
+        if (!parsed) {
+          return;
+        }
+        buffer = parsed.remaining;
+        resolved = true;
+        cleanup();
+        if (parsed.message.error) {
+          reject(
+            new DaemonRpcError(
+              parsed.message.error.message,
+              parsed.message.error.code,
+              method
+            )
+          );
+          return;
+        }
+        resolve(parsed.message.result);
+      });
+    });
+    return response;
+  }
+};
+function normalizeOptions(options) {
+  return {
+    inject_env: [],
+    no_cache: false,
+    refresh_schema: false,
+    daemon_exclusive: [],
+    ...options
+  };
+}
+function defaultSocketPath(env) {
+  if (env?.XDG_RUNTIME_DIR) {
+    return (0, import_node_path.join)(env.XDG_RUNTIME_DIR, "uxc", "uxc.sock");
+  }
+  if (env?.HOME) {
+    return (0, import_node_path.join)(env.HOME, ".uxc", "daemon", "uxc.sock");
+  }
+  const label = (0, import_node_crypto.createHash)("sha1").update(env?.USER ?? env?.USERNAME ?? "user").digest("hex").slice(0, 8);
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), `uxc-${label}`, "daemon", "uxc.sock");
+}
+function requestId(prefix) {
+  return `${prefix}-${process.pid}-${Date.now()}`;
+}
+function isSocketError(error) {
+  return error instanceof Error && /connect|socket|ENOENT|ECONNREFUSED/.test(error.message);
+}
+function tryParseFrame(buffer) {
+  const marker = buffer.indexOf("\r\n\r\n");
+  if (marker === -1) {
+    return null;
+  }
+  const header = buffer.subarray(0, marker).toString("utf8");
+  const match = header.match(/Content-Length:\s*(\d+)/i);
+  if (!match) {
+    throw new Error("Missing Content-Length header");
+  }
+  const bodyLength = Number(match[1]);
+  const bodyStart = marker + 4;
+  if (buffer.length < bodyStart + bodyLength) {
+    return null;
+  }
+  const body = buffer.subarray(bodyStart, bodyStart + bodyLength).toString("utf8");
+  const message = JSON.parse(body);
+  return {
+    message,
+    remaining: Buffer.from(buffer.subarray(bodyStart + bodyLength))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DaemonRpcError,
+  UxcDaemonClient
+});

package/dist/index.d.cts

@@ -0,0 +1,150 @@
+interface RuntimeInvokeOptions {
+    auth?: string;
+    inject_env?: unknown[];
+    no_cache?: boolean;
+    cache_ttl?: number;
+    refresh_schema?: boolean;
+    schema_url?: string;
+    link_name?: string;
+    schema_mapping_file?: string;
+    daemon_exclusive?: string[];
+    daemon_idle_ttl?: number;
+}
+interface RuntimeInvokeResponse {
+    protocol: string;
+    endpoint: string;
+    kind: string;
+    operation?: string | null;
+    data: unknown;
+    duration_ms?: number | null;
+    meta: Record<string, unknown>;
+}
+interface SubscriptionEventEnvelope {
+    version: string;
+    job_id: string;
+    seq: number;
+    timestamp_unix: number;
+    protocol: string;
+    source_kind: string;
+    event_kind: string;
+    data?: unknown;
+    meta?: unknown;
+}
+interface SubscribeStartResponse {
+    job_id: string;
+    mode: "stream" | "poll";
+    protocol: string;
+    endpoint: string;
+    sink: string;
+    resource_uri?: string | null;
+    status: string;
+}
+interface SubscribeStopResponse {
+    job_id: string;
+    stopped: boolean;
+}
+interface SubscriptionJobView {
+    job_id: string;
+    mode: "stream" | "poll";
+    endpoint: string;
+    protocol: string;
+    sink: string;
+    resource_uri?: string | null;
+    status: string;
+    durable: boolean;
+    auto_resume: boolean;
+    resume_strategy: string;
+    created_at_unix: number;
+    started_at_unix?: number | null;
+    stopped_at_unix?: number | null;
+    last_event_at_unix?: number | null;
+    last_error?: string | null;
+    restart_count: number;
+    last_resume_at_unix?: number | null;
+    last_resume_error?: string | null;
+    reconnect_count: number;
+    written_events: number;
+}
+interface DaemonStatus {
+    running: boolean;
+    pid?: number | null;
+    socket: string;
+    version?: string | null;
+    started_at_unix?: number | null;
+    request_count: number;
+    mcp_stdio_sessions: number;
+    mcp_http_sessions: number;
+    mcp_reuse_hits: number;
+    log_file?: string | null;
+}
+interface SubscriptionEventsResponse {
+    job_id: string;
+    status: string;
+    events: SubscriptionEventEnvelope[];
+    next_after_seq: number;
+    has_more: boolean;
+}
+interface UxcDaemonClientOptions {
+    socketPath?: string;
+    binaryPath?: string;
+    autoStart?: boolean;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface SubscribeStartArgs {
+    endpoint: string;
+    resourceUri?: string;
+    operationId?: string;
+    args?: Record<string, unknown>;
+    mode?: "stream" | "poll";
+    options?: RuntimeInvokeOptions;
+    sink?: `file:${string}` | "memory:";
+    ephemeral?: boolean;
+    readResource?: boolean;
+    transportHint?: "websocket" | "discord_gateway" | "slack_socket_mode" | "feishu_long_connection";
+}
+declare class DaemonRpcError extends Error {
+    readonly code: number;
+    readonly method: string;
+    constructor(message: string, code: number, method: string);
+}
+declare class UxcDaemonClient {
+    private readonly socketPath;
+    private readonly binaryPath;
+    private readonly autoStart;
+    private readonly connectTimeoutMs;
+    private readonly requestTimeoutMs;
+    private readonly env;
+    private ensureDaemonPromise?;
+    constructor(options?: UxcDaemonClientOptions);
+    daemonStatus(): Promise<DaemonStatus>;
+    daemonSessions(): Promise<unknown[]>;
+    call(args: {
+        endpoint: string;
+        operation: string;
+        payload?: Record<string, unknown>;
+        options?: RuntimeInvokeOptions;
+    }): Promise<RuntimeInvokeResponse>;
+    subscribeStart(args: SubscribeStartArgs): Promise<SubscribeStartResponse>;
+    subscribeList(): Promise<SubscriptionJobView[]>;
+    subscribeStatus(jobId: string): Promise<SubscriptionJobView>;
+    subscribeStop(jobId: string): Promise<SubscribeStopResponse>;
+    subscriptionEvents(args: {
+        jobId: string;
+        afterSeq?: number;
+        limit?: number;
+        waitMs?: number;
+    }): Promise<SubscriptionEventsResponse>;
+    subscribeEvents(jobId: string, options?: {
+        afterSeq?: number;
+        limit?: number;
+        waitMs?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<SubscriptionEventEnvelope>;
+    request<T>(method: string, params?: unknown): Promise<T>;
+    private ensureDaemon;
+    private requestOnce;
+}
+
+export { DaemonRpcError, type DaemonStatus, type RuntimeInvokeOptions, type RuntimeInvokeResponse, type SubscribeStartArgs, type SubscribeStartResponse, type SubscribeStopResponse, type SubscriptionEventEnvelope, type SubscriptionEventsResponse, type SubscriptionJobView, UxcDaemonClient, type UxcDaemonClientOptions };

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+interface RuntimeInvokeOptions {
+    auth?: string;
+    inject_env?: unknown[];
+    no_cache?: boolean;
+    cache_ttl?: number;
+    refresh_schema?: boolean;
+    schema_url?: string;
+    link_name?: string;
+    schema_mapping_file?: string;
+    daemon_exclusive?: string[];
+    daemon_idle_ttl?: number;
+}
+interface RuntimeInvokeResponse {
+    protocol: string;
+    endpoint: string;
+    kind: string;
+    operation?: string | null;
+    data: unknown;
+    duration_ms?: number | null;
+    meta: Record<string, unknown>;
+}
+interface SubscriptionEventEnvelope {
+    version: string;
+    job_id: string;
+    seq: number;
+    timestamp_unix: number;
+    protocol: string;
+    source_kind: string;
+    event_kind: string;
+    data?: unknown;
+    meta?: unknown;
+}
+interface SubscribeStartResponse {
+    job_id: string;
+    mode: "stream" | "poll";
+    protocol: string;
+    endpoint: string;
+    sink: string;
+    resource_uri?: string | null;
+    status: string;
+}
+interface SubscribeStopResponse {
+    job_id: string;
+    stopped: boolean;
+}
+interface SubscriptionJobView {
+    job_id: string;
+    mode: "stream" | "poll";
+    endpoint: string;
+    protocol: string;
+    sink: string;
+    resource_uri?: string | null;
+    status: string;
+    durable: boolean;
+    auto_resume: boolean;
+    resume_strategy: string;
+    created_at_unix: number;
+    started_at_unix?: number | null;
+    stopped_at_unix?: number | null;
+    last_event_at_unix?: number | null;
+    last_error?: string | null;
+    restart_count: number;
+    last_resume_at_unix?: number | null;
+    last_resume_error?: string | null;
+    reconnect_count: number;
+    written_events: number;
+}
+interface DaemonStatus {
+    running: boolean;
+    pid?: number | null;
+    socket: string;
+    version?: string | null;
+    started_at_unix?: number | null;
+    request_count: number;
+    mcp_stdio_sessions: number;
+    mcp_http_sessions: number;
+    mcp_reuse_hits: number;
+    log_file?: string | null;
+}
+interface SubscriptionEventsResponse {
+    job_id: string;
+    status: string;
+    events: SubscriptionEventEnvelope[];
+    next_after_seq: number;
+    has_more: boolean;
+}
+interface UxcDaemonClientOptions {
+    socketPath?: string;
+    binaryPath?: string;
+    autoStart?: boolean;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}
+interface SubscribeStartArgs {
+    endpoint: string;
+    resourceUri?: string;
+    operationId?: string;
+    args?: Record<string, unknown>;
+    mode?: "stream" | "poll";
+    options?: RuntimeInvokeOptions;
+    sink?: `file:${string}` | "memory:";
+    ephemeral?: boolean;
+    readResource?: boolean;
+    transportHint?: "websocket" | "discord_gateway" | "slack_socket_mode" | "feishu_long_connection";
+}
+declare class DaemonRpcError extends Error {
+    readonly code: number;
+    readonly method: string;
+    constructor(message: string, code: number, method: string);
+}
+declare class UxcDaemonClient {
+    private readonly socketPath;
+    private readonly binaryPath;
+    private readonly autoStart;
+    private readonly connectTimeoutMs;
+    private readonly requestTimeoutMs;
+    private readonly env;
+    private ensureDaemonPromise?;
+    constructor(options?: UxcDaemonClientOptions);
+    daemonStatus(): Promise<DaemonStatus>;
+    daemonSessions(): Promise<unknown[]>;
+    call(args: {
+        endpoint: string;
+        operation: string;
+        payload?: Record<string, unknown>;
+        options?: RuntimeInvokeOptions;
+    }): Promise<RuntimeInvokeResponse>;
+    subscribeStart(args: SubscribeStartArgs): Promise<SubscribeStartResponse>;
+    subscribeList(): Promise<SubscriptionJobView[]>;
+    subscribeStatus(jobId: string): Promise<SubscriptionJobView>;
+    subscribeStop(jobId: string): Promise<SubscribeStopResponse>;
+    subscriptionEvents(args: {
+        jobId: string;
+        afterSeq?: number;
+        limit?: number;
+        waitMs?: number;
+    }): Promise<SubscriptionEventsResponse>;
+    subscribeEvents(jobId: string, options?: {
+        afterSeq?: number;
+        limit?: number;
+        waitMs?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<SubscriptionEventEnvelope>;
+    request<T>(method: string, params?: unknown): Promise<T>;
+    private ensureDaemon;
+    private requestOnce;
+}
+
+export { DaemonRpcError, type DaemonStatus, type RuntimeInvokeOptions, type RuntimeInvokeResponse, type SubscribeStartArgs, type SubscribeStartResponse, type SubscribeStopResponse, type SubscriptionEventEnvelope, type SubscriptionEventsResponse, type SubscriptionJobView, UxcDaemonClient, type UxcDaemonClientOptions };

package/dist/index.js

@@ -0,0 +1,247 @@
+// src/index.ts
+import { execFile } from "child_process";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { join } from "path";
+import net from "net";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var JSONRPC_VERSION = "2.0";
+var DaemonRpcError = class extends Error {
+  constructor(message, code, method) {
+    super(message);
+    this.code = code;
+    this.method = method;
+    this.name = "DaemonRpcError";
+  }
+};
+var UxcDaemonClient = class {
+  socketPath;
+  binaryPath;
+  autoStart;
+  connectTimeoutMs;
+  requestTimeoutMs;
+  env;
+  ensureDaemonPromise;
+  constructor(options = {}) {
+    this.socketPath = options.socketPath ?? defaultSocketPath(options.env);
+    this.binaryPath = options.binaryPath ?? "uxc";
+    this.autoStart = options.autoStart ?? true;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? 2e3;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
+    this.env = { ...process.env, ...options.env };
+  }
+  async daemonStatus() {
+    return this.request("daemon.status");
+  }
+  async daemonSessions() {
+    return this.request("daemon.sessions");
+  }
+  async call(args) {
+    return this.request("runtime.invoke", {
+      request_id: requestId("call"),
+      endpoint: args.endpoint,
+      action: "execute",
+      operation_id: args.operation,
+      args: args.payload ?? null,
+      options: normalizeOptions(args.options)
+    });
+  }
+  async subscribeStart(args) {
+    return this.request("subscription.start", {
+      request_id: requestId("subscribe"),
+      endpoint: args.endpoint,
+      sink: args.sink ?? "memory:",
+      operation_id: args.operationId ?? null,
+      args: args.args ?? null,
+      resource_uri: args.resourceUri ?? null,
+      read_resource: args.readResource ?? false,
+      transport_hint: args.transportHint ?? null,
+      subprotocols: [],
+      initial_text_frames: [],
+      mode: args.mode ?? "stream",
+      poll_config: null,
+      ephemeral: args.ephemeral ?? (args.sink ?? "memory:") === "memory:",
+      options: normalizeOptions(args.options)
+    });
+  }
+  async subscribeList() {
+    return this.request("subscription.list");
+  }
+  async subscribeStatus(jobId) {
+    return this.request("subscription.status", { job_id: jobId });
+  }
+  async subscribeStop(jobId) {
+    return this.request("subscription.stop", { job_id: jobId });
+  }
+  async subscriptionEvents(args) {
+    return this.request("subscription.events", {
+      job_id: args.jobId,
+      after_seq: args.afterSeq ?? 0,
+      limit: args.limit ?? 100,
+      wait_ms: args.waitMs ?? 15e3
+    });
+  }
+  async *subscribeEvents(jobId, options = {}) {
+    let afterSeq = options.afterSeq ?? 0;
+    while (true) {
+      if (options.signal?.aborted) {
+        return;
+      }
+      const batch = await this.subscriptionEvents({
+        jobId,
+        afterSeq,
+        limit: options.limit,
+        waitMs: options.waitMs
+      });
+      for (const event of batch.events) {
+        afterSeq = event.seq;
+        yield event;
+      }
+      if (batch.status !== "running" && batch.events.length === 0) {
+        return;
+      }
+      if (batch.events.length === 0 && batch.status === "running") {
+        continue;
+      }
+      afterSeq = batch.next_after_seq;
+    }
+  }
+  async request(method, params) {
+    await this.ensureDaemon();
+    try {
+      return await this.requestOnce(method, params);
+    } catch (error) {
+      if (!this.autoStart || !isSocketError(error)) {
+        throw error;
+      }
+      await this.ensureDaemon(true);
+      return this.requestOnce(method, params);
+    }
+  }
+  async ensureDaemon(force = false) {
+    if (!this.autoStart) {
+      return;
+    }
+    if (!this.ensureDaemonPromise || force) {
+      this.ensureDaemonPromise = execFileAsync(this.binaryPath, ["daemon", "start"], {
+        env: this.env,
+        timeout: this.requestTimeoutMs
+      }).then(() => void 0);
+    }
+    await this.ensureDaemonPromise;
+  }
+  async requestOnce(method, params) {
+    const socket = net.createConnection(this.socketPath);
+    const response = await new Promise((resolve, reject) => {
+      let timer;
+      let buffer = Buffer.alloc(0);
+      let resolved = false;
+      const cleanup = () => {
+        if (timer) {
+          clearTimeout(timer);
+        }
+        socket.removeAllListeners();
+        socket.end();
+        socket.destroy();
+      };
+      const fail = (error) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        cleanup();
+        reject(error);
+      };
+      timer = setTimeout(() => fail(new Error(`Timed out waiting for ${method}`)), this.requestTimeoutMs);
+      socket.once("error", fail);
+      socket.once("connect", () => {
+        const body = Buffer.from(
+          JSON.stringify({
+            jsonrpc: JSONRPC_VERSION,
+            id: 1,
+            method,
+            params: params ?? null
+          })
+        );
+        const header = Buffer.from(`Content-Length: ${body.length}\r
+\r
+`);
+        socket.write(Buffer.concat([header, body]));
+      });
+      socket.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        const parsed = tryParseFrame(buffer);
+        if (!parsed) {
+          return;
+        }
+        buffer = parsed.remaining;
+        resolved = true;
+        cleanup();
+        if (parsed.message.error) {
+          reject(
+            new DaemonRpcError(
+              parsed.message.error.message,
+              parsed.message.error.code,
+              method
+            )
+          );
+          return;
+        }
+        resolve(parsed.message.result);
+      });
+    });
+    return response;
+  }
+};
+function normalizeOptions(options) {
+  return {
+    inject_env: [],
+    no_cache: false,
+    refresh_schema: false,
+    daemon_exclusive: [],
+    ...options
+  };
+}
+function defaultSocketPath(env) {
+  if (env?.XDG_RUNTIME_DIR) {
+    return join(env.XDG_RUNTIME_DIR, "uxc", "uxc.sock");
+  }
+  if (env?.HOME) {
+    return join(env.HOME, ".uxc", "daemon", "uxc.sock");
+  }
+  const label = createHash("sha1").update(env?.USER ?? env?.USERNAME ?? "user").digest("hex").slice(0, 8);
+  return join(tmpdir(), `uxc-${label}`, "daemon", "uxc.sock");
+}
+function requestId(prefix) {
+  return `${prefix}-${process.pid}-${Date.now()}`;
+}
+function isSocketError(error) {
+  return error instanceof Error && /connect|socket|ENOENT|ECONNREFUSED/.test(error.message);
+}
+function tryParseFrame(buffer) {
+  const marker = buffer.indexOf("\r\n\r\n");
+  if (marker === -1) {
+    return null;
+  }
+  const header = buffer.subarray(0, marker).toString("utf8");
+  const match = header.match(/Content-Length:\s*(\d+)/i);
+  if (!match) {
+    throw new Error("Missing Content-Length header");
+  }
+  const bodyLength = Number(match[1]);
+  const bodyStart = marker + 4;
+  if (buffer.length < bodyStart + bodyLength) {
+    return null;
+  }
+  const body = buffer.subarray(bodyStart, bodyStart + bodyLength).toString("utf8");
+  const message = JSON.parse(body);
+  return {
+    message,
+    remaining: Buffer.from(buffer.subarray(bodyStart + bodyLength))
+  };
+}
+export {
+  DaemonRpcError,
+  UxcDaemonClient
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@holon-run/uxc-daemon-client",
+  "version": "0.12.3",
+  "description": "Thin Node.js client for UXC daemon-backed operations",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/holon-run/uxc.git",
+    "directory": "packages/uxc-daemon-client"
+  },
+  "homepage": "https://github.com/holon-run/uxc",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.0",
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4",
+    "ws": "^8.18.3"
+  }
+}