@co0ontty/wand 2.1.1 → 2.2.0

package/dist/server.js

@@ -29,6 +29,7 @@ import { canUseDetachedUpdateHelper, startDetachedUpdateHelper } from "./update-
 import { registerUploadRoutes } from "./upload-routes.js";
 import { optimizePrompt, PromptOptimizeError } from "./prompt-optimizer.js";
 import { resolveDatabasePath, WandStorage } from "./storage.js";
+import { DEFAULT_BROWSER_EXTENSION_BASE_URL, buildPasswordSecurityReport, generatePassword, generateTotpCode, normalizePasswordItemType, } from "./password-manager.js";
 import { deepRepairRuntimePath, formatPathRepairSummary, repairRuntimePath } from "./path-repair.js";
 import { isLogBusActive, wandTuiLog } from "./tui/log-bus.js";
 import { EMBEDDED_WEB_ASSETS } from "./web-ui/embedded-assets.js";
@@ -384,15 +385,38 @@ async function enrichWithGitStatus(items, dirPath) {
     }
 }
 // ── Auth helpers ──
-function buildRequireAuth(useHttps) {
+function buildRequireAuth(useHttps, storage, config) {
     return function requireAuth(req, res, next) {
-        if (!validateSession(readSessionCookie(req, useHttps))) {
+        if (!validateSession(readSessionCookie(req, useHttps)) && !validateBearerAppToken(req, storage, config)) {
             res.status(401).json({ error: "未授权，请先登录。" });
             return;
         }
         next();
     };
 }
+function getEffectivePassword(storage, config) {
+    return storage.getPassword() ?? config.password;
+}
+function validateBearerAppToken(req, storage, config) {
+    const header = firstHeaderValue(req.headers.authorization);
+    if (!header?.startsWith("Bearer "))
+        return false;
+    const token = header.slice("Bearer ".length).trim();
+    if (!token)
+        return false;
+    try {
+        return verifyAppToken(token, getEffectivePassword(storage, config), config.appSecret ?? "");
+    }
+    catch {
+        return false;
+    }
+}
+function appTokenLoginPayload(storage, config) {
+    return {
+        appToken: generateAppToken(getEffectivePassword(storage, config), config.appSecret ?? ""),
+        serverUrl: DEFAULT_BROWSER_EXTENSION_BASE_URL,
+    };
+}
 // ── App connection token helpers ──
 function generateAppToken(password, secret) {
     return crypto.createHmac("sha256", secret).update(password).digest("hex");
@@ -477,6 +501,13 @@ function normalizePublicOrigin(value) {
         return undefined;
     }
 }
+function isBrowserExtensionOrigin(value) {
+    if (!value)
+        return false;
+    return /^chrome-extension:\/\/[a-z]{32}$/i.test(value)
+        || /^moz-extension:\/\/[0-9a-f-]+$/i.test(value)
+        || /^safari-web-extension:\/\//i.test(value);
+}
 function isPrivateIpv4(address) {
     if (address.startsWith("10.") || address.startsWith("192.168."))
         return true;
@@ -1027,10 +1058,25 @@ export async function startServer(config, configPath) {
     const structuredSessions = new StructuredSessionManager(storage, config, structuredLogger);
     const useHttps = config.https === true;
     const protocol = useHttps ? "https" : "http";
-    const requireAuth = buildRequireAuth(useHttps);
+    const requireAuth = buildRequireAuth(useHttps, storage, config);
     const nodeModulesDir = path.join(RUNTIME_ROOT_DIR, "node_modules");
     app.use(express.json({ limit: "1mb" }));
     app.use(compression({ threshold: 1024 }));
+    app.use((req, res, next) => {
+        const origin = firstHeaderValue(req.headers.origin);
+        if (origin && isBrowserExtensionOrigin(origin)) {
+            res.setHeader("Access-Control-Allow-Origin", origin);
+            res.setHeader("Access-Control-Allow-Credentials", "true");
+            res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+            res.setHeader("Vary", "Origin");
+        }
+        if (req.method === "OPTIONS" && origin && isBrowserExtensionOrigin(origin)) {
+            res.status(204).end();
+            return;
+        }
+        next();
+    });
     const sendEmbeddedVendorAsset = (assetPath, _req, res) => {
         const asset = EMBEDDED_WEB_ASSETS.vendor[assetPath];
         res.setHeader("Cache-Control", "public, max-age=604800, immutable");
@@ -1095,9 +1141,8 @@ export async function startServer(config, configPath) {
             res.status(429).json({ error: "登录尝试次数过多，请在 15 分钟后再试。" });
             return;
         }
-        const { password, appToken } = req.body;
-        const dbPassword = storage.getPassword();
-        const effectivePassword = dbPassword ?? config.password;
+        const { password, appToken, client } = req.body;
+        const effectivePassword = getEffectivePassword(storage, config);
         // App token login — derived from password, so password change invalidates it
         let authenticated = false;
         if (appToken) {
@@ -1138,7 +1183,10 @@ export async function startServer(config, configPath) {
             res.cookie(SESSION_COOKIE_HTTP, token, { ...cookieOpts, secure: false });
             res.cookie(SESSION_COOKIE_LEGACY, token, { ...cookieOpts, secure: false });
         }
-        res.json({ ok: true });
+        res.json({
+            ok: true,
+            ...(client === "browser-extension" ? appTokenLoginPayload(storage, config) : {}),
+        });
     });
     app.post("/api/logout", (req, res) => {
         revokeSession(readSessionCookie(req, useHttps));
@@ -1281,6 +1329,119 @@ export async function startServer(config, configPath) {
             currentVersion: DISPLAY_VERSION,
         });
     });
+    // ── Browser extension password vault endpoints ──
+    app.get("/api/browser-extension/status", (_req, res) => {
+        res.json({
+            ok: true,
+            serverUrl: DEFAULT_BROWSER_EXTENSION_BASE_URL,
+            features: {
+                loginAutofill: true,
+                saveLogins: true,
+                federatedLoginMemory: true,
+                passwordGenerator: true,
+                totp: true,
+                cardsAndIdentities: true,
+                vaults: true,
+                securityReport: true,
+                passkeys: "webauthn-proxy",
+            },
+        });
+    });
+    app.get("/api/browser-extension/vaults", (_req, res) => {
+        res.json({ vaults: storage.listPasswordVaults() });
+    });
+    app.post("/api/browser-extension/vaults", (req, res) => {
+        try {
+            const vault = storage.createPasswordVault(req.body.name);
+            res.status(201).json({ vault });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法创建 vault。") });
+        }
+    });
+    app.get("/api/browser-extension/items", (req, res) => {
+        const filter = {
+            q: firstQueryStringValue(req.query.q),
+            url: firstQueryStringValue(req.query.url),
+            vaultId: firstQueryStringValue(req.query.vaultId),
+            type: req.query.type ? normalizePasswordItemType(firstQueryStringValue(req.query.type)) : undefined,
+            limit: req.query.limit ? Number(firstQueryStringValue(req.query.limit)) : undefined,
+        };
+        res.json({ items: storage.listPasswordItems(filter) });
+    });
+    app.post("/api/browser-extension/items", (req, res) => {
+        try {
+            const item = storage.createPasswordItem(req.body);
+            res.status(201).json({ item });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法保存条目。") });
+        }
+    });
+    app.get("/api/browser-extension/items/:id", (req, res) => {
+        const item = storage.getPasswordItem(req.params.id);
+        if (!item) {
+            res.status(404).json({ error: "条目不存在。" });
+            return;
+        }
+        res.json({ item });
+    });
+    app.put("/api/browser-extension/items/:id", (req, res) => {
+        try {
+            const item = storage.updatePasswordItem(req.params.id, req.body);
+            if (!item) {
+                res.status(404).json({ error: "条目不存在。" });
+                return;
+            }
+            res.json({ item });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法更新条目。") });
+        }
+    });
+    app.delete("/api/browser-extension/items/:id", (req, res) => {
+        if (!storage.deletePasswordItem(req.params.id)) {
+            res.status(404).json({ error: "条目不存在。" });
+            return;
+        }
+        res.json({ ok: true });
+    });
+    app.post("/api/browser-extension/items/:id/use", (req, res) => {
+        const item = storage.touchPasswordItem(req.params.id);
+        if (!item) {
+            res.status(404).json({ error: "条目不存在。" });
+            return;
+        }
+        res.json({ item });
+    });
+    app.get("/api/browser-extension/generator/password", (req, res) => {
+        res.json({
+            password: generatePassword({
+                length: Number(firstQueryStringValue(req.query.length)),
+                digits: firstQueryStringValue(req.query.digits) !== "false",
+                symbols: firstQueryStringValue(req.query.symbols) !== "false",
+            }),
+        });
+    });
+    app.post("/api/browser-extension/totp/preview", (req, res) => {
+        try {
+            const { secret, digits, period } = req.body;
+            if (!secret) {
+                res.status(400).json({ error: "缺少 TOTP secret。" });
+                return;
+            }
+            res.json({
+                code: generateTotpCode(secret, Date.now(), digits ?? 6, period ?? 30),
+                period: period ?? 30,
+            });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法生成 TOTP。") });
+        }
+    });
+    app.get("/api/browser-extension/security-report", (_req, res) => {
+        res.json({ report: buildPasswordSecurityReport(storage.listPasswordItems({ includeArchived: false, limit: 200 })) });
+    });
     // ── Settings endpoints ──
     app.get("/api/settings", async (_req, res) => {
         const certPaths = {
@@ -1440,8 +1601,7 @@ export async function startServer(config, configPath) {
         });
     });
     app.get("/api/app-connect-code", requireAuth, (req, res) => {
-        const dbPassword = storage.getPassword();
-        const effectivePassword = dbPassword ?? config.password;
+        const effectivePassword = getEffectivePassword(storage, config);
         const protocol = getPublicRequestProtocol(req, useHttps ? "https" : "http");
         const host = getPublicRequestHost(req, config);
         const browserOrigin = normalizePublicOrigin(firstQueryStringValue(req.query.origin));
@@ -2271,15 +2431,17 @@ export async function startServer(config, configPath) {
         server.once("error", onListenError);
         server.listen(config.port, config.host, () => {
             server.off("error", onListenError);
-            bindAddr = `${config.host}:${config.port}`;
+            const address = server.address();
+            const actualPort = typeof address === "object" && address ? address.port : config.port;
+            bindAddr = `${config.host}:${actualPort}`;
             const scheme = useHttps ? "HTTPS" : "HTTP";
             // 主 URL：本机回环；若绑定 0.0.0.0 再补一个对外提示。
-            collectedUrls.push({ url: `${protocol}://127.0.0.1:${config.port}`, scheme });
+            collectedUrls.push({ url: `${protocol}://127.0.0.1:${actualPort}`, scheme });
             if (config.host === "0.0.0.0") {
-                collectedUrls.push({ url: `${protocol}://0.0.0.0:${config.port}`, scheme });
+                collectedUrls.push({ url: `${protocol}://0.0.0.0:${actualPort}`, scheme });
             }
             else if (config.host !== "127.0.0.1" && config.host !== "localhost") {
-                collectedUrls.push({ url: `${protocol}://${config.host}:${config.port}`, scheme });
+                collectedUrls.push({ url: `${protocol}://${config.host}:${actualPort}`, scheme });
             }
             resolve();
         });
@@ -2287,10 +2449,16 @@ export async function startServer(config, configPath) {
     if (!storage.hasCustomPassword() && config.password === "change-me") {
         wandWarn("正在使用默认密码（change-me），任何能访问本机的人都可以登录。", "修改方法：在界面右上角「设置」中修改密码，或运行：node dist/cli.js config:set password <你的新密码>");
     }
+    const testMode = process.env.WAND_TEST_MODE === "1";
+    const updateChecksEnabled = !testMode && process.env.WAND_DISABLE_UPDATE_CHECK !== "1";
     // Start configured background sessions after the server is already reachable.
-    processes.runStartupCommands();
+    if (!testMode) {
+        processes.runStartupCommands();
+    }
     // Pre-warm model cache (probes claude --version + codex debug models).
-    refreshModels().catch(() => { });
+    if (!testMode) {
+        refreshModels().catch(() => { });
+    }
     // ── Auto-update endpoints ──
     app.get("/api/auto-update", (_req, res) => {
         const web = storage.getConfigValue("autoUpdateWeb") === "true";
@@ -2386,12 +2554,16 @@ export async function startServer(config, configPath) {
             });
         }
     }
-    // Background update check on startup
-    performAutoUpdate().catch(() => { });
-    // Periodic update check (every 30 minutes)
-    setInterval(() => {
+    let updateCheckTimer = null;
+    if (updateChecksEnabled) {
+        // Background update check on startup
         performAutoUpdate().catch(() => { });
-    }, 30 * 60 * 1000);
+        // Periodic update check (every 30 minutes)
+        updateCheckTimer = setInterval(() => {
+            performAutoUpdate().catch(() => { });
+        }, 30 * 60 * 1000);
+        updateCheckTimer.unref();
+    }
     const close = () => new Promise((resolve) => {
         let done = false;
         const finish = () => {
@@ -2412,6 +2584,8 @@ export async function startServer(config, configPath) {
             wss.close();
         }
         catch { /* ignore */ }
+        if (updateCheckTimer)
+            clearInterval(updateCheckTimer);
         try {
             server.close(() => finish());
         }

package/dist/storage.d.ts

@@ -1,4 +1,5 @@
 import { SessionSnapshot } from "./types.js";
+import { type PasswordVault, type PasswordVaultItem, type PasswordVaultItemFilter, type PasswordVaultItemInput } from "./password-manager.js";
 export declare const DEFAULT_DB_FILE = "wand.db";
 export interface PersistedAuthSession {
     token: string;
@@ -32,6 +33,16 @@ export declare class WandStorage {
     getAppSecret(): string | null;
     /** Persist appSecret in database (DB is the authoritative source after first migration) */
     setAppSecret(value: string): void;
+    ensureDefaultPasswordVault(): void;
+    listPasswordVaults(): PasswordVault[];
+    createPasswordVault(nameInput: unknown): PasswordVault;
+    getPasswordVault(id: string): PasswordVault | null;
+    listPasswordItems(filter?: PasswordVaultItemFilter): PasswordVaultItem[];
+    getPasswordItem(id: string): PasswordVaultItem | null;
+    createPasswordItem(input: PasswordVaultItemInput): PasswordVaultItem;
+    updatePasswordItem(id: string, input: PasswordVaultItemInput): PasswordVaultItem | null;
+    touchPasswordItem(id: string): PasswordVaultItem | null;
+    deletePasswordItem(id: string): boolean;
     saveAuthSession(token: string, expiresAt: number): void;
     getAuthSession(token: string): PersistedAuthSession | null;
     deleteAuthSession(token: string): void;

package/dist/storage.js

@@ -1,6 +1,8 @@
+import crypto from "node:crypto";
 import { existsSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { DEFAULT_PASSWORD_VAULT_ID, DEFAULT_PASSWORD_VAULT_NAME, itemMatchesFilter, normalizePasswordItemInput, normalizeVaultName, nowIso, } from "./password-manager.js";
 function safeJsonParse(raw) {
     if (!raw)
         return undefined;
@@ -232,6 +234,37 @@ const INIT_SQL = `
     key TEXT PRIMARY KEY,
     value TEXT NOT NULL
   );
+
+  CREATE TABLE IF NOT EXISTS password_vaults (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS password_items (
+    id TEXT PRIMARY KEY,
+    vault_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    title TEXT NOT NULL,
+    username TEXT,
+    password TEXT,
+    urls TEXT NOT NULL DEFAULT '[]',
+    notes TEXT,
+    fields TEXT NOT NULL DEFAULT '{}',
+    tags TEXT NOT NULL DEFAULT '[]',
+    favorite INTEGER NOT NULL DEFAULT 0,
+    archived INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_used_at TEXT,
+    password_updated_at TEXT,
+    FOREIGN KEY(vault_id) REFERENCES password_vaults(id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_password_items_vault ON password_items(vault_id);
+  CREATE INDEX IF NOT EXISTS idx_password_items_type ON password_items(type);
+  CREATE INDEX IF NOT EXISTS idx_password_items_updated ON password_items(updated_at);
 `;
 export function ensureDatabaseFile(dbPath) {
     mkdirSync(path.dirname(dbPath), { recursive: true });
@@ -249,6 +282,7 @@ export class WandStorage {
         this.db = new DatabaseSync(dbPath);
         this.db.exec(INIT_SQL);
         ensureCommandSessionSchema(this.db);
+        this.ensureDefaultPasswordVault();
     }
     close() {
         this.db.close();
@@ -321,6 +355,120 @@ export class WandStorage {
     setAppSecret(value) {
         this.setConfigValue("appSecret", value);
     }
+    // ============ Browser Extension Password Vault Methods ============
+    ensureDefaultPasswordVault() {
+        const now = nowIso();
+        this.db
+            .prepare(`INSERT INTO password_vaults (id, name, created_at, updated_at)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(id) DO NOTHING`)
+            .run(DEFAULT_PASSWORD_VAULT_ID, DEFAULT_PASSWORD_VAULT_NAME, now, now);
+    }
+    listPasswordVaults() {
+        this.ensureDefaultPasswordVault();
+        const rows = this.db
+            .prepare("SELECT id, name, created_at, updated_at FROM password_vaults ORDER BY name COLLATE NOCASE ASC")
+            .all();
+        return rows.map(mapPasswordVaultRow);
+    }
+    createPasswordVault(nameInput) {
+        const name = normalizeVaultName(nameInput);
+        const now = nowIso();
+        const id = crypto.randomUUID();
+        this.db
+            .prepare("INSERT INTO password_vaults (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)")
+            .run(id, name, now, now);
+        return { id, name, createdAt: now, updatedAt: now };
+    }
+    getPasswordVault(id) {
+        const row = this.db
+            .prepare("SELECT id, name, created_at, updated_at FROM password_vaults WHERE id = ?")
+            .get(id);
+        return row ? mapPasswordVaultRow(row) : null;
+    }
+    listPasswordItems(filter = {}) {
+        this.ensureDefaultPasswordVault();
+        const rows = this.db
+            .prepare(`SELECT id, vault_id, type, title, username, password, urls, notes, fields, tags, favorite, archived,
+                created_at, updated_at, last_used_at, password_updated_at
+         FROM password_items
+         WHERE (? = 1 OR archived = 0)
+         ORDER BY favorite DESC, last_used_at DESC NULLS LAST, updated_at DESC`)
+            .all(filter.includeArchived ? 1 : 0);
+        const limit = typeof filter.limit === "number" && Number.isFinite(filter.limit)
+            ? Math.max(1, Math.min(200, Math.floor(filter.limit)))
+            : 100;
+        return rows.map(mapPasswordItemRow).filter((item) => itemMatchesFilter(item, filter)).slice(0, limit);
+    }
+    getPasswordItem(id) {
+        const row = this.db
+            .prepare(`SELECT id, vault_id, type, title, username, password, urls, notes, fields, tags, favorite, archived,
+                created_at, updated_at, last_used_at, password_updated_at
+         FROM password_items
+         WHERE id = ? AND archived = 0`)
+            .get(id);
+        return row ? mapPasswordItemRow(row) : null;
+    }
+    createPasswordItem(input) {
+        this.ensureDefaultPasswordVault();
+        const normalized = normalizePasswordItemInput(input);
+        const vaultId = typeof input.vaultId === "string" && this.getPasswordVault(input.vaultId)
+            ? input.vaultId
+            : DEFAULT_PASSWORD_VAULT_ID;
+        const now = nowIso();
+        const id = crypto.randomUUID();
+        const passwordUpdatedAt = normalized.password ? now : undefined;
+        this.db
+            .prepare(`INSERT INTO password_items (
+           id, vault_id, type, title, username, password, urls, notes, fields, tags, favorite, archived,
+           created_at, updated_at, last_used_at, password_updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, NULL, ?)`)
+            .run(id, vaultId, normalized.type, normalized.title, normalized.username ?? null, normalized.password ?? null, JSON.stringify(normalized.urls), normalized.notes ?? null, JSON.stringify(normalized.fields), JSON.stringify(normalized.tags), normalized.favorite ? 1 : 0, now, now, passwordUpdatedAt ?? null);
+        return this.getPasswordItem(id);
+    }
+    updatePasswordItem(id, input) {
+        const existing = this.getPasswordItem(id);
+        if (!existing)
+            return null;
+        const merged = {
+            vaultId: input.vaultId ?? existing.vaultId,
+            type: input.type ?? existing.type,
+            title: input.title ?? existing.title,
+            username: input.username ?? existing.username,
+            password: input.password ?? existing.password,
+            urls: input.urls ?? existing.urls,
+            notes: input.notes ?? existing.notes,
+            fields: input.fields ?? existing.fields,
+            tags: input.tags ?? existing.tags,
+            favorite: input.favorite ?? existing.favorite,
+        };
+        const normalized = normalizePasswordItemInput(merged);
+        const vaultId = typeof merged.vaultId === "string" && this.getPasswordVault(merged.vaultId)
+            ? merged.vaultId
+            : existing.vaultId;
+        const now = nowIso();
+        const passwordChanged = Object.prototype.hasOwnProperty.call(input, "password") && normalized.password !== existing.password;
+        const passwordUpdatedAt = passwordChanged ? (normalized.password ? now : null) : (existing.passwordUpdatedAt ?? null);
+        this.db
+            .prepare(`UPDATE password_items
+         SET vault_id = ?, type = ?, title = ?, username = ?, password = ?, urls = ?, notes = ?,
+             fields = ?, tags = ?, favorite = ?, updated_at = ?, password_updated_at = ?
+         WHERE id = ? AND archived = 0`)
+            .run(vaultId, normalized.type, normalized.title, normalized.username ?? null, normalized.password ?? null, JSON.stringify(normalized.urls), normalized.notes ?? null, JSON.stringify(normalized.fields), JSON.stringify(normalized.tags), normalized.favorite ? 1 : 0, now, passwordUpdatedAt, id);
+        return this.getPasswordItem(id);
+    }
+    touchPasswordItem(id) {
+        const now = nowIso();
+        this.db.prepare("UPDATE password_items SET last_used_at = ?, updated_at = ? WHERE id = ? AND archived = 0").run(now, now, id);
+        return this.getPasswordItem(id);
+    }
+    deletePasswordItem(id) {
+        const now = nowIso();
+        const result = this.db
+            .prepare("UPDATE password_items SET archived = 1, updated_at = ? WHERE id = ? AND archived = 0")
+            .run(now, id);
+        return result.changes > 0;
+    }
     // ============ Auth Session Methods ============
     saveAuthSession(token, expiresAt) {
         this.db
@@ -422,6 +570,33 @@ export class WandStorage {
         this.db.prepare("DELETE FROM command_sessions WHERE id = ?").run(id);
     }
 }
+function mapPasswordVaultRow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function mapPasswordItemRow(row) {
+    return {
+        id: row.id,
+        vaultId: row.vault_id,
+        type: row.type,
+        title: row.title,
+        username: row.username ?? undefined,
+        password: row.password ?? undefined,
+        urls: safeJsonParse(row.urls)?.filter((item) => typeof item === "string") ?? [],
+        notes: row.notes ?? undefined,
+        fields: safeJsonParse(row.fields) ?? {},
+        tags: safeJsonParse(row.tags)?.filter((item) => typeof item === "string") ?? [],
+        favorite: Boolean(row.favorite),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        lastUsedAt: row.last_used_at ?? undefined,
+        passwordUpdatedAt: row.password_updated_at ?? undefined,
+    };
+}
 const SCHEMA_MIGRATIONS = [
     ["archived", "ALTER TABLE command_sessions ADD COLUMN archived INTEGER NOT NULL DEFAULT 0"],
     ["archived_at", "ALTER TABLE command_sessions ADD COLUMN archived_at TEXT"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "A web terminal for local CLI tools like Claude.",
   "type": "module",
   "bin": {
@@ -12,7 +12,8 @@
     "url": ""
   },
   "files": [
-    "dist"
+    "dist",
+    "browser-extension"
   ],
   "preferGlobal": true,
   "scripts": {
@@ -21,6 +22,7 @@
     "build:copy-content": "cp -r src/web-ui/content dist/web-ui/ && node scripts/minify-dist-content.js",
     "dev": "node scripts/bundle-browser.js && npm run generate:web-assets && tsx src/cli.ts web",
     "check": "node scripts/bundle-browser.js && npm run generate:web-assets && tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.browser.json",
+    "test": "node --test --import tsx tests/*.test.ts",
     "prepublishOnly": "VER=${WAND_PUBLISH_VERSION:-$(git tag --sort=-v:refname --list 'v*' | head -1)} && VER=${VER#v} && npm version \"$VER\" --no-git-tag-version --allow-same-version && npm run build"
   },
   "keywords": [