@co0ontty/wand 0.2.0 → 0.3.0

package/dist/server.js

@@ -1,5 +1,5 @@
 import express from "express";
-import { readdir } from "node:fs/promises";
+import { readdir, readFile, stat } from "node:fs/promises";
 import { createServer as createHttpServer } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
 import { exec } from "node:child_process";
@@ -11,13 +11,60 @@ const execAsync = promisify(exec);
 import { createSession, revokeSession, setAuthStorage, validateSession } from "./auth.js";
 import { ensureCertificates } from "./cert.js";
 import { isExecutionMode, resolveConfigDir } from "./config.js";
-import { ProcessManager } from "./process-manager.js";
+import { ProcessManager, SessionInputError } from "./process-manager.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
-import { renderApp } from "./web-ui.js";
+import { renderApp } from "./web-ui/index.js";
 import { parseMessages } from "./message-parser.js";
 function getErrorMessage(error, fallback) {
     return error instanceof Error ? error.message : fallback;
 }
+function getInputErrorResponse(error, sessionId) {
+    if (error instanceof SessionInputError) {
+        const statusCode = error.code === "SESSION_NOT_FOUND" ? 404 : 409;
+        return {
+            statusCode,
+            payload: {
+                error: error.message,
+                errorCode: error.code,
+                sessionId,
+                sessionStatus: error.sessionStatus ?? null
+            }
+        };
+    }
+    return {
+        statusCode: 400,
+        payload: {
+            error: getErrorMessage(error, "会话已结束，请启动新会话。"),
+            errorCode: "INPUT_SEND_FAILED",
+            sessionId,
+            sessionStatus: null
+        }
+    };
+}
+function getInputDebugMeta(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
+    return { error };
+}
+function isPathWithinBase(targetPath, basePath) {
+    const relativePath = path.relative(basePath, targetPath);
+    return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+const BLOCKED_FOLDER_PATHS = ["/etc", "/root", "/boot"];
+function isBlockedFolderPath(targetPath) {
+    return BLOCKED_FOLDER_PATHS.some((blockedPath) => {
+        const relativePath = path.relative(blockedPath, targetPath);
+        return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+    });
+}
+function normalizeFolderPath(inputPath) {
+    return path.resolve(inputPath);
+}
 /**
  * Check if a directory is inside a git repository
  */
@@ -199,25 +246,41 @@ export async function startServer(config, configPath) {
     // PWA manifest
     app.get("/manifest.json", (_req, res) => {
         res.type("json").send(JSON.stringify({
+            id: "/",
+            scope: "/",
             name: "Wand Console",
             short_name: "Wand",
             description: "Local CLI Console for Vibe Coding",
             start_url: "/",
             display: "standalone",
+            display_override: ["standalone", "minimal-ui", "browser"],
             background_color: "#f6f1e8",
             theme_color: "#c5653d",
             orientation: "any",
             icons: [
-                { src: "/icon-192.png", sizes: "192x192", type: "image/png", purpose: "any maskable" },
-                { src: "/icon-512.png", sizes: "512x512", type: "image/png", purpose: "any maskable" }
+                { src: "/icon.svg", sizes: "any", type: "image/svg+xml", purpose: "any maskable" },
+                { src: "/icon-192.png", sizes: "192x192", type: "image/png", purpose: "any" },
+                { src: "/icon-512.png", sizes: "512x512", type: "image/png", purpose: "any" }
             ],
             categories: ["developer tools", "productivity"],
             shortcuts: [
                 { name: "New Session", short_name: "New", url: "/?action=new", description: "Start a new CLI session" }
-            ]
+            ],
+            // iOS Safari specific
+            ios: {
+                statusBarStyle: "black-translucent"
+            },
+            // Android Chrome specific
+            share_target: {
+                action: "/",
+                method: "GET",
+                params: {
+                    text: "q",
+                    url: "url"
+                }
+            }
         }));
     });
-    // PWA icons (SVG data URL converted to simple PNG-like response)
     const iconSvg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 192 192">
     <defs><linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%">
       <stop offset="0%" style="stop-color:#d77a52"/>
@@ -226,51 +289,102 @@ export async function startServer(config, configPath) {
     <rect width="192" height="192" rx="38" fill="url(#g)"/>
     <text x="96" y="128" text-anchor="middle" font-family="system-ui,sans-serif" font-size="88" font-weight="700" fill="white">W</text>
   </svg>`;
-    app.get("/icon-192.png", (_req, res) => {
+    app.get("/icon.svg", (_req, res) => {
         res.type("svg").send(iconSvg);
     });
+    app.get("/icon-192.png", (_req, res) => {
+        res.redirect(302, "/icon.svg");
+    });
     app.get("/icon-512.png", (_req, res) => {
-        res.type("svg").send(iconSvg);
+        res.redirect(302, "/icon.svg");
     });
     // Service Worker for offline support
     app.get("/sw.js", (_req, res) => {
         res.type("javascript").send(`
-const CACHE_NAME = 'wand-v1';
+const STATIC_CACHE = 'wand-static-v2';
+const RUNTIME_CACHE = 'wand-runtime-v2';
+const APP_SHELL = '/';
 const STATIC_ASSETS = [
-  '/',
+  APP_SHELL,
+  '/manifest.json',
+  '/icon.svg',
   '/vendor/xterm/css/xterm.css',
   '/vendor/xterm/lib/xterm.js',
   '/vendor/xterm-addon-fit/lib/addon-fit.js'
 ];
 
 self.addEventListener('install', (event) => {
-  event.waitUntil(caches.open(CACHE_NAME).then((cache) => cache.addAll(STATIC_ASSETS)));
+  event.waitUntil(caches.open(STATIC_CACHE).then((cache) => cache.addAll(STATIC_ASSETS)));
   self.skipWaiting();
 });
 
 self.addEventListener('activate', (event) => {
-  event.waitUntil(caches.keys().then((keys) => Promise.all(keys.filter((k) => k !== CACHE_NAME).map((k) => caches.delete(k)))));
+  event.waitUntil(
+    caches.keys().then((keys) => Promise.all(
+      keys
+        .filter((key) => key !== STATIC_CACHE && key !== RUNTIME_CACHE)
+        .map((key) => caches.delete(key))
+    ))
+  );
   self.clients.claim();
 });
 
+async function cacheFirst(request) {
+  const cached = await caches.match(request);
+  if (cached) return cached;
+
+  const response = await fetch(request);
+  if (response.ok && request.method === 'GET') {
+    const clone = response.clone();
+    const cache = await caches.open(RUNTIME_CACHE);
+    cache.put(request, clone);
+  }
+  return response;
+}
+
 self.addEventListener('fetch', (event) => {
-  const url = new URL(event.request.url);
-  // API calls should always go to network
+  const request = event.request;
+  const url = new URL(request.url);
+
+  if (request.method !== 'GET') {
+    return;
+  }
+
   if (url.pathname.startsWith('/api/')) {
-    event.respondWith(fetch(event.request).catch(() => new Response(JSON.stringify({ error: 'Offline' }), { status: 503, headers: { 'Content-Type': 'application/json' } })));
+    event.respondWith(
+      fetch(request).catch(() => new Response(JSON.stringify({ error: 'Offline' }), {
+        status: 503,
+        headers: { 'Content-Type': 'application/json' }
+      }))
+    );
     return;
   }
-  // Static assets: cache first, network fallback
-  event.respondWith(caches.match(event.request).then((cached) => cached || fetch(event.request).then((response) => {
-    if (response.ok && event.request.method === 'GET') {
-      const clone = response.clone();
-      caches.open(CACHE_NAME).then((cache) => cache.put(event.request, clone));
-    }
-    return response;
-  }).catch(() => caches.match('/'))));
+
+  if (request.mode === 'navigate') {
+    event.respondWith(
+      fetch(request)
+        .then((response) => {
+          const clone = response.clone();
+          caches.open(RUNTIME_CACHE).then((cache) => cache.put(APP_SHELL, clone));
+          return response;
+        })
+        .catch(async () => (await caches.match(APP_SHELL)) || Response.error())
+    );
+    return;
+  }
+
+  event.respondWith(
+    cacheFirst(request).catch(async () => {
+      const cached = await caches.match(request);
+      return cached || (await caches.match(APP_SHELL)) || Response.error();
+    })
+  );
 });
 `);
     });
+    app.get("/offline", (_req, res) => {
+        res.type("html").send(renderApp(configPath));
+    });
     app.post("/api/login", (req, res) => {
         const clientIp = req.ip || req.socket.remoteAddress || "unknown";
         if (!checkRateLimit(clientIp)) {
@@ -340,7 +454,7 @@ self.addEventListener('fetch', (event) => {
         const targetPath = path.resolve(process.cwd(), q);
         // Security check: ensure the resolved path is within the current working directory
         const allowedBase = process.cwd();
-        if (!targetPath.startsWith(allowedBase)) {
+        if (!isPathWithinBase(targetPath, allowedBase)) {
             res.status(403).json({ error: "访问被拒绝：路径必须在项目目录内。" });
             return;
         }
@@ -371,17 +485,100 @@ self.addEventListener('fetch', (event) => {
             res.status(400).json({ error: getErrorMessage(error, "无法读取目录。可能原因：路径不存在或权限不足。") });
         }
     });
+    // File preview API - reads file contents with size limit
+    const MAX_FILE_SIZE = 512 * 1024; // 512KB limit
+    app.get("/api/file-preview", async (req, res) => {
+        const filePath = typeof req.query.path === "string" ? req.query.path : "";
+        if (!filePath) {
+            res.status(400).json({ error: "Missing path parameter" });
+            return;
+        }
+        const resolvedPath = path.resolve(filePath);
+        const allowedBase = process.cwd();
+        if (!isPathWithinBase(resolvedPath, allowedBase)) {
+            res.status(403).json({ error: "Access denied" });
+            return;
+        }
+        try {
+            const fileStat = await stat(resolvedPath);
+            if (fileStat.isDirectory()) {
+                res.status(400).json({ error: "Cannot preview a directory" });
+                return;
+            }
+            if (fileStat.size > MAX_FILE_SIZE) {
+                res.status(413).json({ error: "File too large", truncated: true, size: fileStat.size, maxSize: MAX_FILE_SIZE });
+                return;
+            }
+            const ext = path.extname(filePath).toLowerCase();
+            const previewableExts = [
+                // Markdown
+                ".md", ".markdown", ".mdown", ".mkd", ".mkdn",
+                // Code
+                ".ts", ".tsx", ".js", ".jsx", ".json", ".html", ".css", ".scss", ".less",
+                ".py", ".rb", ".go", ".rs", ".java", ".c", ".cpp", ".h", ".hpp",
+                ".cs", ".swift", ".kt", ".scala", ".php", ".sh", ".bash", ".zsh",
+                ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf", ".env",
+                ".xml", ".sql", ".graphql", ".proto",
+                ".dockerfile", ".gitignore", ".env", ".editorconfig",
+                ".mdx", ".vue", ".svelte",
+                // Text
+                ".txt", ".log", ".diff", ".patch"
+            ];
+            const isText = previewableExts.includes(ext) ||
+                ext === "" ||
+                [".gitignore", "dockerfile", ".env.local", ".env.development"].some(e => filePath.toLowerCase().endsWith(e));
+            if (!isText) {
+                res.status(415).json({ error: "Unsupported file type", ext });
+                return;
+            }
+            const content = await readFile(resolvedPath, "utf-8");
+            const lang = getLanguageFromExt(ext, filePath);
+            res.json({
+                path: resolvedPath,
+                name: path.basename(filePath),
+                ext,
+                lang,
+                content,
+                size: fileStat.size
+            });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "Failed to read file") });
+        }
+    });
+    // Helper to detect language from extension
+    function getLanguageFromExt(ext, filePath) {
+        const map = {
+            ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx",
+            ".json": "json", ".html": "html", ".htm": "html",
+            ".css": "css", ".scss": "scss", ".less": "less",
+            ".py": "python", ".rb": "ruby", ".go": "go", ".rs": "rust",
+            ".java": "java", ".c": "c", ".cpp": "cpp", ".h": "c", ".hpp": "cpp",
+            ".cs": "csharp", ".swift": "swift", ".kt": "kotlin", ".scala": "scala",
+            ".php": "php", ".sh": "bash", ".bash": "bash", ".zsh": "bash",
+            ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".ini": "ini",
+            ".xml": "xml", ".sql": "sql", ".graphql": "graphql",
+            ".md": "markdown", ".markdown": "markdown", ".mdown": "markdown",
+            ".mkd": "markdown", ".mkdn": "markdown",
+            ".dockerfile": "dockerfile", ".gitignore": "plaintext",
+            ".diff": "diff", ".patch": "diff", ".proto": "protobuf",
+            ".env": "bash", ".editorconfig": "ini",
+            ".mdx": "markdown", ".vue": "html", ".svelte": "html"
+        };
+        const baseName = path.basename(filePath).toLowerCase();
+        if (baseName === "dockerfile")
+            return "dockerfile";
+        if (baseName === ".gitignore")
+            return "plaintext";
+        return map[ext] || "plaintext";
+    }
     // Folder picker API - starts from /tmp by default, supports navigation
     app.get("/api/folders", async (req, res) => {
         const q = typeof req.query.q === "string" ? req.query.q : "/tmp";
-        const targetPath = path.resolve(q);
-        // Security check: prevent accessing sensitive system paths
-        const blockedPaths = ['/etc', '/root', '/boot'];
-        for (const blocked of blockedPaths) {
-            if (targetPath.startsWith(blocked)) {
-                res.status(403).json({ error: "访问被拒绝：无法访问系统敏感目录。" });
-                return;
-            }
+        const targetPath = normalizeFolderPath(q);
+        if (isBlockedFolderPath(targetPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法访问系统敏感目录。" });
+            return;
         }
         try {
             const entries = await readdir(targetPath, { withFileTypes: true });
@@ -436,10 +633,22 @@ self.addEventListener('fetch', (event) => {
         ];
         res.json(quickPaths);
     });
+    function parseStoredPathList(raw) {
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
     app.get("/api/favorite-paths", (_req, res) => {
         const stored = storage.getConfigValue("favorite_paths");
-        const favorites = stored ? JSON.parse(stored) : [];
-        res.json(favorites);
+        const favorites = parseStoredPathList(stored);
+        res.json(favorites.filter((favorite) => !isBlockedFolderPath(normalizeFolderPath(favorite.path))));
     });
     app.post("/api/favorite-paths", (req, res) => {
         const { path: favPath, name, icon } = req.body;
@@ -447,16 +656,21 @@ self.addEventListener('fetch', (event) => {
             res.status(400).json({ error: "路径不能为空。" });
             return;
         }
+        const resolvedFavoritePath = normalizeFolderPath(favPath);
+        if (isBlockedFolderPath(resolvedFavoritePath)) {
+            res.status(403).json({ error: "访问被拒绝：无法收藏系统敏感目录。" });
+            return;
+        }
         const stored = storage.getConfigValue("favorite_paths");
-        const favorites = stored ? JSON.parse(stored) : [];
+        const favorites = parseStoredPathList(stored);
         // Check if already exists
-        if (favorites.some((f) => f.path === favPath)) {
+        if (favorites.some((f) => normalizeFolderPath(f.path) === resolvedFavoritePath)) {
             res.status(400).json({ error: "该路径已在收藏列表中。" });
             return;
         }
         const newFavorite = {
-            path: favPath,
-            name: name || path.basename(favPath),
+            path: resolvedFavoritePath,
+            name: name || path.basename(resolvedFavoritePath),
             icon: icon || "⭐",
             addedAt: new Date().toISOString()
         };
@@ -471,7 +685,7 @@ self.addEventListener('fetch', (event) => {
             return;
         }
         const stored = storage.getConfigValue("favorite_paths");
-        const favorites = stored ? JSON.parse(stored) : [];
+        const favorites = parseStoredPathList(stored);
         const index = favorites.findIndex((f) => f.path === delPath);
         if (index === -1) {
             res.status(404).json({ error: "未找到该收藏路径。" });
@@ -484,8 +698,8 @@ self.addEventListener('fetch', (event) => {
     const MAX_RECENT_PATHS = 10;
     app.get("/api/recent-paths", (_req, res) => {
         const stored = storage.getConfigValue("recent_paths");
-        const recent = stored ? JSON.parse(stored) : [];
-        res.json(recent);
+        const recent = parseStoredPathList(stored);
+        res.json(recent.filter((item) => !isBlockedFolderPath(normalizeFolderPath(item.path))));
     });
     app.post("/api/recent-paths", (req, res) => {
         const { path: usedPath } = req.body;
@@ -493,14 +707,19 @@ self.addEventListener('fetch', (event) => {
             res.status(400).json({ error: "路径不能为空。" });
             return;
         }
+        const resolvedRecentPath = normalizeFolderPath(usedPath);
+        if (isBlockedFolderPath(resolvedRecentPath)) {
+            res.status(403).json({ error: "访问被拒绝：无法保存系统敏感目录。" });
+            return;
+        }
         const stored = storage.getConfigValue("recent_paths");
-        let recent = stored ? JSON.parse(stored) : [];
+        let recent = parseStoredPathList(stored);
         // Remove existing entry for this path (to update position)
-        recent = recent.filter((r) => r.path !== usedPath);
+        recent = recent.filter((r) => normalizeFolderPath(r.path) !== resolvedRecentPath);
         // Add to front
         const newRecent = {
-            path: usedPath,
-            name: path.basename(usedPath),
+            path: resolvedRecentPath,
+            name: path.basename(resolvedRecentPath),
             lastUsedAt: new Date().toISOString()
         };
         recent.unshift(newRecent);
@@ -517,7 +736,11 @@ self.addEventListener('fetch', (event) => {
             return;
         }
         try {
-            const resolvedPath = path.resolve(inputPath);
+            const resolvedPath = normalizeFolderPath(inputPath);
+            if (isBlockedFolderPath(resolvedPath)) {
+                res.json({ valid: false, error: "访问被拒绝：无法访问系统敏感目录。", resolvedPath });
+                return;
+            }
             const stats = await import("node:fs/promises").then(fs => fs.stat(resolvedPath));
             if (!stats.isDirectory()) {
                 res.json({ valid: false, error: "路径不是目录", resolvedPath });
@@ -554,7 +777,7 @@ self.addEventListener('fetch', (event) => {
         // Security check: ensure cwd is within allowed base
         const allowedBase = process.cwd();
         const resolvedCwd = path.resolve(allowedBase, cwd);
-        if (!resolvedCwd.startsWith(allowedBase)) {
+        if (!isPathWithinBase(resolvedCwd, allowedBase)) {
             res.status(403).json({ error: "访问被拒绝：路径必须在项目目录内。" });
             return;
         }
@@ -614,7 +837,7 @@ self.addEventListener('fetch', (event) => {
             return;
         }
         if (req.query.format === "chat") {
-            // Prefer structured messages from JSON chat mode, fall back to PTY parsing
+            // Prefer PTY-derived structured messages, fall back to parsing raw output
             const messages = snapshot.messages && snapshot.messages.length > 0
                 ? snapshot.messages
                 : parseMessages(snapshot.output);
@@ -639,14 +862,77 @@ self.addEventListener('fetch', (event) => {
             res.status(400).json({ error: getErrorMessage(error, "无法启动命令。请检查命令是否正确安装。") });
         }
     });
+    // Resume a session with a different mode (e.g., switch from terminal to chat)
+    app.post("/api/sessions/:id/resume", (req, res) => {
+        const sessionId = req.params.id;
+        const body = req.body;
+        try {
+            const existingSession = processes.get(sessionId);
+            if (!existingSession) {
+                res.status(404).json({ error: "会话不存在。" });
+                return;
+            }
+            if (existingSession.status !== "running") {
+                res.status(400).json({ error: "会话已结束，无法恢复。" });
+                return;
+            }
+            // Get the Claude session ID for resuming
+            const claudeSessionId = existingSession.claudeSessionId;
+            if (!claudeSessionId) {
+                res.status(400).json({ error: "此会话没有 Claude 会话 ID，无法恢复。" });
+                return;
+            }
+            // Determine the new mode
+            const newMode = normalizeMode(body.mode, config.defaultMode);
+            // Build the resume command
+            const command = existingSession.command;
+            const isClaude = /^claude\b/.test(command);
+            if (!isClaude) {
+                res.status(400).json({ error: "只有 Claude 命令支持恢复功能。" });
+                return;
+            }
+            // Create a new session with --resume flag
+            const resumeCommand = `${command} --resume ${claudeSessionId}`;
+            const snapshot = processes.start(resumeCommand, existingSession.cwd, newMode, undefined);
+            // Copy the Claude session ID to the new session
+            // This is done internally by the process manager when it detects --resume
+            res.status(201).json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法恢复会话。") });
+        }
+    });
     app.post("/api/sessions/:id/input", (req, res) => {
         const body = req.body;
+        const sessionId = req.params.id;
+        const input = body.input ?? "";
+        const view = body.view;
+        console.error("[wand] Input request received", {
+            sessionId,
+            inputLength: input.length,
+            view: view ?? "chat"
+        });
         try {
-            const snapshot = processes.sendInput(req.params.id, body.input ?? "", body.view);
+            const snapshot = processes.sendInput(sessionId, input, view);
+            console.error("[wand] Input request succeeded", {
+                sessionId,
+                status: snapshot.status,
+                inputLength: input.length,
+                view: view ?? "chat"
+            });
             res.json(snapshot);
         }
         catch (error) {
-            res.status(400).json({ error: getErrorMessage(error, "会话已结束，请启动新会话。") });
+            const response = getInputErrorResponse(error, sessionId);
+            console.error("[wand] Input request failed", {
+                sessionId,
+                inputLength: input.length,
+                view: view ?? "chat",
+                responseStatus: response.statusCode,
+                responsePayload: response.payload,
+                error: getInputDebugMeta(error)
+            });
+            res.status(response.statusCode).json(response.payload);
         }
     });
     app.post("/api/sessions/:id/resize", (req, res) => {
@@ -659,6 +945,35 @@ self.addEventListener('fetch', (event) => {
             res.status(400).json({ error: getErrorMessage(error, "无法调整终端大小。") });
         }
     });
+    app.post("/api/sessions/:id/approve-permission", (req, res) => {
+        try {
+            const snapshot = processes.approvePermission(req.params.id);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法批准该授权请求。") });
+        }
+    });
+    app.post("/api/sessions/:id/deny-permission", (req, res) => {
+        try {
+            const snapshot = processes.denyPermission(req.params.id);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法拒绝该授权请求。") });
+        }
+    });
+    app.post("/api/sessions/:id/escalations/:requestId/resolve", (req, res) => {
+        try {
+            const { requestId } = req.params;
+            const body = req.body;
+            const snapshot = processes.resolveEscalation(req.params.id, requestId, body.resolution);
+            res.json(snapshot);
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法处理该授权请求。") });
+        }
+    });
     app.post("/api/sessions/:id/stop", (req, res) => {
         try {
             const snapshot = processes.stop(req.params.id);

package/dist/session-lifecycle.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Session Lifecycle Manager
+ * Inspired by Happy's session lifecycle management
+ */
+import type { SessionLifecycleState, SessionLifecycle } from "./types.js";
+export interface SessionLifecycleEvents {
+    onStateChange?: (sessionId: string, oldState: SessionLifecycleState, newState: SessionLifecycleState) => void;
+    onIdle?: (sessionId: string) => void;
+    onArchived?: (sessionId: string, reason: string) => void;
+}
+export declare class SessionLifecycleManager {
+    private sessions;
+    private events;
+    private idleTimeout;
+    private archiveTimeout;
+    private checkInterval;
+    constructor(events?: SessionLifecycleEvents, options?: {
+        idleTimeout?: number;
+        archiveTimeout?: number;
+    });
+    /**
+     * Register a new session
+     */
+    register(sessionId: string, initialState?: SessionLifecycleState): void;
+    /**
+     * Update session state
+     */
+    setState(sessionId: string, newState: SessionLifecycleState): void;
+    /**
+     * Update last activity timestamp
+     */
+    touch(sessionId: string): void;
+    /**
+     * Mark session as thinking
+     */
+    startThinking(sessionId: string): void;
+    /**
+     * Mark session as done thinking
+     */
+    stopThinking(sessionId: string): void;
+    /**
+     * Mark session as waiting for input
+     */
+    waitingInput(sessionId: string): void;
+    /**
+     * Archive a session
+     */
+    archive(sessionId: string, reason: string, by?: "user" | "timeout" | "error"): void;
+    /**
+     * Unregister a session
+     */
+    unregister(sessionId: string): void;
+    /**
+     * Get session lifecycle
+     */
+    get(sessionId: string): SessionLifecycle | undefined;
+    /**
+     * Get all sessions
+     */
+    getAll(): Map<string, SessionLifecycle>;
+    /**
+     * Get sessions by state
+     */
+    getByState(state: SessionLifecycleState): string[];
+    /**
+     * Start periodic check for idle/archived sessions
+     */
+    private startPeriodicCheck;
+    /**
+     * Stop periodic check
+     */
+    stopPeriodicCheck(): void;
+    /**
+     * Check sessions for idle/archived status
+     */
+    private checkSessions;
+    /**
+     * Cleanup all sessions
+     */
+    cleanup(): void;
+}