@co0ontty/wand 0.2.0

package/dist/session-logger.d.ts

@@ -0,0 +1,23 @@
+import type { ConversationTurn } from "./types.js";
+/**
+ * SessionLogger saves raw session content to local files for debugging and analysis.
+ *
+ * Directory structure: .wand/sessions/{sessionId}/
+ *   - pty-output.log     Raw PTY output (append-only)
+ *   - stream-events.jsonl NDJSON events from native mode (append-only)
+ *   - messages.json       Final structured messages (overwritten on each update)
+ */
+export declare class SessionLogger {
+    private readonly baseDir;
+    private readonly dirs;
+    constructor(configDir: string);
+    private ensureDir;
+    /** Append raw PTY output chunk */
+    appendPtyOutput(sessionId: string, chunk: string): void;
+    /** Append a native mode NDJSON event */
+    appendStreamEvent(sessionId: string, event: unknown): void;
+    /** Save the current structured messages snapshot */
+    saveMessages(sessionId: string, messages: ConversationTurn[]): void;
+    /** Save session metadata */
+    saveMetadata(sessionId: string, meta: Record<string, unknown>): void;
+}

package/dist/session-logger.js

@@ -0,0 +1,78 @@
+import { mkdirSync, appendFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+/**
+ * SessionLogger saves raw session content to local files for debugging and analysis.
+ *
+ * Directory structure: .wand/sessions/{sessionId}/
+ *   - pty-output.log     Raw PTY output (append-only)
+ *   - stream-events.jsonl NDJSON events from native mode (append-only)
+ *   - messages.json       Final structured messages (overwritten on each update)
+ */
+export class SessionLogger {
+    baseDir;
+    dirs = new Map();
+    constructor(configDir) {
+        this.baseDir = path.join(configDir, "sessions");
+        try {
+            mkdirSync(this.baseDir, { recursive: true });
+        }
+        catch {
+            process.stderr.write(`[wand] Warning: Could not create session log dir: ${this.baseDir}\n`);
+        }
+    }
+    ensureDir(sessionId) {
+        let dir = this.dirs.get(sessionId);
+        if (dir)
+            return dir;
+        dir = path.join(this.baseDir, sessionId);
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+        this.dirs.set(sessionId, dir);
+        return dir;
+    }
+    /** Append raw PTY output chunk */
+    appendPtyOutput(sessionId, chunk) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            appendFileSync(path.join(dir, "pty-output.log"), chunk);
+        }
+        catch {
+            // Non-critical — don't let logging failures affect main flow
+        }
+    }
+    /** Append a native mode NDJSON event */
+    appendStreamEvent(sessionId, event) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            appendFileSync(path.join(dir, "stream-events.jsonl"), JSON.stringify(event) + "\n");
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /** Save the current structured messages snapshot */
+    saveMessages(sessionId, messages) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            writeFileSync(path.join(dir, "messages.json"), JSON.stringify(messages, null, 2) + "\n");
+        }
+        catch {
+            // Non-critical
+        }
+    }
+    /** Save session metadata */
+    saveMetadata(sessionId, meta) {
+        try {
+            const dir = this.ensureDir(sessionId);
+            writeFileSync(path.join(dir, "metadata.json"), JSON.stringify(meta, null, 2) + "\n");
+        }
+        catch {
+            // Non-critical
+        }
+    }
+}

package/dist/storage.d.ts

@@ -0,0 +1,32 @@
+import { SessionSnapshot } from "./types.js";
+export declare const DEFAULT_DB_FILE = "wand.db";
+export interface PersistedAuthSession {
+    token: string;
+    expiresAt: number;
+}
+export declare function resolveDatabasePath(configPath: string): string;
+export declare function ensureDatabaseFile(dbPath: string): boolean;
+export declare class WandStorage {
+    private readonly db;
+    constructor(dbPath: string);
+    close(): void;
+    /** Get a config value from database */
+    getConfigValue(key: string): string | null;
+    /** Set a config value in database */
+    setConfigValue(key: string, value: string): void;
+    /** Delete a config value */
+    deleteConfigValue(key: string): void;
+    /** Get password from database */
+    getPassword(): string | null;
+    /** Set password in database */
+    setPassword(password: string): void;
+    /** Check if password has been set (not default) */
+    hasCustomPassword(): boolean;
+    saveAuthSession(token: string, expiresAt: number): void;
+    getAuthSession(token: string): PersistedAuthSession | null;
+    deleteAuthSession(token: string): void;
+    deleteExpiredAuthSessions(now: number): void;
+    saveSession(snapshot: SessionSnapshot): void;
+    loadSessions(): SessionSnapshot[];
+    deleteSession(id: string): void;
+}

package/dist/storage.js

@@ -0,0 +1,181 @@
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export const DEFAULT_DB_FILE = "wand.db";
+export function resolveDatabasePath(configPath) {
+    return path.resolve(path.dirname(configPath), DEFAULT_DB_FILE);
+}
+const INIT_SQL = `
+  CREATE TABLE IF NOT EXISTS auth_sessions (
+    token TEXT PRIMARY KEY,
+    expires_at INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS command_sessions (
+    id TEXT PRIMARY KEY,
+    command TEXT NOT NULL,
+    cwd TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    status TEXT NOT NULL,
+    exit_code INTEGER,
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    output TEXT NOT NULL,
+    archived INTEGER NOT NULL DEFAULT 0,
+    archived_at TEXT,
+    claude_session_id TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS app_config (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  );
+`;
+export function ensureDatabaseFile(dbPath) {
+    mkdirSync(path.dirname(dbPath), { recursive: true });
+    const created = !existsSync(dbPath);
+    const db = new DatabaseSync(dbPath);
+    db.exec(INIT_SQL);
+    ensureCommandSessionSchema(db);
+    db.close();
+    return created;
+}
+export class WandStorage {
+    db;
+    constructor(dbPath) {
+        mkdirSync(path.dirname(dbPath), { recursive: true });
+        this.db = new DatabaseSync(dbPath);
+        this.db.exec(INIT_SQL);
+        ensureCommandSessionSchema(this.db);
+    }
+    close() {
+        this.db.close();
+    }
+    // ============ Config Methods ============
+    /** Get a config value from database */
+    getConfigValue(key) {
+        const row = this.db
+            .prepare("SELECT value FROM app_config WHERE key = ?")
+            .get(key);
+        return row?.value ?? null;
+    }
+    /** Set a config value in database */
+    setConfigValue(key, value) {
+        this.db
+            .prepare(`INSERT INTO app_config (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`)
+            .run(key, value);
+    }
+    /** Delete a config value */
+    deleteConfigValue(key) {
+        this.db.prepare("DELETE FROM app_config WHERE key = ?").run(key);
+    }
+    /** Get password from database */
+    getPassword() {
+        return this.getConfigValue("password");
+    }
+    /** Set password in database */
+    setPassword(password) {
+        this.setConfigValue("password", password);
+    }
+    /** Check if password has been set (not default) */
+    hasCustomPassword() {
+        return this.getPassword() !== null;
+    }
+    // ============ Auth Session Methods ============
+    saveAuthSession(token, expiresAt) {
+        this.db
+            .prepare(`INSERT INTO auth_sessions (token, expires_at)
+         VALUES (?, ?)
+         ON CONFLICT(token) DO UPDATE SET expires_at = excluded.expires_at`)
+            .run(token, expiresAt);
+    }
+    getAuthSession(token) {
+        const row = this.db
+            .prepare("SELECT token, expires_at FROM auth_sessions WHERE token = ?")
+            .get(token);
+        if (!row) {
+            return null;
+        }
+        return {
+            token: row.token,
+            expiresAt: row.expires_at
+        };
+    }
+    deleteAuthSession(token) {
+        this.db.prepare("DELETE FROM auth_sessions WHERE token = ?").run(token);
+    }
+    deleteExpiredAuthSessions(now) {
+        this.db.prepare("DELETE FROM auth_sessions WHERE expires_at < ?").run(now);
+    }
+    saveSession(snapshot) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db
+                .prepare(`INSERT INTO command_sessions (
+             id, command, cwd, mode, status, exit_code, started_at, ended_at, output
+             , archived, archived_at, claude_session_id, messages
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             command = excluded.command,
+             cwd = excluded.cwd,
+             mode = excluded.mode,
+             status = excluded.status,
+             exit_code = excluded.exit_code,
+             started_at = excluded.started_at,
+             ended_at = excluded.ended_at,
+             output = excluded.output,
+             archived = excluded.archived,
+             archived_at = excluded.archived_at,
+             claude_session_id = excluded.claude_session_id,
+             messages = excluded.messages`)
+                .run(snapshot.id, snapshot.command, snapshot.cwd, snapshot.mode, snapshot.status, snapshot.exitCode, snapshot.startedAt, snapshot.endedAt, snapshot.output, snapshot.archived ? 1 : 0, snapshot.archivedAt, snapshot.claudeSessionId, snapshot.messages ? JSON.stringify(snapshot.messages) : null);
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    loadSessions() {
+        const rows = this.db
+            .prepare(`SELECT id, command, cwd, mode, status, exit_code, started_at, ended_at, output, archived, archived_at, claude_session_id, messages
+         FROM command_sessions
+         ORDER BY started_at DESC`)
+            .all();
+        return rows.map((row) => ({
+            id: row.id,
+            command: row.command,
+            cwd: row.cwd,
+            mode: row.mode,
+            status: row.status,
+            exitCode: row.exit_code,
+            startedAt: row.started_at,
+            endedAt: row.ended_at,
+            output: row.output,
+            archived: Boolean(row.archived),
+            archivedAt: row.archived_at,
+            claudeSessionId: row.claude_session_id,
+            messages: row.messages ? JSON.parse(row.messages) : undefined
+        }));
+    }
+    deleteSession(id) {
+        this.db.prepare("DELETE FROM command_sessions WHERE id = ?").run(id);
+    }
+}
+function ensureCommandSessionSchema(db) {
+    const columns = db.prepare("PRAGMA table_info(command_sessions)").all();
+    const names = new Set(columns.map((column) => column.name));
+    if (!names.has("archived")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN archived INTEGER NOT NULL DEFAULT 0");
+    }
+    if (!names.has("archived_at")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN archived_at TEXT");
+    }
+    if (!names.has("claude_session_id")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN claude_session_id TEXT");
+    }
+    if (!names.has("messages")) {
+        db.exec("ALTER TABLE command_sessions ADD COLUMN messages TEXT");
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,105 @@
+export type ExecutionMode = "auto-edit" | "default" | "full-access" | "native" | "managed";
+export interface CommandPreset {
+    label: string;
+    command: string;
+    mode?: ExecutionMode;
+}
+export interface WandConfig {
+    host: string;
+    port: number;
+    /** Enable HTTPS with self-signed certificate (default: true) */
+    https?: boolean;
+    password: string;
+    defaultMode: ExecutionMode;
+    shell: string;
+    defaultCwd: string;
+    startupCommands: string[];
+    allowedCommandPrefixes: string[];
+    commandPresets: CommandPreset[];
+}
+export interface CommandRequest {
+    command: string;
+    cwd?: string;
+    mode?: ExecutionMode;
+    initialInput?: string;
+}
+export interface InputRequest {
+    input?: string;
+    /** Current UI view: "chat" or "terminal". Used to route via native pipeline in chat mode. */
+    view?: "chat" | "terminal";
+}
+export interface ResizeRequest {
+    cols?: number;
+    rows?: number;
+}
+export interface PathSuggestion {
+    path: string;
+    name: string;
+    isDirectory: boolean;
+}
+export interface GitFileStatus {
+    staged?: 'modified' | 'added' | 'deleted' | 'renamed';
+    unstaged?: 'modified' | 'deleted';
+    untracked?: boolean;
+}
+export interface FileEntry {
+    path: string;
+    name: string;
+    type: 'dir' | 'file';
+    gitStatus?: GitFileStatus;
+}
+export interface ChatMessage {
+    role: "user" | "assistant";
+    content: string;
+}
+export interface TextBlock {
+    type: "text";
+    text: string;
+}
+export interface ThinkingBlock {
+    type: "thinking";
+    thinking: string;
+}
+export interface ToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    description?: string;
+    input: Record<string, unknown>;
+}
+export interface ToolResultBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    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) */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadInputTokens?: number;
+        cacheCreationInputTokens?: number;
+        totalCostUsd?: number;
+    };
+}
+export interface SessionSnapshot {
+    id: string;
+    command: string;
+    cwd: string;
+    mode: ExecutionMode;
+    status: "running" | "exited" | "failed" | "stopped";
+    exitCode: number | null;
+    startedAt: string;
+    endedAt: string | null;
+    output: string;
+    archived: boolean;
+    archivedAt: string | null;
+    /** Claude Code 会话 ID，用于 --resume 恢复会话 */
+    claudeSessionId: string | null;
+    /** Structured conversation messages (from JSON chat mode) */
+    messages?: ConversationTurn[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};