weacpx 0.6.1 → 0.7.0

package/dist/commands/handlers/session-handler.d.ts

@@ -8,6 +8,7 @@ export interface SessionHandlerContext extends CommandRouterContext {
     lifecycle: SessionLifecycleOps;
     interaction: SessionInteractionOps;
     recovery: SessionRenderRecoveryOps;
+    readonly activeTurns?: import("../../sessions/active-turn-registry.js").ActiveTurnRegistry;
 }
 export declare const sessionHelp: HelpTopicMetadata;
 export declare const nativeSessionHelp: HelpTopicMetadata;
@@ -22,14 +23,15 @@ export declare function handleSessionShortcut(context: SessionHandlerContext, ch
     workspace?: string;
 }, createNew: boolean): Promise<RouterResponse>;
 export declare function handleSessionAttach(context: SessionHandlerContext, chatKey: string, alias: string, agent: string, workspace: string, transportSession: string): Promise<RouterResponse>;
-export declare function handleSessionUse(context: SessionHandlerContext, chatKey: string, alias: string): Promise<RouterResponse>;
+export declare function handleSessionUse(context: SessionHandlerContext, chatKey: string, input: string): Promise<RouterResponse>;
+export declare function handleSessionUsePrevious(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
 export declare function handleModeShow(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
 export declare function handleModeSet(context: SessionHandlerContext, chatKey: string, modeId: string): Promise<RouterResponse>;
 export declare function handleReplyModeShow(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
 export declare function handleReplyModeSet(context: SessionHandlerContext, chatKey: string, replyMode: "stream" | "final" | "verbose"): Promise<RouterResponse>;
 export declare function handleReplyModeReset(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
 export declare function handleStatus(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
-export declare function handleCancel(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
+export declare function handleCancel(context: SessionHandlerContext, chatKey: string, alias?: string): Promise<RouterResponse>;
 export declare function handleSessionReset(context: SessionHandlerContext, chatKey: string): Promise<RouterResponse>;
 export declare function handleSessionTail(context: SessionHandlerContext, chatKey: string, lines?: number): Promise<RouterResponse>;
 export declare function handleSessionRemove(context: SessionHandlerContext, chatKey: string, alias: string): Promise<RouterResponse>;

package/dist/commands/handlers/session-list-marker.d.ts

@@ -0,0 +1 @@
+export declare function decorateUnread(label: string, hasUnread: boolean): string;

package/dist/commands/parse-command.d.ts

@@ -54,6 +54,7 @@ export type ParsedCommand = {
     kind: "status";
 } | {
     kind: "cancel";
+    alias?: string;
 } | {
     kind: "session.reset";
 } | {
@@ -118,6 +119,8 @@ export type ParsedCommand = {
 } | {
     kind: "session.use";
     alias: string;
+} | {
+    kind: "session.use.previous";
 } | {
     kind: "session.new";
     alias: string;

package/dist/plugin-api.d.ts

@@ -7,3 +7,12 @@ export type { CommandHint } from "./commands/command-hints.js";
 export type { AppLogger } from "./logging/app-logger.js";
 export type { WeacpxPlugin } from "./plugins/types.js";
 export { WEACPX_PLUGIN_API_VERSION, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION, } from "./plugins/types.js";
+export { createConversationExecutor } from "./runtime/conversation-executor.js";
+export type { ConversationExecutor, ConversationExecutorLane } from "./runtime/conversation-executor.js";
+export { resolveTurnLane } from "./runtime/turn-lane.js";
+export { createActiveTurnRegistry } from "./sessions/active-turn-registry.js";
+export type { ActiveTurnRegistry } from "./sessions/active-turn-registry.js";
+export { toDisplaySessionAlias } from "./channels/channel-scope.js";
+export type { SessionService } from "./sessions/session-service.js";
+export type { BackgroundResult } from "./state/types.js";
+export type { ChatRequestMetadata } from "./weixin/agent/interface.js";

package/dist/plugin-api.js

@@ -171,9 +171,166 @@ var init_types = __esm(() => {
   init_compatibility();
 });
 
+// src/runtime/conversation-executor.ts
+function createConversationExecutor() {
+  const states = new Map;
+  const getState = (conversationId) => {
+    const existing = states.get(conversationId);
+    if (existing)
+      return existing;
+    const created = { normalTails: new Map, activeControls: 0 };
+    states.set(conversationId, created);
+    return created;
+  };
+  const cleanupState = (conversationId, state) => {
+    if (state.normalTails.size === 0 && state.activeControls === 0) {
+      states.delete(conversationId);
+    }
+  };
+  return {
+    run(conversationId, lane, task, sessionKey) {
+      const state = getState(conversationId);
+      if (lane === "control") {
+        state.activeControls += 1;
+        return Promise.resolve().then(task).finally(() => {
+          state.activeControls -= 1;
+          cleanupState(conversationId, state);
+        });
+      }
+      const key = sessionKey ?? DEFAULT_SESSION_KEY;
+      const previous = state.normalTails.get(key) ?? Promise.resolve();
+      const next = previous.then(() => task(), () => task());
+      state.normalTails.set(key, next);
+      return next.finally(() => {
+        if (state.normalTails.get(key) === next) {
+          state.normalTails.delete(key);
+        }
+        cleanupState(conversationId, state);
+      });
+    }
+  };
+}
+var DEFAULT_SESSION_KEY = "__chat__";
+
+// src/sessions/active-turn-registry.ts
+function createActiveTurnRegistry() {
+  const byChat = new Map;
+  return {
+    markActive(chatKey, alias) {
+      const set = byChat.get(chatKey) ?? new Set;
+      set.add(alias);
+      byChat.set(chatKey, set);
+    },
+    markInactive(chatKey, alias) {
+      const set = byChat.get(chatKey);
+      if (!set)
+        return;
+      set.delete(alias);
+      if (set.size === 0)
+        byChat.delete(chatKey);
+    },
+    isActive(chatKey, alias) {
+      return byChat.get(chatKey)?.has(alias) ?? false;
+    }
+  };
+}
+
+// src/channels/channel-scope.ts
+function registerKnownChannelId(channelId) {
+  const normalized = channelId.trim();
+  if (!normalized || normalized.includes(":")) {
+    throw new Error("channel id must be non-empty and must not contain ':'");
+  }
+  KNOWN_CHANNEL_IDS.add(normalized);
+}
+function listKnownChannelIds() {
+  return Array.from(KNOWN_CHANNEL_IDS);
+}
+function getChannelIdFromChatKey(chatKey) {
+  const first = chatKey.split(":", 1)[0];
+  return first && KNOWN_CHANNEL_IDS.has(first) ? first : "weixin";
+}
+function toInternalSessionAlias(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  if (normalized.startsWith(`${channelId}:`)) {
+    return normalized;
+  }
+  return `${channelId}:${normalized}`;
+}
+function toDisplaySessionAlias(internalAlias) {
+  const [first, ...rest] = internalAlias.split(":");
+  if (first && KNOWN_CHANNEL_IDS.has(first) && rest.length > 0) {
+    return rest.join(":");
+  }
+  return internalAlias;
+}
+function isSessionAliasVisibleInChannel(alias, channelId) {
+  const [first] = alias.split(":", 1);
+  if (first && KNOWN_CHANNEL_IDS.has(first)) {
+    return first === channelId;
+  }
+  return channelId === "weixin";
+}
+function resolveSessionAliasForInput(channelId, displayAlias, existingAliases) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  if (normalized.startsWith(`${channelId}:`)) {
+    return normalized;
+  }
+  const scopedAlias = toInternalSessionAlias(channelId, normalized);
+  for (const alias of existingAliases) {
+    if (alias === scopedAlias)
+      return scopedAlias;
+  }
+  if (channelId === "weixin") {
+    for (const alias of existingAliases) {
+      if (alias === normalized)
+        return alias;
+    }
+  }
+  return scopedAlias;
+}
+function scopeDisplayAliasToInternal(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  return channelId === "weixin" ? normalized : toInternalSessionAlias(channelId, normalized);
+}
+function buildDefaultTransportSession(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  return channelId === "weixin" ? normalized : toInternalSessionAlias(channelId, normalized);
+}
+var KNOWN_CHANNEL_IDS;
+var init_channel_scope = __esm(() => {
+  KNOWN_CHANNEL_IDS = new Set(["weixin"]);
+});
+
 // src/plugin-api.ts
 init_types();
+
+// src/runtime/turn-lane.ts
+var CONTROL_COMMANDS = new Set(["/use", "/ss", "/cancel", "/stop"]);
+function resolveTurnLane(text) {
+  const command = text.trim().toLowerCase().split(/\s+/)[0] ?? "";
+  return CONTROL_COMMANDS.has(command) ? "control" : "normal";
+}
+
+// src/plugin-api.ts
+init_channel_scope();
 export {
+  toDisplaySessionAlias,
+  resolveTurnLane,
+  createConversationExecutor,
+  createActiveTurnRegistry,
   WEACPX_PLUGIN_MIN_CORE_VERSION,
   WEACPX_PLUGIN_API_VERSION,
   WEACPX_PLUGIN_API_SUPPORTED_VERSIONS

package/dist/{weixin/messaging → runtime}/conversation-executor.d.ts

@@ -1,7 +1,7 @@
 export type ConversationExecutorLane = "normal" | "control";
 type ConversationTask<T> = () => Promise<T>;
 export type ConversationExecutor = {
-    run<T>(conversationId: string, lane: ConversationExecutorLane, task: ConversationTask<T>): Promise<T>;
+    run<T>(conversationId: string, lane: ConversationExecutorLane, task: ConversationTask<T>, sessionKey?: string): Promise<T>;
 };
 export declare function createConversationExecutor(): ConversationExecutor;
 export {};

package/dist/runtime/core-home.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The per-user state directory name (`<home>/.weacpx/`). This is the SINGLE
+ * source of truth for that name; every config / state / runtime / plugin path
+ * is built on top of it.
+ *
+ * The weacpx→xacpx rename (0.8.0) changes the name HERE — and adds any
+ * legacy-directory fallback inside {@link coreHomeDir} (e.g. prefer
+ * `~/.xacpx`, fall back to an existing `~/.weacpx`) — so the whole tree of
+ * derived paths follows from one place rather than ~11 scattered literals.
+ */
+export declare const CORE_HOME_DIR_NAME = ".weacpx";
+/**
+ * The core state root for a given user home: `<home>/.weacpx`.
+ *
+ * Pass the home directory the caller already resolved — this helper imposes no
+ * home-resolution policy of its own, so each caller's existing semantics are
+ * preserved (this is a pure refactor of the directory-name literal). It is the
+ * one function the 0.8.0 rename hooks into.
+ */
+export declare function coreHomeDir(home: string): string;
+/**
+ * Display form for user-facing hints (e.g. "请查看日志：~/.weacpx/runtime/...").
+ * Keeps printed paths single-sourced with the real directory name. Always uses
+ * "/" separators since it is for display, not filesystem access.
+ */
+export declare function coreHomeDisplayPath(...segments: string[]): string;

package/dist/runtime/turn-lane.d.ts

@@ -0,0 +1,2 @@
+import type { ConversationExecutorLane } from "./conversation-executor.js";
+export declare function resolveTurnLane(text: string): ConversationExecutorLane;

package/dist/sessions/active-turn-registry.d.ts

@@ -0,0 +1,6 @@
+export interface ActiveTurnRegistry {
+    markActive(chatKey: string, alias: string): void;
+    markInactive(chatKey: string, alias: string): void;
+    isActive(chatKey: string, alias: string): boolean;
+}
+export declare function createActiveTurnRegistry(): ActiveTurnRegistry;

package/dist/sessions/session-service.d.ts

@@ -1,7 +1,7 @@
 import type { AppConfig } from "../config/types";
 import { AsyncMutex } from "../orchestration/async-mutex";
 import type { StateStore } from "../state/state-store";
-import type { AppState } from "../state/types";
+import type { AppState, BackgroundResult } from "../state/types";
 import type { AgentSession, ResolvedSession } from "../transport/types";
 interface SessionListItem {
     alias: string;
@@ -10,6 +10,25 @@ interface SessionListItem {
     workspace: string;
     isCurrent: boolean;
 }
+export interface SessionSwitchResult {
+    alias: string;
+    agent: string;
+    workspace: string;
+    previousAlias?: string;
+}
+export type FuzzyAliasResult = {
+    kind: "match";
+    alias: string;
+} | {
+    kind: "ambiguous";
+    candidates: Array<{
+        alias: string;
+        agent: string;
+        workspace: string;
+    }>;
+} | {
+    kind: "none";
+};
 interface NativeSessionAttachmentInput {
     alias: string;
     agent: string;
@@ -57,9 +76,24 @@ export declare class SessionService {
     attachSession(alias: string, agent: string, workspace: string, transportSession: string, transportAgentCommand?: string): Promise<ResolvedSession>;
     attachNativeSession(input: NativeSessionAttachmentInput): Promise<ResolvedSession>;
     getSession(alias: string): Promise<ResolvedSession | null>;
+    /**
+     * Synchronously resolve a session by its internal alias (as stored in state).
+     * Returns null if the alias is unknown or if the referenced agent/workspace is
+     * no longer registered (i.e. toResolvedSession would throw).
+     *
+     * Used by handlePrompt to honour a `boundSessionAlias` captured at dispatch
+     * time without requiring an async state mutation.
+     */
+    getResolvedSessionByInternalAlias(alias: string): ResolvedSession | null;
+    peekCurrentSessionAlias(chatKey: string): string | undefined;
     getPreferredSessionForTransport(transportSession: string): Promise<ResolvedSession | null>;
     findAttachedNativeSession(chatKey: string, agent: string, agentSessionId: string): Promise<ResolvedSession | null>;
-    useSession(chatKey: string, alias: string): Promise<void>;
+    useSession(chatKey: string, alias: string): Promise<SessionSwitchResult>;
+    usePreviousSession(chatKey: string): Promise<SessionSwitchResult | null>;
+    setBackgroundResult(chatKey: string, alias: string, result: BackgroundResult): Promise<void>;
+    takeBackgroundResult(chatKey: string, alias: string): Promise<BackgroundResult | null>;
+    listBackgroundResultAliases(chatKey: string): string[];
+    resolveFuzzyAlias(chatKey: string, fragment: string): FuzzyAliasResult;
     resolveAliasForChat(chatKey: string, displayAlias: string): Promise<string>;
     buildDefaultTransportSessionForChat(chatKey: string, displayAlias: string): string;
     listInternalAliases(): string[];
@@ -73,6 +107,7 @@ export declare class SessionService {
     }>;
     cacheNativeSessionList(chatKey: string, input: NativeSessionListInput): Promise<void>;
     getNativeSessionList(chatKey: string, ttlMs?: number): Promise<NativeSessionListResult | null>;
+    private deleteNativeSessionListIfCurrent;
     private toResolvedSession;
     setSessionTransportAgentCommand(alias: string, transportAgentCommand: string | undefined): Promise<void>;
     private mutate;

package/dist/state/types.d.ts

@@ -31,8 +31,15 @@ export interface LogicalSession {
     created_at: string;
     last_used_at: string;
 }
+export interface BackgroundResult {
+    text: string;
+    status: "done" | "error";
+    finished_at: string;
+}
 export interface ChatContextState {
     current_session: string;
+    previous_session?: string;
+    background_results?: Record<string, BackgroundResult>;
 }
 export interface AppState {
     sessions: Record<string, LogicalSession>;

package/dist/weixin/agent/interface.d.ts

@@ -66,6 +66,7 @@ export interface ChatRequestMetadata {
     scheduledSessionAlias?: string;
     /** Transient session descriptor for temp-mode scheduled prompts (no persisted alias). */
     scheduledSessionDescriptor?: ScheduledSessionDescriptor;
+    boundSessionAlias?: string;
 }
 export interface ChatResponse {
     /**

package/dist/weixin/api/config-cache.d.ts

@@ -1,7 +1,15 @@
+import { getConfig } from "./api.js";
 /** Subset of getConfig fields that we actually need; add new fields here as needed. */
 export interface CachedConfig {
     typingTicket: string;
 }
+type GetConfigFn = typeof getConfig;
+export interface WeixinConfigManagerOptions {
+    maxEntries?: number;
+    entryTtlMs?: number;
+    now?: () => number;
+    getConfig?: GetConfigFn;
+}
 /**
  * Per-user getConfig cache with periodic random refresh (within 24h) and
  * exponential-backoff retry (up to 1h) on failure.
@@ -10,9 +18,18 @@ export declare class WeixinConfigManager {
     private apiOpts;
     private log;
     private cache;
+    private readonly maxEntries;
+    private readonly entryTtlMs;
+    private readonly now;
+    private readonly fetchConfig;
     constructor(apiOpts: {
         baseUrl: string;
         token?: string;
-    }, log: (msg: string) => void);
+    }, log: (msg: string) => void, options?: WeixinConfigManagerOptions);
     getForUser(userId: string, contextToken?: string): Promise<CachedConfig>;
+    cacheSizeForTests(): number;
+    hasCachedUserForTests(userId: string): boolean;
+    private prune;
+    private enforceMaxEntries;
 }
+export {};

package/dist/weixin/bot.d.ts

@@ -2,6 +2,7 @@ import type { Agent } from "./agent/interface.js";
 import type { PendingFinalChunk } from "./messaging/quota-manager.js";
 import type { RuntimeMediaStore } from "../channels/media-store.js";
 import type { PerfTracer } from "../perf/perf-tracer.js";
+import type { ActiveTurnRegistry } from "../sessions/active-turn-registry.js";
 export type LoginOptions = {
     /** Override the API base URL. */
     baseUrl?: string;
@@ -31,6 +32,16 @@ export type StartOptions = {
     dropPendingFinal?: (chatKey: string) => void;
     mediaStore?: RuntimeMediaStore;
     perfTracer?: PerfTracer;
+    /** Read the chat's current session synchronously for dispatch-time binding. */
+    peekCurrentSessionAlias?: (chatKey: string) => string | undefined;
+    /** Persist a background turn's final result for later replay. */
+    setBackgroundResult?: (chatKey: string, alias: string, result: {
+        text: string;
+        status: "done" | "error";
+        finished_at: string;
+    }) => Promise<void>;
+    /** Shared in-flight turn registry for dispatch-time foreground tracking. */
+    activeTurns?: ActiveTurnRegistry;
 };
 /**
  * Interactive QR-code login. Prints the QR code to the terminal and waits

package/dist/weixin/messaging/completion-notice.d.ts

@@ -0,0 +1,2 @@
+export declare function buildBackgroundCompletionNotice(internalAlias: string, status: "done" | "error"): string;
+export declare function shouldSendBackgroundNotice(reserve: (() => boolean) | undefined): boolean;

package/dist/weixin/messaging/foreground-gate.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldDeliverSegment(isForeground: (() => boolean) | undefined): boolean;
+export type FinalDisposition = "send" | "store" | "drop";
+export declare function resolveFinalDisposition(isForeground: boolean, canStore: boolean): FinalDisposition;

package/dist/weixin/messaging/handle-weixin-message-turn.d.ts

@@ -27,6 +27,10 @@ export type HandleWeixinMessageTurnDeps = {
     downloadMediaFromItemFn?: typeof downloadMediaFromItem;
     allowedMediaRoots?: string[];
     perfTracer?: PerfTracer;
+    isForeground?: () => boolean;
+    boundSessionAlias?: string;
+    onBackgroundFinal?: (alias: string, text: string, status: "done" | "error") => Promise<void>;
 };
 export declare function getWeixinMessageTurnLane(full: WeixinMessage): "normal" | "control";
+export declare function buildWeixinChatKey(accountId: string, userId: string): string;
 export declare function handleWeixinMessageTurn(full: WeixinMessage, deps: HandleWeixinMessageTurnDeps): Promise<void>;

package/dist/weixin/messaging/inbound.d.ts

@@ -1,5 +1,11 @@
 import type { ChannelMediaKind } from "../../channels/media-types.js";
 import type { WeixinMessage, MessageItem } from "../api/types.js";
+interface ContextTokenRetentionOptions {
+    maxTokensPerAccount?: number;
+    tokenTtlMs?: number;
+    now?: () => number;
+}
+export declare function configureContextTokenRetentionForTests(options?: ContextTokenRetentionOptions): void;
 /**
  * Restore the per-account context-token cache from disk into memory.
  * Called at bot startup (after login). Missing/unreadable files are tolerated
@@ -78,3 +84,4 @@ export interface WeixinInboundMediaDescriptor {
     fileName?: string;
 }
 export declare function extractWeixinMediaDescriptors(itemList?: MessageItem[]): WeixinInboundMediaDescriptor[];
+export {};

package/dist/weixin/messaging/quota-manager.d.ts

@@ -24,11 +24,21 @@ export interface QuotaObserver {
     onFinalReserved?(chatKey: string, snapshot: QuotaSnapshot): void;
     onFinalRejected?(chatKey: string, snapshot: QuotaSnapshot): void;
 }
+export interface QuotaManagerOptions {
+    maxStates?: number;
+    stateTtlMs?: number;
+    maxPendingFinalChunksPerChat?: number;
+    now?: () => number;
+}
 export declare class QuotaManager {
     private readonly states;
     private readonly observer;
     private readonly normalizeKey;
-    constructor(observer?: QuotaObserver, normalizeKey?: (key: string) => string);
+    private readonly maxStates;
+    private readonly stateTtlMs;
+    private readonly maxPendingFinalChunksPerChat;
+    private readonly now;
+    constructor(observer?: QuotaObserver, normalizeKey?: (key: string) => string, options?: QuotaManagerOptions);
     onInbound(chatKey: string): void;
     reserveMidSegment(chatKey: string): boolean;
     reserveFinal(chatKey: string): boolean;
@@ -41,4 +51,8 @@ export declare class QuotaManager {
     clearPendingFinal(chatKey: string): void;
     snapshot(chatKey: string): QuotaSnapshot;
     private getOrCreate;
+    private prune;
+    private enforceMaxStates;
+    private trimPendingFinalChunks;
+    private deleteIfEmpty;
 }

package/dist/weixin/monitor/monitor.d.ts

@@ -1,5 +1,6 @@
 import type { Agent } from "../agent/interface.js";
 import type { PendingFinalChunk } from "../messaging/quota-manager.js";
+import type { ActiveTurnRegistry } from "../../sessions/active-turn-registry.js";
 import type { RuntimeMediaStore } from "../../channels/media-store.js";
 import type { PerfTracer } from "../../perf/perf-tracer.js";
 export type MonitorWeixinOpts = {
@@ -22,6 +23,13 @@ export type MonitorWeixinOpts = {
     mediaStore?: RuntimeMediaStore;
     allowedMediaRoots?: string[];
     perfTracer?: PerfTracer;
+    peekCurrentSessionAlias?: (chatKey: string) => string | undefined;
+    setBackgroundResult?: (chatKey: string, alias: string, result: {
+        text: string;
+        status: "done" | "error";
+        finished_at: string;
+    }) => Promise<void>;
+    activeTurns?: ActiveTurnRegistry;
 };
 /**
  * Long-poll loop: getUpdates → process message → call agent → send reply.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weacpx",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",