@ganglion/xacpx 0.16.0 → 0.17.0-beta.0

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";
@@ -34273,6 +34288,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;
@@ -34307,6 +34339,133 @@ var init_control_service = __esm(() => {
   init_workspace_fs();
 });
 
+// src/control/terminal-service.ts
+import { randomUUID as randomUUID3 } 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 = randomUUID3();
+      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 +34646,7 @@ __export(exports_main, {
   main: () => main,
   buildApp: () => buildApp
 });
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } 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 +35026,7 @@ async function buildApp(paths, deps = {}) {
   };
   orchestration3 = new OrchestrationService({
     now: deps.loggerNow ?? (() => new Date),
-    createId: () => randomUUID3(),
+    createId: () => randomUUID4(),
     config: config4,
     loadState: async () => JSON.parse(JSON.stringify(state)),
     saveState: async (nextState) => {
@@ -34980,6 +35139,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 +35191,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 +35285,7 @@ async function buildApp(paths, deps = {}) {
       scheduledScheduler.stop();
       configWatcher.close();
       clearInterval(uploadCleanupInterval);
+      terminalService.disposeAll();
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
@@ -35262,6 +35428,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 +37130,7 @@ var init_doctor2 = __esm(async () => {
 
 // src/cli.ts
 init_core_home();
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } 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 +52806,7 @@ async function prepareMcpCoordinatorStartup(input) {
   return { kind: "external-coordinator" };
 }
 function createMcpStdioIdentityResolver(input) {
-  const instanceId = randomUUID4().slice(0, 8);
+  const instanceId = randomUUID5().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

@@ -64,6 +64,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;
@@ -180,4 +182,11 @@ export declare class ControlService {
     private executeTurn;
     cancelTurn(chatKey: string, sessionAlias: string): 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.0",
   "description": "随时随地通过聊天频道（微信 / 飞书 / 元宝等）远程控制 `acpx` 上的 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",