@ganglion/xacpx 0.17.0-beta.0 → 0.17.0-beta.1

package/dist/cli.js

@@ -33889,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;
@@ -34056,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 } : {}
@@ -34081,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;
@@ -34103,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;
@@ -34115,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) {
@@ -34127,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 {
@@ -34251,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);
@@ -34261,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) {
@@ -34271,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({
@@ -34332,7 +34410,7 @@ 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();
@@ -34340,7 +34418,7 @@ var init_control_service = __esm(() => {
 });
 
 // src/control/terminal-service.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { createRequire as createRequire6 } from "node:module";
 import { spawn as spawnPty2 } from "node-pty";
 function scrubEnv() {
@@ -34392,7 +34470,7 @@ function createTerminalService(deps) {
     create({ cwd, cols, rows }) {
       if (platform === "win32")
         throw new Error("terminal-unsupported-platform");
-      const terminalId = randomUUID3();
+      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);
@@ -34646,7 +34724,7 @@ __export(exports_main, {
   main: () => main,
   buildApp: () => buildApp
 });
-import { randomUUID as randomUUID4 } 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";
@@ -35026,7 +35104,7 @@ async function buildApp(paths, deps = {}) {
   };
   orchestration3 = new OrchestrationService({
     now: deps.loggerNow ?? (() => new Date),
-    createId: () => randomUUID4(),
+    createId: () => randomUUID5(),
     config: config4,
     loadState: async () => JSON.parse(JSON.stringify(state)),
     saveState: async (nextState) => {
@@ -37130,7 +37208,7 @@ var init_doctor2 = __esm(async () => {
 
 // src/cli.ts
 init_core_home();
-import { randomUUID as randomUUID5 } 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";
@@ -52806,7 +52884,7 @@ async function prepareMcpCoordinatorStartup(input) {
   return { kind: "external-coordinator" };
 }
 function createMcpStdioIdentityResolver(input) {
-  const instanceId = randomUUID5().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/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;

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

@@ -93,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
@@ -173,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
@@ -180,7 +200,15 @@ 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<{

package/package.json

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