@co0ontty/wand 0.2.0 → 0.3.0

package/dist/session-lifecycle.js

@@ -0,0 +1,176 @@
+/**
+ * Session Lifecycle Manager
+ * Inspired by Happy's session lifecycle management
+ */
+export class SessionLifecycleManager {
+    sessions = new Map();
+    events;
+    idleTimeout;
+    archiveTimeout;
+    checkInterval = null;
+    constructor(events = {}, options = {}) {
+        this.events = events;
+        this.idleTimeout = options.idleTimeout ?? 5 * 60 * 1000; // 5 minutes
+        this.archiveTimeout = options.archiveTimeout ?? 30 * 60 * 1000; // 30 minutes
+        // Start periodic check
+        this.startPeriodicCheck();
+    }
+    /**
+     * Register a new session
+     */
+    register(sessionId, initialState = "initializing") {
+        const lifecycle = {
+            state: initialState,
+            stateSince: Date.now(),
+            lastActivityAt: Date.now(),
+        };
+        this.sessions.set(sessionId, lifecycle);
+        console.error(`[Lifecycle] Session ${sessionId} registered with state: ${initialState}`);
+    }
+    /**
+     * Update session state
+     */
+    setState(sessionId, newState) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (!lifecycle) {
+            console.error(`[Lifecycle] Session ${sessionId} not found`);
+            return;
+        }
+        const oldState = lifecycle.state;
+        if (oldState === newState) {
+            return;
+        }
+        lifecycle.state = newState;
+        lifecycle.stateSince = Date.now();
+        lifecycle.lastActivityAt = Date.now();
+        console.error(`[Lifecycle] Session ${sessionId} state changed: ${oldState} -> ${newState}`);
+        // Emit state change event
+        this.events.onStateChange?.(sessionId, oldState, newState);
+    }
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (lifecycle) {
+            lifecycle.lastActivityAt = Date.now();
+        }
+    }
+    /**
+     * Mark session as thinking
+     */
+    startThinking(sessionId) {
+        this.setState(sessionId, "thinking");
+    }
+    /**
+     * Mark session as done thinking
+     */
+    stopThinking(sessionId) {
+        const lifecycle = this.sessions.get(sessionId);
+        if (lifecycle?.state === "thinking") {
+            this.setState(sessionId, "idle");
+        }
+    }
+    /**
+     * Mark session as waiting for input
+     */
+    waitingInput(sessionId) {
+        this.setState(sessionId, "waiting-input");
+    }
+    /**
+     * Archive a session
+     */
+    archive(sessionId, reason, by = "user") {
+        const lifecycle = this.sessions.get(sessionId);
+        if (!lifecycle) {
+            return;
+        }
+        lifecycle.state = "archived";
+        lifecycle.stateSince = Date.now();
+        lifecycle.archivedBy = by;
+        lifecycle.archiveReason = reason;
+        console.error(`[Lifecycle] Session ${sessionId} archived: ${reason} (by: ${by})`);
+        // Emit archived event
+        this.events.onArchived?.(sessionId, reason);
+    }
+    /**
+     * Unregister a session
+     */
+    unregister(sessionId) {
+        this.sessions.delete(sessionId);
+        console.error(`[Lifecycle] Session ${sessionId} unregistered`);
+    }
+    /**
+     * Get session lifecycle
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Get all sessions
+     */
+    getAll() {
+        return new Map(this.sessions);
+    }
+    /**
+     * Get sessions by state
+     */
+    getByState(state) {
+        const result = [];
+        for (const [sessionId, lifecycle] of this.sessions) {
+            if (lifecycle.state === state) {
+                result.push(sessionId);
+            }
+        }
+        return result;
+    }
+    /**
+     * Start periodic check for idle/archived sessions
+     */
+    startPeriodicCheck() {
+        if (this.checkInterval) {
+            return;
+        }
+        this.checkInterval = setInterval(() => {
+            this.checkSessions();
+        }, 60 * 1000); // Check every minute
+    }
+    /**
+     * Stop periodic check
+     */
+    stopPeriodicCheck() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+    /**
+     * Check sessions for idle/archived status
+     */
+    checkSessions() {
+        const now = Date.now();
+        for (const [sessionId, lifecycle] of this.sessions) {
+            if (lifecycle.state === "archived") {
+                continue;
+            }
+            const timeSinceLastActivity = now - lifecycle.lastActivityAt;
+            // Check for archive timeout
+            if (timeSinceLastActivity > this.archiveTimeout) {
+                this.archive(sessionId, "Session timed out", "timeout");
+                continue;
+            }
+            // Check for idle timeout
+            if (timeSinceLastActivity > this.idleTimeout && lifecycle.state !== "idle") {
+                this.setState(sessionId, "idle");
+                this.events.onIdle?.(sessionId);
+            }
+        }
+    }
+    /**
+     * Cleanup all sessions
+     */
+    cleanup() {
+        this.stopPeriodicCheck();
+        this.sessions.clear();
+    }
+}

package/dist/storage.js

@@ -1,6 +1,17 @@
 import { existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+function parseStoredMessages(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
 export const DEFAULT_DB_FILE = "wand.db";
 export function resolveDatabasePath(configPath) {
     return path.resolve(path.dirname(configPath), DEFAULT_DB_FILE);
@@ -156,7 +167,7 @@ export class WandStorage {
             archived: Boolean(row.archived),
             archivedAt: row.archived_at,
             claudeSessionId: row.claude_session_id,
-            messages: row.messages ? JSON.parse(row.messages) : undefined
+            messages: parseStoredMessages(row.messages)
         }));
     }
     deleteSession(id) {

package/dist/types.d.ts

@@ -1,4 +1,28 @@
-export type ExecutionMode = "auto-edit" | "default" | "full-access" | "native" | "managed";
+export type ExecutionMode = "assist" | "agent" | "agent-max" | "default" | "auto-edit" | "full-access" | "native" | "managed";
+export type AutonomyPolicy = "assist" | "agent" | "agent-max";
+export type ApprovalPolicy = "ask-every-time" | "approve-once" | "remember-this-turn";
+export type EscalationScope = "write_file" | "run_command" | "network" | "outside_workspace" | "dangerous_shell" | "unknown";
+export type EscalationRunner = "json" | "pty";
+export type EscalationResolution = "approve_once" | "approve_turn" | "deny" | "fallback_manual";
+export type EscalationSource = "tool_permission_request" | "sandbox_hard_block" | "workspace_policy_limit" | "cli_capability_limit" | "unknown";
+export interface EscalationRequest {
+    requestId: string;
+    scope: EscalationScope;
+    runner: EscalationRunner;
+    source: EscalationSource;
+    resolution?: EscalationResolution;
+    target?: string;
+    reason: string;
+}
+export interface TurnRequest {
+    message: string;
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+}
+export interface EscalationDecisionRequest {
+    resolution?: Extract<EscalationResolution, "approve_once" | "approve_turn" | "deny">;
+}
 export interface CommandPreset {
     label: string;
     command: string;
@@ -25,8 +49,12 @@ export interface CommandRequest {
 }
 export interface InputRequest {
     input?: string;
-    /** Current UI view: "chat" or "terminal". Used to route via native pipeline in chat mode. */
+    /** Current UI view: "chat" or "terminal". Chat view uses PTY-derived structured messages. */
     view?: "chat" | "terminal";
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+    turn?: TurnRequest;
 }
 export interface ResizeRequest {
     cols?: number;
@@ -70,14 +98,17 @@ export interface ToolUseBlock {
 export interface ToolResultBlock {
     type: "tool_result";
     tool_use_id: string;
-    content: string;
+    content: string | Array<{
+        type: string;
+        [key: string]: unknown;
+    }>;
     is_error?: boolean;
 }
 export type ContentBlock = TextBlock | ThinkingBlock | ToolUseBlock | ToolResultBlock;
 export interface ConversationTurn {
     role: "user" | "assistant";
     content: ContentBlock[];
-    /** Token usage for this turn (native mode only) */
+    /** Optional usage metadata when available from the underlying tool. */
     usage?: {
         inputTokens?: number;
         outputTokens?: number;
@@ -91,6 +122,9 @@ export interface SessionSnapshot {
     command: string;
     cwd: string;
     mode: ExecutionMode;
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
     status: "running" | "exited" | "failed" | "stopped";
     exitCode: number | null;
     startedAt: string;
@@ -98,8 +132,74 @@ export interface SessionSnapshot {
     output: string;
     archived: boolean;
     archivedAt: string | null;
+    /** Backward-compatible derived flag from pendingEscalation */
+    permissionBlocked?: boolean;
+    pendingEscalation?: EscalationRequest | null;
+    lastEscalationResult?: {
+        requestId: string;
+        resolution: EscalationResolution;
+        reason: string;
+    } | null;
     /** Claude Code 会话 ID，用于 --resume 恢复会话 */
     claudeSessionId: string | null;
-    /** Structured conversation messages (from JSON chat mode) */
+    /** Structured conversation messages derived from PTY output. */
     messages?: ConversationTurn[];
+    /** Session lifecycle state */
+    lifecycleState?: "running" | "idle" | "archived";
+    /** Last activity timestamp */
+    lastActivityAt?: string;
+}
+export type SessionLifecycleState = "initializing" | "running" | "idle" | "thinking" | "waiting-input" | "archived";
+export interface SessionLifecycle {
+    state: SessionLifecycleState;
+    stateSince: number;
+    lastActivityAt: number;
+    archivedBy?: "user" | "timeout" | "error";
+    archiveReason?: string;
+}
+/** Unified event type emitted by ClaudePtyBridge for WebSocket broadcast */
+export type SessionEventType = "output.raw" | "output.chat" | "chat.turn" | "permission.prompt" | "permission.resolved" | "session.id" | "task" | "ended";
+export interface SessionEvent {
+    type: SessionEventType;
+    sessionId: string;
+    timestamp: number;
+    data?: unknown;
+}
+export interface RawOutputData {
+    chunk: string;
+    /** Full accumulated output for terminal view */
+    output: string;
+}
+export interface ChatOutputData {
+    /** Current messages array */
+    messages: ConversationTurn[];
+    /** Index of the message being streamed */
+    streamingIndex?: number;
+    /** Whether assistant is currently responding */
+    isResponding: boolean;
+}
+export interface ChatTurnData {
+    /** The completed turn */
+    turn: ConversationTurn;
+    /** Full messages array */
+    messages: ConversationTurn[];
+}
+export interface PermissionPromptData {
+    /** Detected prompt text */
+    prompt: string;
+    /** Inferred scope */
+    scope: EscalationScope;
+    /** Target if detected */
+    target?: string;
+}
+export interface SessionIdData {
+    /** Claude CLI session UUID */
+    claudeSessionId: string;
+}
+export interface TaskData {
+    title: string;
+    tool?: string;
+}
+export interface SessionEndData {
+    exitCode: number | null;
 }