@ganglion/xacpx 0.16.0 → 0.17.0-beta.1

package/dist/cli.js

@@ -4727,7 +4727,13 @@ function parseConfig(raw, options = {}) {
     workspaces,
     orchestration: orchestrationConfig,
     later: laterConfig,
-    ...language ? { language } : {}
+    ...language ? { language } : {},
+    ...raw.terminal && typeof raw.terminal === "object" ? {
+      terminal: {
+        enabled: raw.terminal.enabled === true,
+        ...typeof raw.terminal.idleTimeoutSeconds === "number" ? { idleTimeoutSeconds: raw.terminal.idleTimeoutSeconds } : {}
+      }
+    } : {}
   };
 }
 function parsePluginConfig(raw, index) {
@@ -25571,6 +25577,15 @@ var init_console_agent = __esm(() => {
   init_i18n();
 });
 
+// src/config/types.ts
+function terminalEnabled(config4) {
+  return config4.terminal?.enabled === true;
+}
+function terminalIdleTimeoutSeconds(config4) {
+  const v = config4.terminal?.idleTimeoutSeconds;
+  return typeof v === "number" && v > 0 ? v : 900;
+}
+
 // src/orchestration/orchestration-server.ts
 import { chmod as chmod4, rm as rm8 } from "node:fs/promises";
 import { createServer } from "node:net";
@@ -33874,6 +33889,7 @@ var init_workspace_fs = __esm(() => {
 
 // src/control/control-service.ts
 import path15 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 class ControlService {
   deps;
@@ -34041,12 +34057,23 @@ class ControlService {
     return task;
   }
   inFlight = new Map;
+  queues = new Map;
+  draining = new Set;
+  emitQueueUpdated(chatKey, sessionAlias) {
+    const items = (this.queues.get(turnKey(chatKey, sessionAlias)) ?? []).map((q) => ({
+      id: q.id,
+      textPreview: q.text.length > QUEUE_PREVIEW_MAX ? q.text.slice(0, QUEUE_PREVIEW_MAX) : q.text,
+      enqueuedAt: q.enqueuedAt
+    }));
+    this.deps.events.emit({ type: "queue-updated", chatKey, sessionAlias, items });
+  }
   async prompt(input) {
     return this.executeTurn({
       chatKey: input.chatKey,
       sessionAlias: input.sessionAlias,
       text: input.text,
       senderId: input.senderId,
+      queueable: true,
       ...input.isOwner !== undefined ? { isOwner: input.isOwner } : {},
       ...input.accountId !== undefined ? { accountId: input.accountId } : {},
       ...input.media !== undefined ? { media: input.media } : {}
@@ -34066,14 +34093,34 @@ class ControlService {
   }
   async executeTurn(params) {
     const key = turnKey(params.chatKey, params.sessionAlias);
-    const existing = this.inFlight.get(key);
-    if (existing) {
-      if (!existing.controller.signal.aborted) {
+    if (!params.drained) {
+      const existing = this.inFlight.get(key);
+      const busy = this.draining.has(key) || existing !== undefined && !existing.controller.signal.aborted;
+      if (busy) {
+        if (params.queueable) {
+          const id = randomUUID3();
+          const item = {
+            id,
+            text: params.text,
+            enqueuedAt: new Date().toISOString(),
+            senderId: params.senderId,
+            ...params.isOwner !== undefined ? { isOwner: params.isOwner } : {},
+            ...params.accountId !== undefined ? { accountId: params.accountId } : {},
+            ...params.media !== undefined ? { media: params.media } : {}
+          };
+          const q = this.queues.get(key) ?? [];
+          q.push(item);
+          this.queues.set(key, q);
+          this.emitQueueUpdated(params.chatKey, params.sessionAlias);
+          return { ok: true, queued: true, queueItemId: id };
+        }
         return { ok: false, errorMessage: "turn-already-running" };
       }
-      await raceWithTimeout(existing.settled, CANCEL_DRAIN_TIMEOUT_MS);
-      if (this.inFlight.has(key)) {
-        return { ok: false, errorMessage: "turn-already-running" };
+      if (existing) {
+        await raceWithTimeout(existing.settled, CANCEL_DRAIN_TIMEOUT_MS);
+        if (this.inFlight.has(key)) {
+          return { ok: false, errorMessage: "turn-already-running" };
+        }
       }
     }
     const controller = new AbortController;
@@ -34088,6 +34135,9 @@ class ControlService {
       resolveSettled = resolve4;
     });
     this.inFlight.set(key, { controller, settled });
+    if (params.drained) {
+      this.draining.delete(key);
+    }
     let internalAlias;
     let wasArchived = false;
     let priorTransportSession;
@@ -34100,8 +34150,8 @@ class ControlService {
     try {
       await this.deps.sessions.useSession(params.chatKey, params.sessionAlias);
     } catch (error2) {
-      this.inFlight.delete(key);
       resolveSettled();
+      this.advanceQueue(key, params.chatKey, params.sessionAlias);
       return { ok: false, errorMessage: toErrorMessage(error2) };
     }
     if (wasArchived) {
@@ -34112,7 +34162,8 @@ class ControlService {
       chatKey: params.chatKey,
       sessionAlias: params.sessionAlias,
       ...params.turnStarted?.prompt ? { prompt: params.turnStarted.prompt } : {},
-      ...params.turnStarted?.scheduled ? { scheduled: params.turnStarted.scheduled } : {}
+      ...params.turnStarted?.scheduled ? { scheduled: params.turnStarted.scheduled } : {},
+      ...params.turnStarted?.queueItemId ? { queueItemId: params.turnStarted.queueItemId } : {}
     });
     let streamMode = false;
     try {
@@ -34236,8 +34287,9 @@ ${chunk}` : chunk
       });
       return { ok: false, errorMessage };
     } finally {
-      this.inFlight.delete(key);
-      resolveSettled();
+      if ((this.queues.get(key)?.length ?? 0) > 0) {
+        this.draining.add(key);
+      }
       if (internalAlias && priorTransportSession) {
         try {
           const after = await this.deps.sessions.getSession(internalAlias);
@@ -34246,6 +34298,33 @@ ${chunk}` : chunk
           }
         } catch {}
       }
+      resolveSettled();
+      this.advanceQueue(key, params.chatKey, params.sessionAlias);
+    }
+  }
+  advanceQueue(key, chatKey, sessionAlias) {
+    const q = this.queues.get(key);
+    const next = q?.shift();
+    if (q && q.length === 0)
+      this.queues.delete(key);
+    if (next) {
+      this.draining.add(key);
+      this.emitQueueUpdated(chatKey, sessionAlias);
+      this.executeTurn({
+        chatKey,
+        sessionAlias,
+        text: next.text,
+        senderId: next.senderId,
+        queueable: true,
+        drained: true,
+        ...next.isOwner !== undefined ? { isOwner: next.isOwner } : {},
+        ...next.accountId !== undefined ? { accountId: next.accountId } : {},
+        ...next.media !== undefined ? { media: next.media } : {},
+        turnStarted: { queueItemId: next.id }
+      });
+    } else {
+      this.draining.delete(key);
+      this.inFlight.delete(key);
     }
   }
   cancelTurn(chatKey, sessionAlias) {
@@ -34256,6 +34335,20 @@ ${chunk}` : chunk
     entry.controller.abort();
     return true;
   }
+  cancelQueuedItem(chatKey, sessionAlias, itemId) {
+    const key = turnKey(chatKey, sessionAlias);
+    const q = this.queues.get(key);
+    if (!q)
+      return { cancelled: false };
+    const i = q.findIndex((x) => x.id === itemId);
+    if (i < 0)
+      return { cancelled: false };
+    q.splice(i, 1);
+    if (q.length === 0)
+      this.queues.delete(key);
+    this.emitQueueUpdated(chatKey, sessionAlias);
+    return { cancelled: true };
+  }
   async executeCommand(input) {
     const chunks = [];
     const response = await this.deps.agent.chat({
@@ -34273,6 +34366,23 @@ ${chunk}` : chunk
     return chunks.join(`
 `);
   }
+  async createTerminal(chatKey, sessionAlias, cols, rows) {
+    if (!this.deps.terminalEnabled())
+      throw new Error("terminal-disabled");
+    const session3 = await this.resolveControlSession(chatKey, sessionAlias);
+    if (!session3)
+      throw new Error("session-not-found");
+    return this.deps.terminal.create({ cwd: session3.cwd, cols, rows });
+  }
+  writeTerminal(terminalId, data) {
+    this.deps.terminal.write(terminalId, data);
+  }
+  resizeTerminal(terminalId, cols, rows) {
+    this.deps.terminal.resize(terminalId, cols, rows);
+  }
+  closeTerminal(terminalId) {
+    this.deps.terminal.close(terminalId);
+  }
 }
 async function raceWithTimeout(promise2, ms) {
   let timer;
@@ -34300,13 +34410,140 @@ function buildControlMetadata(senderId, isOwner) {
     ...isOwner === undefined ? {} : { isOwner }
   };
 }
-var CANCEL_DRAIN_TIMEOUT_MS = 5000;
+var CANCEL_DRAIN_TIMEOUT_MS = 5000, QUEUE_PREVIEW_MAX = 120;
 var init_control_service = __esm(() => {
   init_channel_scope();
   init_native_session_history();
   init_workspace_fs();
 });
 
+// src/control/terminal-service.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { createRequire as createRequire6 } from "node:module";
+import { spawn as spawnPty2 } from "node-pty";
+function scrubEnv() {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === undefined)
+      continue;
+    if (SENSITIVE_ENV_KEYS.includes(k) || k.startsWith("XACPX_"))
+      continue;
+    out[k] = v;
+  }
+  out.TERM = "xterm-256color";
+  out.LANG = out.LANG ?? "en_US.UTF-8";
+  return out;
+}
+function defaultShell(platform) {
+  if (process.env.SHELL)
+    return process.env.SHELL;
+  return platform === "darwin" ? "/bin/zsh" : "/bin/bash";
+}
+function realPtySpawn(file, args, opts) {
+  const helperPath = resolveNodePtyHelperPath(require5.resolve("node-pty/package.json"), process.platform, process.arch);
+  ensureNodePtyHelperExecutable(helperPath);
+  return spawnPty2(file, args, opts);
+}
+function createTerminalService(deps) {
+  const spawn11 = deps.spawn ?? realPtySpawn;
+  const platform = deps.platform ?? process.platform;
+  const sessions = new Map;
+  const setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimer = deps.clearTimer ?? ((id) => clearTimeout(id));
+  const resetIdle = (terminalId) => {
+    const s = sessions.get(terminalId);
+    if (!s)
+      return;
+    if (s.idleTimer)
+      clearTimer(s.idleTimer);
+    const ms = deps.idleTimeoutSeconds() * 1000;
+    s.idleTimer = setTimer(() => {
+      try {
+        s.handle.kill();
+      } catch {}
+    }, ms);
+    const t2 = s.idleTimer;
+    if (typeof t2.unref === "function")
+      t2.unref();
+  };
+  return {
+    create({ cwd, cols, rows }) {
+      if (platform === "win32")
+        throw new Error("terminal-unsupported-platform");
+      const terminalId = randomUUID4();
+      const handle = spawn11(defaultShell(platform), [], { name: "xterm-256color", cols, rows, cwd, env: scrubEnv() });
+      const session3 = { handle, seq: 0, idleTimer: null };
+      sessions.set(terminalId, session3);
+      handle.onData((data) => {
+        deps.events.emit({ type: "terminal-output", terminalId, seq: session3.seq++, data });
+      });
+      handle.onExit(({ exitCode }) => {
+        if (session3.idleTimer)
+          clearTimer(session3.idleTimer);
+        sessions.delete(terminalId);
+        deps.events.emit({ type: "terminal-exit", terminalId, code: exitCode });
+      });
+      resetIdle(terminalId);
+      return { terminalId };
+    },
+    write(terminalId, data) {
+      const s = sessions.get(terminalId);
+      if (!s)
+        return;
+      try {
+        s.handle.write(data);
+      } catch {}
+      resetIdle(terminalId);
+    },
+    resize(terminalId, cols, rows) {
+      const s = sessions.get(terminalId);
+      if (!s)
+        return;
+      try {
+        s.handle.resize(cols, rows);
+      } catch {}
+      resetIdle(terminalId);
+    },
+    close(terminalId) {
+      const s = sessions.get(terminalId);
+      if (!s)
+        return;
+      try {
+        s.handle.kill();
+      } catch {}
+    },
+    disposeAll() {
+      for (const s of sessions.values()) {
+        if (s.idleTimer)
+          clearTimer(s.idleTimer);
+        try {
+          s.handle.kill();
+        } catch {}
+      }
+      sessions.clear();
+    }
+  };
+}
+var require5, SENSITIVE_ENV_KEYS;
+var init_terminal_service = __esm(() => {
+  init_node_pty_helper();
+  require5 = createRequire6(import.meta.url);
+  SENSITIVE_ENV_KEYS = [
+    "ANTHROPIC_API_KEY",
+    "OPENAI_API_KEY",
+    "OPENROUTER_API_KEY",
+    "GEMINI_API_KEY",
+    "GOOGLE_API_KEY",
+    "DEEPSEEK_API_KEY",
+    "GROQ_API_KEY",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "GH_TOKEN",
+    "GITHUB_TOKEN",
+    "NPM_TOKEN"
+  ];
+});
+
 // src/control/upload-store.ts
 import { mkdtemp as mkdtemp2, readdir as readdir5, rm as rm10, stat as stat4, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir13 } from "node:os";
@@ -34487,7 +34724,7 @@ __export(exports_main, {
   main: () => main,
   buildApp: () => buildApp
 });
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { homedir as homedir14 } from "node:os";
 import { dirname as dirname13, join as join23 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -34867,7 +35104,7 @@ async function buildApp(paths, deps = {}) {
   };
   orchestration3 = new OrchestrationService({
     now: deps.loggerNow ?? (() => new Date),
-    createId: () => randomUUID3(),
+    createId: () => randomUUID5(),
     config: config4,
     loadState: async () => JSON.parse(JSON.stringify(state)),
     saveState: async (nextState) => {
@@ -34980,6 +35217,10 @@ async function buildApp(paths, deps = {}) {
   const router3 = new CommandRouter(sessions, transport, config4, configStore, logger2, undefined, orchestration3, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined, deps.channel?.nativeSessionListFormat ? deps.channel.nativeSessionListFormat.bind(deps.channel) : undefined, activeTurns);
   const agent3 = new ConsoleAgent(router3, logger2);
   const controlEvents = createControlEventBus(logger2);
+  const terminalService = createTerminalService({
+    events: controlEvents,
+    idleTimeoutSeconds: () => terminalIdleTimeoutSeconds(config4)
+  });
   const uploadStore = new UploadStore;
   uploadStore.cleanup();
   const uploadCleanupInterval = setInterval(() => void uploadStore.cleanup().catch(() => {}), 60 * 60 * 1000);
@@ -35028,7 +35269,9 @@ async function buildApp(paths, deps = {}) {
         controlEvents.emit({ type: "workspaces-changed" });
       }
     },
-    uploadStore
+    uploadStore,
+    terminal: terminalService,
+    terminalEnabled: () => terminalEnabled(config4)
   });
   const workspaceSignature = (cfg) => JSON.stringify(Object.keys(cfg.workspaces).sort().map((name) => {
     const ws = cfg.workspaces[name];
@@ -35120,6 +35363,7 @@ async function buildApp(paths, deps = {}) {
       scheduledScheduler.stop();
       configWatcher.close();
       clearInterval(uploadCleanupInterval);
+      terminalService.disposeAll();
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
@@ -35262,6 +35506,7 @@ var init_main = __esm(async () => {
   init_render_text();
   init_quota_manager();
   init_control_service();
+  init_terminal_service();
   init_upload_store();
   init_agent_catalog();
   init_config_watcher();
@@ -36963,7 +37208,7 @@ var init_doctor2 = __esm(async () => {
 
 // src/cli.ts
 init_core_home();
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { homedir as homedir20 } from "node:os";
 import { dirname as dirname15, join as join27, sep as sep2 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
@@ -52639,7 +52884,7 @@ async function prepareMcpCoordinatorStartup(input) {
   return { kind: "external-coordinator" };
 }
 function createMcpStdioIdentityResolver(input) {
-  const instanceId = randomUUID4().slice(0, 8);
+  const instanceId = randomUUID6().slice(0, 8);
   return async (context) => {
     const parsedCoordinatorSession = input.parsedCoordinatorSession?.trim() || null;
     const workspace3 = input.workspace?.trim() || null;

package/dist/config/types.d.ts

@@ -42,6 +42,12 @@ export interface TransportConfig {
      */
     preferLocalAgents?: boolean;
 }
+export interface TerminalConfig {
+    /** Default false. When false, control.terminal.create is rejected before any PTY spawns. */
+    enabled: boolean;
+    /** Idle seconds before a terminal PTY is auto-killed. Defaults to 900 (15 min). */
+    idleTimeoutSeconds?: number;
+}
 export type LoggingLevel = "error" | "info" | "debug";
 export interface PerfLogConfig {
     enabled: boolean;
@@ -103,4 +109,7 @@ export interface AppConfig {
     orchestration: OrchestrationConfig;
     later?: LaterConfig;
     language?: Locale;
+    terminal?: TerminalConfig;
 }
+export declare function terminalEnabled(config: AppConfig): boolean;
+export declare function terminalIdleTimeoutSeconds(config: AppConfig): number;

package/dist/control/control-event-bus.d.ts

@@ -6,6 +6,13 @@ export interface ScheduledOrigin {
     taskId: string;
     executeAt: string;
 }
+/** A single pending item in the per-session server-side prompt queue, as surfaced on
+ *  the wire by `queue-updated`. `textPreview` is truncated server-side (~120 chars). */
+export interface QueuedItemInfo {
+    id: string;
+    textPreview: string;
+    enqueuedAt: string;
+}
 export type ControlEvent = {
     type: "turn-output";
     chatKey: string;
@@ -17,6 +24,12 @@ export type ControlEvent = {
     sessionAlias: string;
     prompt?: string;
     scheduled?: ScheduledOrigin;
+    queueItemId?: string;
+} | {
+    type: "queue-updated";
+    chatKey: string;
+    sessionAlias: string;
+    items: QueuedItemInfo[];
 } | {
     type: "tool-event";
     chatKey: string;
@@ -64,6 +77,15 @@ export type ControlEvent = {
     chatKey: string;
     sessionAlias: string;
     messages: NativeHistoryMessage[];
+} | {
+    type: "terminal-output";
+    terminalId: string;
+    seq: number;
+    data: string;
+} | {
+    type: "terminal-exit";
+    terminalId: string;
+    code: number;
 } | {
     type: "orchestration-changed";
 };

package/dist/control/control-service.d.ts

@@ -77,6 +77,8 @@ export interface ControlServiceDeps {
         remove(name: string): Promise<void>;
     };
     uploadStore: UploadStore;
+    terminal: import("./terminal-service").TerminalService;
+    terminalEnabled: () => boolean;
 }
 export interface ControlPromptInput {
     chatKey: string;
@@ -91,6 +93,23 @@ export interface ControlPromptResult {
     ok: boolean;
     text?: string;
     errorMessage?: string;
+    /** True when this prompt did not run immediately and was instead appended to the
+     *  per-session server-side queue (a turn was already in flight). */
+    queued?: boolean;
+    /** Id of the queued item, present only when `queued` is true. Used to cancel it via
+     *  `cancelQueuedItem` before it drains. */
+    queueItemId?: string;
+}
+/** A prompt held in the per-session server-side queue while a turn is in flight.
+ *  Runs through the same `executeTurn` machinery as a manual prompt once drained. */
+export interface QueuedPrompt {
+    id: string;
+    text: string;
+    enqueuedAt: string;
+    senderId: string;
+    isOwner?: boolean;
+    accountId?: string;
+    media?: PromptAttachmentRef[];
 }
 /** A turn started by a fired scheduled task. Runs through the same agent + turn-event
  *  machinery as a normal prompt, so it streams live and persists to history — but it
@@ -171,6 +190,9 @@ export declare class ControlService {
     getOrchestrationTask(taskId: string): Promise<OrchestrationTaskRecord | null>;
     cancelOrchestrationTask(input: CancelTaskInput): Promise<OrchestrationTaskRecord>;
     private readonly inFlight;
+    private readonly queues;
+    private readonly draining;
+    private emitQueueUpdated;
     prompt(input: ControlPromptInput): Promise<ControlPromptResult>;
     /** Run a fired scheduled task as a real turn through the same machinery as a manual
      *  prompt — so it streams live and persists to history — while tagging turn-started
@@ -178,6 +200,21 @@ export declare class ControlService {
      *  the web can badge it. Owner-authorized: the task was owner-gated at creation. */
     runScheduledTurn(input: ControlScheduledTurnInput): Promise<ControlPromptResult>;
     private executeTurn;
+    private advanceQueue;
     cancelTurn(chatKey: string, sessionAlias: string): boolean;
+    /** Remove a pending queued prompt (by id) before it drains. No-ops (returns
+     *  `{ cancelled: false }`) when the queue or the id is absent/already drained —
+     *  e.g. a race where the item drained into a running turn just before the cancel
+     *  arrived. Does NOT touch a turn that is already running (use `cancelTurn`). */
+    cancelQueuedItem(chatKey: string, sessionAlias: string, itemId: string): {
+        cancelled: boolean;
+    };
     executeCommand(input: ControlExecuteCommandInput): Promise<string>;
+    /** Open an interactive terminal in the session's workspace cwd. Rejected when terminal is disabled. */
+    createTerminal(chatKey: string, sessionAlias: string, cols: number, rows: number): Promise<{
+        terminalId: string;
+    }>;
+    writeTerminal(terminalId: string, data: string): void;
+    resizeTerminal(terminalId: string, cols: number, rows: number): void;
+    closeTerminal(terminalId: string): void;
 }

package/dist/control/terminal-service.d.ts

@@ -0,0 +1,48 @@
+import type { ControlEventBus } from "./control-event-bus";
+/**
+ * Secret-bearing env keys stripped before handing the shell its environment.
+ * Best-effort denylist only — a real shell still inherits the full process env;
+ * custom secrets (DATABASE_URL, *_TOKEN, ~/.ssh keys, etc.) not on this list
+ * pass through. Do not treat env scrubbing as a security guarantee.
+ */
+export declare const SENSITIVE_ENV_KEYS: string[];
+export interface PtyHandle {
+    onData(cb: (data: string) => void): void;
+    onExit(cb: (e: {
+        exitCode: number;
+    }) => void): void;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+}
+export type PtySpawn = (file: string, args: string[], opts: {
+    name: string;
+    cols: number;
+    rows: number;
+    cwd: string;
+    env: Record<string, string>;
+}) => PtyHandle;
+export interface TerminalCreateInput {
+    cwd: string;
+    cols: number;
+    rows: number;
+}
+export interface TerminalService {
+    create(input: TerminalCreateInput): {
+        terminalId: string;
+    };
+    write(terminalId: string, data: string): void;
+    resize(terminalId: string, cols: number, rows: number): void;
+    close(terminalId: string): void;
+    disposeAll(): void;
+}
+export interface TerminalServiceDeps {
+    events: ControlEventBus;
+    idleTimeoutSeconds: () => number;
+    spawn?: PtySpawn;
+    platform?: NodeJS.Platform;
+    /** Injectable timer primitives; defaults to global setTimeout/clearTimeout. */
+    setTimer?: (fn: () => void, ms: number) => unknown;
+    clearTimer?: (id: unknown) => void;
+}
+export declare function createTerminalService(deps: TerminalServiceDeps): TerminalService;

package/dist/transport/acpx-cli/node-pty-helper.d.ts

@@ -0,0 +1,4 @@
+type ChmodFunction = (path: string, mode: number) => Promise<void>;
+export declare function resolveNodePtyHelperPath(packageJsonPath: string, platform: NodeJS.Platform, arch: string): string | null;
+export declare function ensureNodePtyHelperExecutable(helperPath: string | null, chmod?: ChmodFunction): Promise<void>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ganglion/xacpx",
-  "version": "0.16.0",
+  "version": "0.17.0-beta.1",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",