weacpx 0.6.1 → 0.8.0

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

@@ -1,83 +0,0 @@
-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 { AgentSession, ResolvedSession } from "../transport/types";
-interface SessionListItem {
-    alias: string;
-    internalAlias: string;
-    agent: string;
-    workspace: string;
-    isCurrent: boolean;
-}
-interface NativeSessionAttachmentInput {
-    alias: string;
-    agent: string;
-    workspace: string;
-    transportSession: string;
-    transportAgentCommand?: string;
-    agentSessionId: string;
-    title?: string | null;
-    updatedAt?: string;
-}
-interface NativeSessionListInput {
-    agent: string;
-    workspace?: string;
-    cwd: string;
-    sessions: AgentSession[];
-    nextCursor?: string | null;
-}
-interface NativeSessionListResult {
-    agent: string;
-    workspace?: string;
-    cwd: string;
-    sessions: AgentSession[];
-    nextCursor?: string | null;
-}
-interface SessionServiceOptions {
-    stateMutex?: AsyncMutex;
-    now?: () => number;
-}
-export declare class SessionService {
-    private readonly config;
-    private readonly stateStore;
-    private readonly state;
-    private readonly stateMutex;
-    private readonly now;
-    constructor(config: AppConfig, stateStore: Pick<StateStore, "save">, state: AppState, options?: SessionServiceOptions);
-    createSession(alias: string, agent: string, workspace: string): Promise<ResolvedSession>;
-    /**
-     * All currently-known logical sessions resolved to transport sessions, deduped by
-     * transport session. Sessions whose agent or workspace is no longer registered are
-     * skipped (toResolvedSession would throw). Used by shutdown cleanup to reap warm
-     * acpx queue owners; never throws.
-     */
-    listAllResolvedSessions(): ResolvedSession[];
-    resolveSession(alias: string, agent: string, workspace: string, transportSession: string): ResolvedSession;
-    attachSession(alias: string, agent: string, workspace: string, transportSession: string, transportAgentCommand?: string): Promise<ResolvedSession>;
-    attachNativeSession(input: NativeSessionAttachmentInput): Promise<ResolvedSession>;
-    getSession(alias: string): Promise<ResolvedSession | null>;
-    getPreferredSessionForTransport(transportSession: string): Promise<ResolvedSession | null>;
-    findAttachedNativeSession(chatKey: string, agent: string, agentSessionId: string): Promise<ResolvedSession | null>;
-    useSession(chatKey: string, alias: string): Promise<void>;
-    resolveAliasForChat(chatKey: string, displayAlias: string): Promise<string>;
-    buildDefaultTransportSessionForChat(chatKey: string, displayAlias: string): string;
-    listInternalAliases(): string[];
-    setCurrentSessionMode(chatKey: string, modeId: string | undefined): Promise<void>;
-    setCurrentSessionReplyMode(chatKey: string, replyMode: "stream" | "final" | "verbose" | undefined): Promise<void>;
-    getCurrentSession(chatKey: string): Promise<ResolvedSession | null>;
-    listSessions(chatKey: string): Promise<SessionListItem[]>;
-    countAliasesSharingTransport(transportSession: string, excludeAlias?: string): number;
-    removeSession(alias: string): Promise<{
-        wasActive: boolean;
-    }>;
-    cacheNativeSessionList(chatKey: string, input: NativeSessionListInput): Promise<void>;
-    getNativeSessionList(chatKey: string, ttlMs?: number): Promise<NativeSessionListResult | null>;
-    private toResolvedSession;
-    setSessionTransportAgentCommand(alias: string, transportAgentCommand: string | undefined): Promise<void>;
-    private mutate;
-    private persist;
-    private createLogicalSession;
-    private validateSession;
-}
-export {};

package/dist/state/state-store.d.ts

@@ -1,8 +0,0 @@
-import { type AppState } from "./types";
-export declare function parseState(raw: unknown, path: string): AppState;
-export declare class StateStore {
-    private readonly path;
-    constructor(path: string);
-    load(): Promise<AppState>;
-    save(state: AppState): Promise<void>;
-}

package/dist/state/types.d.ts

@@ -1,44 +0,0 @@
-import { type OrchestrationState } from "../orchestration/orchestration-types";
-import type { ScheduledTaskRecord } from "../scheduled/scheduled-types";
-export type LogicalSessionSource = "weacpx" | "agent-side";
-export interface NativeSessionCacheEntry {
-    session_id: string;
-    cwd?: string;
-    title?: string | null;
-    updated_at?: string;
-}
-export interface NativeSessionListCacheRecord {
-    created_at: string;
-    agent: string;
-    workspace?: string;
-    cwd: string;
-    sessions: NativeSessionCacheEntry[];
-    next_cursor?: string | null;
-}
-export interface LogicalSession {
-    alias: string;
-    agent: string;
-    workspace: string;
-    transport_session: string;
-    source?: LogicalSessionSource;
-    agent_session_id?: string;
-    agent_session_title?: string;
-    agent_session_updated_at?: string;
-    attached_at?: string;
-    transport_agent_command?: string;
-    mode_id?: string;
-    reply_mode?: "stream" | "final" | "verbose";
-    created_at: string;
-    last_used_at: string;
-}
-export interface ChatContextState {
-    current_session: string;
-}
-export interface AppState {
-    sessions: Record<string, LogicalSession>;
-    chat_contexts: Record<string, ChatContextState>;
-    native_session_lists: Record<string, NativeSessionListCacheRecord>;
-    orchestration: OrchestrationState;
-    scheduled_tasks: Record<string, ScheduledTaskRecord>;
-}
-export declare function createEmptyState(): AppState;

package/dist/transport/tool-event-mode.d.ts

@@ -1,14 +0,0 @@
-import type { ToolUseEvent } from "../channels/types.js";
-export type ToolEventMode = "text" | "structured" | "both";
-/**
- * Resolves the effective tool-event rendering mode.
- *
- * Resolution order (hard contract — preserves Phase 0 invariant):
- *   1. Explicit `toolEventMode` always wins.
- *   2. `onToolEvent` present → "structured" (structured consumer, suppress text tool calls).
- *   3. Default → "text" (legacy text tool calls; no structured consumer).
- */
-export declare function resolveToolEventMode(input?: {
-    toolEventMode?: ToolEventMode;
-    onToolEvent?: (event: ToolUseEvent) => void | Promise<void>;
-}): ToolEventMode;

package/dist/transport/types.d.ts

@@ -1,129 +0,0 @@
-import type { NonInteractivePermissions, PermissionMode } from "../config/types";
-import type { QuotaManager } from "../weixin/messaging/quota-manager.js";
-import type { ToolUseEvent } from "../channels/types.js";
-import type { ToolEventMode } from "./tool-event-mode.js";
-export type { ToolEventMode } from "./tool-event-mode.js";
-export interface ReplyQuotaContext {
-    chatKey: string;
-    quota: QuotaManager;
-}
-export interface PromptMedia {
-    type: "image" | "audio" | "video" | "file";
-    filePath: string;
-    mimeType: string;
-    fileName?: string;
-}
-export interface PermissionPolicy {
-    permissionMode: PermissionMode;
-    nonInteractivePermissions: NonInteractivePermissions;
-    permissionPolicy?: string;
-}
-export interface ResolvedSession {
-    alias: string;
-    agent: string;
-    agentCommand?: string;
-    workspace: string;
-    transportSession: string;
-    source?: "weacpx" | "agent-side";
-    agentSessionId?: string;
-    agentSessionTitle?: string;
-    agentSessionUpdatedAt?: string;
-    attachedAt?: string;
-    mcpCoordinatorSession?: string;
-    mcpSourceHandle?: string;
-    modeId?: string;
-    replyMode?: "stream" | "final" | "verbose";
-    cwd: string;
-    /**
-     * True for a non-persisted, single-use session (e.g. a `/later` temp-mode
-     * scheduled run). Transport errors for such a session must not suggest
-     * `/session new`/`attach`, and missing-session recovery (which mutates
-     * persisted state by alias) does not apply.
-     */
-    transient?: boolean;
-}
-export interface AgentSession {
-    sessionId: string;
-    cwd?: string;
-    title?: string | null;
-    updatedAt?: string;
-    _meta?: Record<string, unknown>;
-}
-export interface AgentSessionListQuery {
-    agent: string;
-    agentCommand?: string;
-    cwd: string;
-    cursor?: string;
-    filterCwd?: string;
-}
-export interface AgentSessionListResult {
-    source: "agent";
-    sessions: AgentSession[];
-    cursor?: string;
-    nextCursor?: string | null;
-    cwd?: string;
-}
-export type EnsureSessionProgressStage = "spawn" | "initializing" | "ready";
-export type EnsureSessionProgress = EnsureSessionProgressStage | {
-    kind: "note";
-    text: string;
-};
-export type PromptMediaInput = PromptMedia | PromptMedia[];
-export interface PromptOptions {
-    onSegment?: (text: string) => void | Promise<void>;
-    /**
-     * Structured side-channel for tool calls. See `toolEventMode` for routing.
-     *
-     * Async semantics: callbacks are invoked in event order and serialized —
-     * each invocation is awaited before the next is dispatched. The transport
-     * waits for all callbacks to settle before resolving the prompt. If any
-     * invocation throws or returns a rejected promise, the prompt rejects
-     * with the first observed error (matching `onSegment` behavior).
-     */
-    onToolEvent?: (event: ToolUseEvent) => void | Promise<void>;
-    /**
-     * Optional structured side-channel for the agent's thinking/reasoning.
-     *
-     * Each acpx `agent_thought_chunk` is forwarded raw (no buffering, no
-     * paragraph splitting). Channels that register this callback opt in to
-     * receiving thoughts and are responsible for their own accumulation /
-     * rendering. When omitted, thought chunks are dropped at the transport
-     * boundary — the built-in WeChat channel does not register it.
-     *
-     * Async semantics match `onSegment`: invocations are serialized and the
-     * transport awaits all of them before resolving the prompt; the first
-     * error observed rejects the prompt.
-     */
-    onThought?: (chunk: string) => void | Promise<void>;
-    /**
-     * How tool_call / tool_call_update events are surfaced for this prompt.
-     *
-     * - "text" (default when no handler): legacy emoji-prefixed segments in the reply stream.
-     * - "structured" (default when a handler is provided): events go to `onToolEvent` only.
-     * - "both": events go to `onToolEvent` AND legacy text segments — useful for migration.
-     *
-     * Resolved at the transport boundary via `resolveToolEventMode`.
-     */
-    toolEventMode?: ToolEventMode;
-    media?: PromptMediaInput;
-}
-export interface SessionTransport {
-    ensureSession(session: ResolvedSession, onProgress?: (progress: EnsureSessionProgress) => void): Promise<void>;
-    tailSessionHistory(session: ResolvedSession, lines: number): Promise<{
-        text: string;
-    }>;
-    prompt(session: ResolvedSession, text: string, reply?: (text: string) => Promise<void>, replyContext?: ReplyQuotaContext, options?: PromptOptions): Promise<{
-        text: string;
-    }>;
-    setMode(session: ResolvedSession, modeId: string): Promise<void>;
-    cancel(session: ResolvedSession): Promise<{
-        cancelled: boolean;
-        message: string;
-    }>;
-    hasSession(session: ResolvedSession): Promise<boolean>;
-    listAgentSessions?(query: AgentSessionListQuery): Promise<AgentSessionListResult | undefined>;
-    resumeAgentSession?(session: ResolvedSession, agentSessionId: string): Promise<void>;
-    removeSession?(session: ResolvedSession): Promise<void>;
-    updatePermissionPolicy?(policy: PermissionPolicy): Promise<void>;
-    dispose?(): Promise<void>;
-}

package/dist/util/path.d.ts

@@ -1,4 +0,0 @@
-export declare function normalizePath(input: string): string;
-export declare function basenameForPath(input: string): string;
-export declare function isSamePath(left: string, right: string): boolean;
-export declare function isWindowsLikePath(input: string): boolean;

package/dist/util/private-file.d.ts

@@ -1,26 +0,0 @@
-export declare function writePrivateFileAtomic(path: string, content: string): Promise<void>;
-/**
- * Synchronous private-file write for hot-path callers that cannot await
- * (e.g. per-message weixin credential/sync-buf/context-token persistence).
- * Atomic via write-file-atomic's temp+rename, created at 0600 so the secret is
- * never momentarily world-readable. No cross-process lock: weixin's per-account
- * consumer lock already serializes the single writing daemon.
- */
-interface WritePrivateFileSyncDeps {
-    platform?: NodeJS.Platform;
-    atomicWrite?: (path: string, content: string) => void;
-    directWrite?: (path: string, content: string) => void;
-}
-export declare function writePrivateFileSync(path: string, content: string, deps?: WritePrivateFileSyncDeps): void;
-interface RetryTransientWriteOptions {
-    platform?: NodeJS.Platform;
-    maxAttempts?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    delay?: (ms: number) => Promise<void>;
-}
-export declare function retryTransientWriteErrors(run: () => Promise<void>, options?: RetryTransientWriteOptions): Promise<void>;
-export declare const __privateFileForTests: {
-    retryTransientWriteErrors: typeof retryTransientWriteErrors;
-};
-export {};

package/dist/util/sanitize.d.ts

@@ -1,10 +0,0 @@
-export interface SanitizeOptions {
-    allow?: RegExp;
-    deny?: RegExp;
-    replacement?: string;
-    collapse?: boolean;
-    trim?: boolean;
-    lowercase?: boolean;
-    fallback?: string;
-}
-export declare function sanitizeString(input: string, options?: SanitizeOptions): string;

package/dist/util/text.d.ts

@@ -1,3 +0,0 @@
-export declare function truncateText(text: string, maxLength: number, ellipsis?: string): string;
-export declare function escapeForDoubleQuotes(input: string): string;
-export declare function quoteIfNeeded(input: string): string;

package/dist/version.d.ts

@@ -1,3 +0,0 @@
-export declare function readVersion(moduleUrl?: string): string;
-/** weacpx 核心版本，派生自 package.json（经 readVersion 动态读取，无硬编码漂移）。 */
-export declare const WEACPX_CORE_VERSION: string;

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

@@ -1,78 +0,0 @@
-import type { ChannelMediaAttachment, OutboundChannelMedia } from "../../channels/media-types.js";
-import type { ScheduledSessionDescriptor, ToolUseEvent } from "../../channels/types.js";
-import type { PerfSpan } from "../../perf/perf-tracer.js";
-/**
- * Agent interface — any AI backend that can handle a chat message.
- *
- * Implement this interface to connect WeChat to your own AI service.
- * The WeChat bridge calls `chat()` for each inbound message and sends
- * the returned response back to the user.
- */
-export interface Agent {
-    /** Process a single message and return a reply. */
-    chat(request: ChatRequest): Promise<ChatResponse>;
-    /** Return true when the text begins with a command prefix handled by this agent. */
-    isKnownCommand?(text: string): boolean;
-    /** Clear/reset the session for a given conversation. */
-    clearSession?(conversationId: string): void | Promise<void>;
-}
-export interface ChatRequest {
-    /** Inbound Weixin account id that received this message. */
-    accountId: string;
-    /** Conversation / user identifier. Use this to maintain per-user context. */
-    conversationId: string;
-    /** Text content of the message. */
-    text: string;
-    /** Attached media file(s) (image, audio, video, or generic file). */
-    media?: ChannelMediaAttachment | ChannelMediaAttachment[];
-    /**
-     * Optional callback for streaming text out during long-running agent
-     * processing. When the channel delivers any non-empty reply segment,
-     * callers may treat it as the text output channel for that turn and
-     * suppress `ChatResponse.text`.
-     */
-    reply?: (text: string) => Promise<void>;
-    /** Latest inbound Weixin context token for follow-up replies in the same chat. */
-    replyContextToken?: string;
-    /** Channel-provided facts for command authorization and routing policy. */
-    metadata?: ChatRequestMetadata;
-    /**
-     * Signals that the channel has received an abort/stop request for this turn.
-     * Agents that can interrupt long-running work (e.g. cancel an in-flight acpx
-     * prompt) should observe this and bail out early. Optional; agents that don't
-     * support cancellation may ignore it — the channel will still suppress any
-     * output produced after abort.
-     */
-    abortSignal?: AbortSignal;
-    /** Structured tool-use side-channel; see PromptOptions.onToolEvent. */
-    onToolEvent?: (event: ToolUseEvent) => void | Promise<void>;
-    /** Structured thinking side-channel; see PromptOptions.onThought. */
-    onThought?: (chunk: string) => void | Promise<void>;
-    /**
-     * Optional per-turn performance tracing span. When `logging.perf.enabled` is
-     * true, the channel handler attaches a `PerfSpan` so downstream layers can
-     * inline `request.perfSpan?.mark(event, ctx)` without further plumbing.
-     */
-    perfSpan?: PerfSpan;
-}
-export interface ChatRequestMetadata {
-    channel?: string;
-    chatType?: "direct" | "group";
-    senderId?: string;
-    senderName?: string;
-    groupId?: string;
-    isOwner?: boolean;
-    /** Internal weacpx session alias to use for non-interactive scheduled prompts. */
-    scheduledSessionAlias?: string;
-    /** Transient session descriptor for temp-mode scheduled prompts (no persisted alias). */
-    scheduledSessionDescriptor?: ScheduledSessionDescriptor;
-}
-export interface ChatResponse {
-    /**
-     * Final reply text when no streamed `reply()` output was delivered for
-     * the same turn. May contain markdown and will be normalized before send.
-     */
-    text?: string;
-    /** Reply media file(s). */
-    media?: OutboundChannelMedia | OutboundChannelMedia[];
-}

package/dist/weixin/api/api.d.ts

@@ -1,76 +0,0 @@
-import type { BaseInfo, GetUploadUrlReq, GetUploadUrlResp, GetUpdatesReq, GetUpdatesResp, SendMessageReq, SendTypingReq, GetConfigResp } from "./types.js";
-export type WeixinApiOptions = {
-    baseUrl: string;
-    token?: string;
-    timeoutMs?: number;
-    /** Long-poll timeout for getUpdates (server may hold the request up to this). */
-    longPollTimeoutMs?: number;
-};
-/**
- * Sanitize a user-supplied `botAgent` config value into a wire-safe string.
- *
- * Grammar (UA-style):
- *   bot_agent = product *( SP product )
- *   product   = name "/" version [ SP "(" comment ")" ]
- *   name      = 1*32( ALPHA / DIGIT / "_" / "." / "-" )
- *   version   = 1*32( ALPHA / DIGIT / "_" / "." / "+" / "-" )
- *   comment   = 1*64( printable ASCII minus "(" ")" )
- *
- * Tokens that fail to parse are dropped silently (no partial tokens kept).
- * Returns `DEFAULT_BOT_AGENT` when the input is empty / all tokens dropped /
- * the result exceeds the length cap after truncation.
- */
-export declare function sanitizeBotAgent(raw: string | undefined): string;
-/** Build the `base_info` payload included in every API request. */
-export declare function buildBaseInfo(): BaseInfo;
-/**
- * GET fetch wrapper: send a GET request to a Weixin API endpoint with timeout + abort.
- * Query parameters should already be encoded in `endpoint`.
- * Returns the raw response text on success; throws on HTTP error or timeout.
- */
-export declare function apiGetFetch(params: {
-    baseUrl: string;
-    endpoint: string;
-    timeoutMs: number;
-    label: string;
-}): Promise<string>;
-/**
- * Simple POST fetch wrapper for login/auth endpoints.
- * Returns the raw response text on success; throws on HTTP error or timeout.
- */
-export declare function apiPostFetch(params: {
-    baseUrl: string;
-    endpoint: string;
-    body: string;
-    token?: string;
-    timeoutMs?: number;
-    label: string;
-    abortSignal?: AbortSignal;
-}): Promise<string>;
-/**
- * Long-poll getUpdates. Server should hold the request until new messages or timeout.
- *
- * On client-side timeout (no server response within timeoutMs), returns an empty response
- * with ret=0 so the caller can simply retry. This is normal for long-poll.
- */
-export declare function getUpdates(params: GetUpdatesReq & {
-    baseUrl: string;
-    token?: string;
-    timeoutMs?: number;
-    abortSignal?: AbortSignal;
-}): Promise<GetUpdatesResp>;
-/** Get a pre-signed CDN upload URL for a file. */
-export declare function getUploadUrl(params: GetUploadUrlReq & WeixinApiOptions): Promise<GetUploadUrlResp>;
-/** Send a single message downstream. */
-export declare function sendMessage(params: WeixinApiOptions & {
-    body: SendMessageReq;
-}): Promise<void>;
-/** Fetch bot config (includes typing_ticket) for a given user. */
-export declare function getConfig(params: WeixinApiOptions & {
-    ilinkUserId: string;
-    contextToken?: string;
-}): Promise<GetConfigResp>;
-/** Send a typing indicator to a user. */
-export declare function sendTyping(params: WeixinApiOptions & {
-    body: SendTypingReq;
-}): Promise<void>;

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

@@ -1,18 +0,0 @@
-/** Subset of getConfig fields that we actually need; add new fields here as needed. */
-export interface CachedConfig {
-    typingTicket: string;
-}
-/**
- * Per-user getConfig cache with periodic random refresh (within 24h) and
- * exponential-backoff retry (up to 1h) on failure.
- */
-export declare class WeixinConfigManager {
-    private apiOpts;
-    private log;
-    private cache;
-    constructor(apiOpts: {
-        baseUrl: string;
-        token?: string;
-    }, log: (msg: string) => void);
-    getForUser(userId: string, contextToken?: string): Promise<CachedConfig>;
-}

package/dist/weixin/api/session-guard.d.ts

@@ -1,17 +0,0 @@
-/** Error code returned by the server when the bot session has expired. */
-export declare const SESSION_EXPIRED_ERRCODE = -14;
-/** Pause all inbound/outbound API calls for `accountId` for one hour. */
-export declare function pauseSession(accountId: string): void;
-/** Returns `true` when the bot is still within its one-hour cooldown window. */
-export declare function isSessionPaused(accountId: string): boolean;
-/** Milliseconds remaining until the pause expires (0 when not paused). */
-export declare function getRemainingPauseMs(accountId: string): number;
-/** Clear the session pause for a specific account. Used when fresh credentials are detected. */
-export declare function resetSessionPause(accountId: string): void;
-/** Throw if the session is currently paused. Call before any API request. */
-export declare function assertSessionActive(accountId: string): void;
-/**
- * Reset internal state — only for tests.
- * @internal
- */
-export declare function _resetForTest(): void;