lark-remote 0.1.0

package/dist/session/session-store.js

@@ -0,0 +1,450 @@
+import fs from 'node:fs';
+import { getLogger } from '../logger/index.js';
+import { atomicWriteJson } from '../persistence/atomic-write.js';
+/**
+ * Per-user session store. Persists cwd + per-agent sessions to disk so that
+ * the last workspace AND the last-used sessionId per agent are restored after
+ * a bridge restart.
+ *
+ * Persistence strategy:
+ * - Persists `cwd`, `sessions` (per-agent sessionId), `previousSessions`
+ *   (parked restore slots for `/config` agent switching), and `arrivalSessions`
+ *   (arrival baseline; '' entries are meaningful and must survive restart).
+ * - Atomic write (temp + rename) to avoid truncated files on crash
+ * - Corrupt files are treated as empty (with a warning)
+ *
+ * P3.3: sessions is Map<AgentKind, sessionId> (one session per agent), allowing
+ * each agent to maintain its own session context when switching between agents.
+ */
+export class SessionStore {
+    sessions = new Map();
+    persistPath;
+    defaultAgent;
+    /**
+     * 进程内会话代际（2026-08-09 /new 被在途 run init 写回撤销事故）：
+     * 每次「用户意图移动 session 指针」+1。system.init 写回通道不 bump。
+     * Bridge 在 run 启动时快照 epoch，init 写回前比较——不一致说明 /new、
+     * /cd、/resume 等在 run 在途时移动了指针，该 run 的写回是 stale 的，丢弃。
+     * 不持久化：重启后无在途 run，stale 写回不可能发生。
+     * 独立 Map 而非 SessionEntry 字段：entry 有 ~10 处整体重构点，字段易漏传。
+     */
+    agentEpochs = new Map(); // key: userId agent
+    userEpochs = new Map(); // key: userId（/cd 跨 agent 清全部）
+    static epochKey(userId, agent) {
+        return `${userId} ${agent}`;
+    }
+    /** 当前代际 = user 级 + agent 级之和；任一级 bump 都会改变总和。 */
+    getSessionEpoch(userId, agent) {
+        return ((this.userEpochs.get(userId) ?? 0) +
+            (this.agentEpochs.get(SessionStore.epochKey(userId, agent)) ?? 0));
+    }
+    /** 用户意图移动了指定 agent 的 session 指针（/new、/resume、/config 切换）。 */
+    bumpSessionEpoch(userId, agent) {
+        const k = SessionStore.epochKey(userId, agent);
+        this.agentEpochs.set(k, (this.agentEpochs.get(k) ?? 0) + 1);
+    }
+    /** 用户意图移动了全部 agent 的 session 指针（/cd、/ws use 的 setCwd）。 */
+    bumpUserEpoch(userId) {
+        this.userEpochs.set(userId, (this.userEpochs.get(userId) ?? 0) + 1);
+    }
+    constructor(persistPath, defaultAgent) {
+        this.persistPath = persistPath;
+        this.defaultAgent = defaultAgent;
+        if (persistPath)
+            this.load();
+    }
+    get(userId) {
+        return this.sessions.get(userId);
+    }
+    set(userId, entry) {
+        this.sessions.set(userId, entry);
+        this.autoPersist();
+    }
+    delete(userId) {
+        this.sessions.delete(userId);
+        this.autoPersist();
+    }
+    /** Clear sessionId for a specific agent, keeping cwd and other agent sessions */
+    clearSessionId(userId, agent = 'claude', opts) {
+        // 无条件 bump：空→空也必须可检测（事故场景正是 run 以 (none) 启动，
+        // /new 后 store 仍为空，值比较会误判「没变」）。entry 不存在同样 bump。
+        this.bumpSessionEpoch(userId, agent);
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newSessions = new Map(entry.sessions);
+            newSessions.set(agent, '');
+            const newSessionCwds = new Map(entry.sessionCwds);
+            if (opts?.clearSessionCwd) {
+                newSessionCwds.set(agent, '');
+            }
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: entry.previousSessions,
+                sessionCwds: newSessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd: entry.cwd,
+            });
+        }
+        this.autoPersist();
+    }
+    /** Get previous sessionId for a specific agent (stored when switching away) */
+    getPreviousSessionId(userId, agent) {
+        const entry = this.sessions.get(userId);
+        if (!entry)
+            return undefined;
+        const sessionId = entry.previousSessions.get(agent);
+        if (!sessionId)
+            return undefined;
+        return sessionId;
+    }
+    /** Set previous sessionId for a specific agent (for potential restore when switching back) */
+    setPreviousSessionId(userId, agent, sessionId) {
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newPrevious = new Map(entry.previousSessions);
+            newPrevious.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: entry.sessions,
+                previousSessions: newPrevious,
+                sessionCwds: entry.sessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd: entry.cwd,
+            });
+        }
+        else {
+            const newPrevious = new Map();
+            newPrevious.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: new Map(),
+                previousSessions: newPrevious,
+                sessionCwds: new Map(),
+                arrivalSessions: new Map(),
+                cwd: '',
+            });
+        }
+        this.autoPersist();
+    }
+    /** Clear previous sessionId for a specific agent */
+    clearPreviousSessionId(userId, agent) {
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newPrevious = new Map(entry.previousSessions);
+            newPrevious.delete(agent);
+            this.sessions.set(userId, {
+                sessions: entry.sessions,
+                previousSessions: newPrevious,
+                sessionCwds: entry.sessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd: entry.cwd,
+            });
+        }
+        this.autoPersist();
+    }
+    /** Get the arrival baseline sessionId for a specific agent ('' and missing → undefined) */
+    getArrivalSessionId(userId, agent) {
+        const entry = this.sessions.get(userId);
+        if (!entry)
+            return undefined;
+        const sessionId = entry.arrivalSessions.get(agent);
+        if (!sessionId)
+            return undefined;
+        return sessionId;
+    }
+    /** Set the arrival baseline for a specific agent ('' explicitly clears the arrival baseline) */
+    setArrivalSessionId(userId, agent, sessionId) {
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newArrival = new Map(entry.arrivalSessions);
+            newArrival.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: entry.sessions,
+                previousSessions: entry.previousSessions,
+                sessionCwds: entry.sessionCwds,
+                arrivalSessions: newArrival,
+                cwd: entry.cwd,
+            });
+        }
+        else {
+            const newArrival = new Map();
+            newArrival.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: new Map(),
+                previousSessions: new Map(),
+                sessionCwds: new Map(),
+                arrivalSessions: newArrival,
+                cwd: '',
+            });
+        }
+        this.autoPersist();
+    }
+    /** Set cwd for a user, clearing all sessionIds (§9.1) */
+    setCwd(userId, cwd) {
+        // §9.1 setCwd 清全部 agent 的 sessionId → user 级 bump，覆盖 sessions
+        // map 里还没有 key 的 agent（run 刚启动、首个 init 未写回时 /cd 的边界）。
+        this.bumpUserEpoch(userId);
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newSessions = new Map(entry.sessions);
+            for (const key of newSessions.keys()) {
+                newSessions.set(key, '');
+            }
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: new Map(),
+                sessionCwds: new Map(),
+                arrivalSessions: new Map(),
+                cwd,
+            });
+        }
+        else {
+            this.sessions.set(userId, {
+                sessions: new Map(),
+                previousSessions: new Map(),
+                sessionCwds: new Map(),
+                arrivalSessions: new Map(),
+                cwd,
+            });
+        }
+        this.autoPersist();
+    }
+    /** Get cwd for a user, or undefined if no session */
+    getCwd(userId) {
+        return this.sessions.get(userId)?.cwd;
+    }
+    /** Get sessionId for a specific agent, or undefined if no session or sessionId is empty */
+    getSessionId(userId, agent = 'claude') {
+        const entry = this.sessions.get(userId);
+        if (!entry || !entry.sessions)
+            return undefined;
+        const sessionId = entry.sessions.get(agent);
+        if (!sessionId)
+            return undefined;
+        return sessionId;
+    }
+    /** Set sessionId for a specific agent, optionally with cwd */
+    setSessionId(userId, agent, sessionId, cwd) {
+        this.bumpSessionEpoch(userId, agent);
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newSessions = new Map(entry.sessions);
+            newSessions.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: entry.previousSessions,
+                sessionCwds: entry.sessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd: cwd ?? entry.cwd,
+            });
+        }
+        else {
+            const newSessions = new Map();
+            newSessions.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: new Map(),
+                sessionCwds: new Map(),
+                arrivalSessions: new Map(),
+                cwd: cwd ?? '',
+            });
+        }
+        this.autoPersist();
+    }
+    /** Set sessionId for a specific agent and cwd together */
+    setSessionIdAndCwd(userId, agent, sessionId, cwd, sessionCwd) {
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newSessions = new Map(entry.sessions);
+            newSessions.set(agent, sessionId);
+            const newSessionCwds = new Map(entry.sessionCwds);
+            if (sessionCwd !== undefined) {
+                newSessionCwds.set(agent, sessionCwd);
+            }
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: entry.previousSessions,
+                sessionCwds: newSessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd,
+            });
+        }
+        else {
+            const newSessions = new Map();
+            newSessions.set(agent, sessionId);
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: new Map(),
+                sessionCwds: new Map(),
+                arrivalSessions: new Map(),
+                cwd,
+            });
+        }
+        this.autoPersist();
+    }
+    /** Get sessionCwd for a specific agent, or undefined if not set */
+    getSessionCwd(userId, agent = 'claude') {
+        const entry = this.sessions.get(userId);
+        if (!entry)
+            return undefined;
+        const sessionCwd = entry.sessionCwds.get(agent);
+        if (!sessionCwd)
+            return undefined;
+        return sessionCwd;
+    }
+    /** Set sessionId and sessionCwd for a specific agent, without touching cwd */
+    setSessionIdAndSessionCwd(userId, agent, sessionId, sessionCwd) {
+        const entry = this.sessions.get(userId);
+        if (entry) {
+            const newSessions = new Map(entry.sessions);
+            newSessions.set(agent, sessionId);
+            const newSessionCwds = new Map(entry.sessionCwds);
+            newSessionCwds.set(agent, sessionCwd);
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: entry.previousSessions,
+                sessionCwds: newSessionCwds,
+                arrivalSessions: entry.arrivalSessions,
+                cwd: entry.cwd,
+            });
+        }
+        else {
+            const newSessions = new Map();
+            newSessions.set(agent, sessionId);
+            const newSessionCwds = new Map();
+            newSessionCwds.set(agent, sessionCwd);
+            this.sessions.set(userId, {
+                sessions: newSessions,
+                previousSessions: new Map(),
+                sessionCwds: newSessionCwds,
+                arrivalSessions: new Map(),
+                cwd: '',
+            });
+        }
+        this.autoPersist();
+    }
+    // -- Persistence helpers --
+    /** Persisted format: only cwd per user (sessionId is process-scoped) */
+    load() {
+        if (!this.persistPath)
+            return;
+        try {
+            if (!fs.existsSync(this.persistPath))
+                return;
+            const raw = fs.readFileSync(this.persistPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (typeof parsed === 'object' && parsed !== null) {
+                for (const [userId, data] of Object.entries(parsed)) {
+                    if (typeof data === 'object' && data !== null) {
+                        const entry = data;
+                        // All four session fields are required; a missing one indicates a
+                        // corrupt record — skip it entirely. cwd is allowed to be absent
+                        // (legitimately-empty cwd state, see round7 tests).
+                        if (!entry.sessions ||
+                            !entry.previousSessions ||
+                            !entry.arrivalSessions ||
+                            !entry.sessionCwds) {
+                            continue;
+                        }
+                        const sessions = new Map();
+                        for (const [agent, sid] of Object.entries(entry.sessions)) {
+                            if (sid) {
+                                sessions.set(agent, sid);
+                            }
+                        }
+                        const previousSessions = new Map();
+                        for (const [agent, sid] of Object.entries(entry.previousSessions)) {
+                            if (sid) {
+                                previousSessions.set(agent, sid);
+                            }
+                        }
+                        const arrivalSessions = new Map();
+                        for (const [agent, sid] of Object.entries(entry.arrivalSessions)) {
+                            // '' entries are meaningful: explicit "cleared arrival" must
+                            // survive a restart instead of being re-defaulted.
+                            arrivalSessions.set(agent, sid);
+                        }
+                        const sessionCwds = new Map();
+                        for (const [agent, scwd] of Object.entries(entry.sessionCwds)) {
+                            if (scwd) {
+                                sessionCwds.set(agent, scwd);
+                            }
+                        }
+                        // Persist any user that has state: cwd set, or any meaningful
+                        // sessions/previousSessions value, or any arrival baseline entry
+                        // ('' arrivals are meaningful). Fully empty records are skipped.
+                        const hasCwd = !!entry.cwd && entry.cwd.length > 0;
+                        if (hasCwd ||
+                            sessions.size > 0 ||
+                            previousSessions.size > 0 ||
+                            arrivalSessions.size > 0) {
+                            this.sessions.set(userId, {
+                                sessions,
+                                previousSessions,
+                                sessionCwds,
+                                arrivalSessions,
+                                cwd: entry.cwd ?? '',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            getLogger().warn('[session] persisted session store corrupted, ignoring');
+        }
+    }
+    autoPersist() {
+        if (!this.persistPath)
+            return;
+        try {
+            // Persist cwd, sessions, previousSessions (parked restore slots) and
+            // arrivalSessions (arrival baseline; '' entries are meaningful).
+            const obj = {};
+            for (const [userId, entry] of this.sessions) {
+                // Persist any user that has state: cwd set, or any meaningful
+                // sessions/previousSessions value, or any arrival baseline entry
+                // ('' arrivals are meaningful). Empty cwd is written as '' so the
+                // other fields survive a rebuild.
+                const hasSessions = [...entry.sessions.values()].some((sid) => sid);
+                const hasPrevious = [...entry.previousSessions.values()].some((sid) => sid);
+                const hasArrival = entry.arrivalSessions.size > 0;
+                const hasSessionCwds = entry.sessionCwds.size > 0;
+                if (entry.cwd.length > 0 || hasSessions || hasPrevious || hasArrival || hasSessionCwds) {
+                    const sessionsObj = {};
+                    for (const [agent, sid] of entry.sessions) {
+                        if (sid) {
+                            sessionsObj[agent] = sid;
+                        }
+                    }
+                    const previousObj = {};
+                    for (const [agent, sid] of entry.previousSessions) {
+                        if (sid) {
+                            previousObj[agent] = sid;
+                        }
+                    }
+                    const arrivalObj = {};
+                    for (const [agent, sid] of entry.arrivalSessions) {
+                        arrivalObj[agent] = sid;
+                    }
+                    const sessionCwdsObj = {};
+                    for (const [agent, scwd] of entry.sessionCwds) {
+                        if (scwd) {
+                            sessionCwdsObj[agent] = scwd;
+                        }
+                    }
+                    obj[userId] = {
+                        cwd: entry.cwd,
+                        sessions: sessionsObj,
+                        previousSessions: previousObj,
+                        sessionCwds: sessionCwdsObj,
+                        arrivalSessions: arrivalObj,
+                    };
+                }
+            }
+            atomicWriteJson(this.persistPath, obj);
+        }
+        catch (err) {
+            getLogger().warn('[session] failed to persist session store:', err);
+        }
+    }
+}
+//# sourceMappingURL=session-store.js.map

package/dist/startup-contact.d.ts

@@ -0,0 +1,18 @@
+interface StartupContact {
+    chatId?: string;
+    userId?: string;
+}
+interface StartupHelloChannel {
+    sendWithRetry(to: string, input: {
+        text: string;
+    }): Promise<string>;
+}
+export declare class StartupContactStore {
+    private readonly filePath;
+    constructor(filePath: string);
+    save(contact: StartupContact): void;
+    getContact(): StartupContact | undefined;
+}
+export declare function formatStartupHello(now?: Date, pid?: number): string;
+export declare function sendStartupHello(connector: StartupHelloChannel, store: StartupContactStore): Promise<void>;
+export {};

package/dist/startup-contact.js

@@ -0,0 +1,51 @@
+import { getLogger } from './logger/index.js';
+import { atomicWriteJson } from './persistence/atomic-write.js';
+import { loadJsonFile } from './persistence/load-json-file.js';
+export class StartupContactStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    save(contact) {
+        atomicWriteJson(this.filePath, contact);
+    }
+    getContact() {
+        const parsed = loadJsonFile(this.filePath, undefined);
+        if (!parsed)
+            return undefined;
+        const contact = {};
+        if (typeof parsed.chatId === 'string' && parsed.chatId.length > 0)
+            contact.chatId = parsed.chatId;
+        if (typeof parsed.userId === 'string' && parsed.userId.length > 0)
+            contact.userId = parsed.userId;
+        return contact.chatId || contact.userId ? contact : undefined;
+    }
+}
+export function formatStartupHello(now = new Date(), pid = process.pid) {
+    const startedAt = new Intl.DateTimeFormat('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    }).format(now);
+    return `lark-remote 已启动\n启动时间：${startedAt}\n进程号：${pid}`;
+}
+export async function sendStartupHello(connector, store) {
+    const contact = store.getContact();
+    const recipient = contact?.chatId ?? contact?.userId;
+    if (!recipient) {
+        getLogger().info('[startup] no known p2p recipient for hello message');
+        return;
+    }
+    try {
+        await connector.sendWithRetry(recipient, { text: formatStartupHello() });
+        getLogger().info('[startup] hello message sent');
+    }
+    catch (err) {
+        getLogger().warn('[startup] hello message failed:', err);
+    }
+}
+//# sourceMappingURL=startup-contact.js.map

package/dist/workspace/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Persistent named-alias store for workspace directories.
+ *
+ * Atomic write (§9.10): writes a temp file then `fs.rename` so a crash
+ * mid-write cannot leave a truncated JSON file. On load, a corrupt file
+ * is treated as empty (with a warning) so the bridge can still start.
+ */
+export declare class WorkspaceStore {
+    private filePath;
+    private data;
+    constructor(filePath?: string);
+    private load;
+    private persist;
+    save(name: string, dirPath: string): void;
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    remove(name: string): void;
+    list(): [string, string][];
+}

package/dist/workspace/index.js

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import os from 'node:os';
+import { atomicWriteJson } from '../persistence/atomic-write.js';
+import { loadJsonFile } from '../persistence/load-json-file.js';
+/**
+ * Persistent named-alias store for workspace directories.
+ *
+ * Atomic write (§9.10): writes a temp file then `fs.rename` so a crash
+ * mid-write cannot leave a truncated JSON file. On load, a corrupt file
+ * is treated as empty (with a warning) so the bridge can still start.
+ */
+export class WorkspaceStore {
+    filePath;
+    data;
+    constructor(filePath) {
+        this.filePath = filePath ?? path.join(os.homedir(), '.lark-remote', 'workspace.json');
+        this.data = new Map();
+        this.load();
+    }
+    load() {
+        const parsed = loadJsonFile(this.filePath, undefined);
+        if (!parsed)
+            return;
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === 'string')
+                this.data.set(k, v);
+        }
+    }
+    persist() {
+        const obj = {};
+        for (const [k, v] of this.data)
+            obj[k] = v;
+        atomicWriteJson(this.filePath, obj);
+    }
+    save(name, dirPath) {
+        this.data.set(name, dirPath);
+        this.persist();
+    }
+    get(name) {
+        return this.data.get(name);
+    }
+    has(name) {
+        return this.data.has(name);
+    }
+    remove(name) {
+        this.data.delete(name);
+        this.persist();
+    }
+    list() {
+        return [...this.data.entries()];
+    }
+}
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "lark-remote",
+  "version": "0.1.0",
+  "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "lark-remote": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.js.map",
+    "!dist/**/*.d.ts.map",
+    "!dist/config/codex-bundled-test-helpers.*",
+    "!dist/test-helpers.*",
+    "README.md",
+    "README.en.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "dev": "bun src/index.ts",
+    "build": "rm -rf dist && tsc && chmod +x dist/index.js dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src tests",
+    "lint:fix": "eslint src tests --fix",
+    "format": "prettier --write 'src/**/*.ts' 'tests/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts' 'tests/**/*.ts'",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "tsc --noEmit && vitest run && rm -rf dist && tsc && chmod +x dist/index.js dist/cli.js",
+    "prepack": "node -e \"const fs=require('fs');if(!fs.existsSync('dist/cli.js')){console.error('dist/ missing — run bun run build first');process.exit(1)}\""
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "keywords": [
+    "feishu",
+    "lark",
+    "claude-code",
+    "codex",
+    "opencode",
+    "kimi",
+    "coding-agent",
+    "bridge",
+    "cli",
+    "remote-control"
+  ],
+  "author": "hhr-code",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hhr-code/lark-remote.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hhr-code/lark-remote/issues"
+  },
+  "homepage": "https://github.com/hhr-code/lark-remote#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@larksuite/channel": "^0.3.0",
+    "axios": "^1.18.0",
+    "form-data": "^4.0.6",
+    "qrcode-terminal": "^0.12.0",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/form-data": "^2.5.2",
+    "@types/node": "^26.1.2",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@vitest/coverage-v8": "4.1.9",
+    "eslint": "^10.7.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "prettier": "^3.9.5",
+    "typescript": "^6.0.0",
+    "typescript-eslint": "^8.63.0",
+    "vitest": "^4.1.9"
+  }
+}