appback-remoteagent 0.13.0

package/dist/store/file-store.js

@@ -0,0 +1,690 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+const EMPTY_STATE = { chats: {}, sessions: {}, telegramContacts: {}, settings: {} };
+export class FileStore {
+    dataDir;
+    defaultMode;
+    stateFile;
+    legacyLogsDir;
+    sessionsDir;
+    telegramChannelsDir;
+    constructor(dataDir, defaultMode) {
+        this.dataDir = dataDir;
+        this.defaultMode = defaultMode;
+        this.stateFile = path.join(dataDir, "state.json");
+        this.legacyLogsDir = path.join(dataDir, "logs");
+        this.sessionsDir = path.join(dataDir, "sessions");
+        this.telegramChannelsDir = path.join(dataDir, "channels", "telegram");
+    }
+    async init() {
+        await fs.mkdir(this.legacyLogsDir, { recursive: true });
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+        await fs.mkdir(this.telegramChannelsDir, { recursive: true });
+        let state = await this.readState();
+        if (Object.keys(state.chats).length === 0) {
+            const recovered = await this.recoverBindingsFromLogs(state);
+            if (Object.keys(recovered.chats).length > 0) {
+                state = recovered;
+            }
+        }
+        await this.writeState(state);
+    }
+    async getChatSession(botId, chatId) {
+        const state = await this.readState();
+        const migrated = this.materializeBindingForBot(state, botId, chatId);
+        if (migrated) {
+            await this.writeState(state);
+        }
+        return this.resolveChatSession(state, botId, chatId);
+    }
+    async listSessions(botId) {
+        const state = await this.readState();
+        const sessions = Object.values(state.sessions);
+        if (!botId) {
+            return sessions.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+        }
+        const sessionIds = new Set(Object.values(state.chats)
+            .filter((binding) => binding.botId === botId)
+            .map((binding) => binding.sessionId));
+        return sessions
+            .filter((session) => sessionIds.has(session.sessionId))
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    }
+    async listActiveSessionIds(botId) {
+        const state = await this.readState();
+        const sessionIds = Object.values(state.chats)
+            .filter((binding) => !botId || binding.botId === botId)
+            .map((binding) => binding.sessionId);
+        return new Set(sessionIds);
+    }
+    async getSession(sessionId) {
+        const state = await this.readState();
+        return state.sessions[sessionId];
+    }
+    async getDefaultStartMode() {
+        const state = await this.readState();
+        return state.settings.defaultStartMode;
+    }
+    async ensureDefaultStartMode(provider) {
+        const state = await this.readState();
+        if (state.settings.defaultStartMode) {
+            return;
+        }
+        state.settings.defaultStartMode = provider;
+        await this.writeState(state);
+    }
+    async createSessionForChat(botId, chatId, workspace, mode, workspaceUid) {
+        const state = await this.readState();
+        const now = new Date().toISOString();
+        const sessionId = randomUUID();
+        state.sessions[sessionId] = {
+            sessionId,
+            publicId: this.nextPublicSessionId(state),
+            mode: mode ?? this.defaultMode,
+            workspace,
+            workspaceUid,
+            createdAt: now,
+            updatedAt: now,
+        };
+        state.chats[this.chatKey(botId, chatId)] = {
+            botId,
+            chatId,
+            sessionId,
+            boundAt: now,
+            updatedAt: now,
+        };
+        delete state.chats[chatId];
+        await this.writeState(state);
+        return this.mustResolveChatSession(state, botId, chatId);
+    }
+    async bindChatToSession(botId, chatId, sessionId) {
+        const state = await this.readState();
+        const record = state.sessions[sessionId];
+        if (!record) {
+            throw new Error(`Session was not found: ${sessionId}`);
+        }
+        const now = new Date().toISOString();
+        const existing = this.resolveBinding(state, botId, chatId);
+        state.chats[this.chatKey(botId, chatId)] = {
+            botId,
+            chatId,
+            sessionId,
+            boundAt: existing?.boundAt ?? now,
+            updatedAt: now,
+        };
+        delete state.chats[chatId];
+        await this.writeState(state);
+        return this.mustResolveChatSession(state, botId, chatId);
+    }
+    async upsertProviderForChat(botId, chatId, provider, session, workspace) {
+        const state = await this.readState();
+        const now = new Date().toISOString();
+        const { binding, record } = this.ensureBoundSession(state, botId, chatId, workspace, now);
+        record.workspace = workspace;
+        record[provider] = {
+            provider,
+            ...session,
+        };
+        record.updatedAt = now;
+        binding.updatedAt = now;
+        await this.writeState(state);
+        return this.mustResolveChatSession(state, botId, chatId);
+    }
+    async upsertProviderForSession(sessionId, provider, session, workspace) {
+        const state = await this.readState();
+        const record = state.sessions[sessionId];
+        if (!record) {
+            throw new Error(`Session was not found: ${sessionId}`);
+        }
+        record.workspace = workspace;
+        record[provider] = {
+            provider,
+            ...session,
+        };
+        record.updatedAt = new Date().toISOString();
+        await this.writeState(state);
+        return record;
+    }
+    async setModeForChat(botId, chatId, mode) {
+        const state = await this.readState();
+        const now = new Date().toISOString();
+        const { binding, record } = this.ensureBoundSession(state, botId, chatId, this.dataDir, now);
+        record.mode = mode;
+        record.updatedAt = now;
+        binding.updatedAt = now;
+        await this.writeState(state);
+        return this.mustResolveChatSession(state, botId, chatId);
+    }
+    async resetChat(botId, chatId) {
+        const state = await this.readState();
+        delete state.chats[this.chatKey(botId, chatId)];
+        delete state.chats[chatId];
+        await this.writeState(state);
+        await fs.rm(this.channelFilePath(botId, chatId), { force: true }).catch(() => undefined);
+    }
+    async rememberTelegramContact(contact) {
+        const state = await this.readState();
+        const key = this.chatKey(contact.botId, contact.chatId);
+        const existing = state.telegramContacts[key];
+        state.telegramContacts[key] = {
+            ...existing,
+            ...contact,
+            transport: "telegram",
+            lastSeenAt: contact.lastSeenAt,
+        };
+        await this.writeState(state);
+    }
+    async listTelegramContacts() {
+        const state = await this.readState();
+        return Object.values(state.telegramContacts).sort((left, right) => right.lastSeenAt.localeCompare(left.lastSeenAt));
+    }
+    async appendLog(remoteSessionId, line) {
+        const eventFile = this.sessionEventsPath(remoteSessionId);
+        await fs.mkdir(path.dirname(eventFile), { recursive: true });
+        await fs.appendFile(eventFile, `${line}\n`, "utf8");
+        const legacyLogFile = path.join(this.legacyLogsDir, `${remoteSessionId}.jsonl`);
+        await fs.appendFile(legacyLogFile, `${line}\n`, "utf8");
+    }
+    async readLogs(remoteSessionId, limit = 200) {
+        const eventFile = this.sessionEventsPath(remoteSessionId);
+        const primary = await this.readLogFile(eventFile);
+        if (primary.length > 0) {
+            return primary.slice(Math.max(0, primary.length - limit));
+        }
+        const legacyLogFile = path.join(this.legacyLogsDir, `${remoteSessionId}.jsonl`);
+        const legacy = await this.readLogFile(legacyLogFile);
+        return legacy.slice(Math.max(0, legacy.length - limit));
+    }
+    async readState() {
+        const directoryState = await this.readStateFromDirectories();
+        const legacyState = await this.readLegacyState();
+        const state = this.mergeStates(directoryState, legacyState);
+        this.ensurePublicSessionIds(state);
+        return state;
+    }
+    async writeState(state) {
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+        await fs.mkdir(this.telegramChannelsDir, { recursive: true });
+        await this.writeJsonFileAtomic(this.stateFile, state);
+        await this.writeSessions(state.sessions);
+        await this.writeChannelBindings(state.chats);
+    }
+    async readStateFromDirectories() {
+        const state = { chats: {}, sessions: {}, telegramContacts: {}, settings: {} };
+        const sessionDirs = await fs.readdir(this.sessionsDir, { withFileTypes: true }).catch(() => []);
+        for (const entry of sessionDirs) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const sessionFile = path.join(this.sessionsDir, entry.name, "session.json");
+            const session = await this.readJsonFile(sessionFile);
+            if (!session) {
+                continue;
+            }
+            state.sessions[session.sessionId] = this.normalizeSession(session);
+        }
+        const botDirs = await fs.readdir(this.telegramChannelsDir, { withFileTypes: true }).catch(() => []);
+        for (const botEntry of botDirs) {
+            if (!botEntry.isDirectory()) {
+                continue;
+            }
+            const botId = decodeURIComponent(botEntry.name);
+            const botDir = path.join(this.telegramChannelsDir, botEntry.name);
+            const bindingFiles = await fs.readdir(botDir, { withFileTypes: true }).catch(() => []);
+            for (const fileEntry of bindingFiles) {
+                if (!fileEntry.isFile() || !fileEntry.name.endsWith(".json")) {
+                    continue;
+                }
+                const binding = await this.readJsonFile(path.join(botDir, fileEntry.name));
+                if (!binding?.chatId || !binding.sessionId) {
+                    continue;
+                }
+                binding.botId = binding.botId || botId;
+                state.chats[this.chatKey(binding.botId, binding.chatId)] = binding;
+            }
+        }
+        return state;
+    }
+    async readLegacyState() {
+        try {
+            const raw = await fs.readFile(this.stateFile, "utf8");
+            const { state } = this.normalizeState(this.parseJsonObject(raw, this.stateFile));
+            return state;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return EMPTY_STATE;
+            }
+            throw error;
+        }
+    }
+    async writeSessions(sessions) {
+        for (const session of Object.values(sessions)) {
+            const normalized = this.normalizeSession(session);
+            const sessionDir = this.sessionDirPath(session.sessionId);
+            await fs.mkdir(sessionDir, { recursive: true });
+            await this.writeJsonFileAtomic(path.join(sessionDir, "session.json"), normalized);
+        }
+    }
+    async writeChannelBindings(chats) {
+        const desiredFiles = new Set();
+        for (const binding of Object.values(chats)) {
+            if (!binding.botId) {
+                continue;
+            }
+            const filePath = this.channelFilePath(binding.botId, binding.chatId);
+            desiredFiles.add(filePath);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await this.writeJsonFileAtomic(filePath, binding);
+        }
+        const existingFiles = await this.listChannelFiles();
+        for (const filePath of existingFiles) {
+            if (!desiredFiles.has(filePath)) {
+                await fs.rm(filePath, { force: true }).catch(() => undefined);
+            }
+        }
+    }
+    async listChannelFiles() {
+        const files = [];
+        const botDirs = await fs.readdir(this.telegramChannelsDir, { withFileTypes: true }).catch(() => []);
+        for (const botEntry of botDirs) {
+            if (!botEntry.isDirectory()) {
+                continue;
+            }
+            const botDir = path.join(this.telegramChannelsDir, botEntry.name);
+            const entries = await fs.readdir(botDir, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith(".json")) {
+                    files.push(path.join(botDir, entry.name));
+                }
+            }
+        }
+        return files;
+    }
+    async readLogFile(filePath) {
+        const raw = await fs.readFile(filePath, "utf8").catch((error) => {
+            if (error.code === "ENOENT") {
+                return "";
+            }
+            throw error;
+        });
+        const entries = [];
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+        }
+        return entries;
+    }
+    async readJsonFile(filePath) {
+        const raw = await fs.readFile(filePath, "utf8").catch((error) => {
+            if (error.code === "ENOENT") {
+                return undefined;
+            }
+            throw error;
+        });
+        if (!raw) {
+            return undefined;
+        }
+        try {
+            return this.parseJsonObject(raw, filePath);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    parseJsonObject(raw, source) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            const end = this.findJsonObjectEnd(raw);
+            if (!end) {
+                throw error;
+            }
+            const trailing = raw.slice(end).trim();
+            if (!trailing) {
+                throw error;
+            }
+            console.warn(`[store] ${source} has ${trailing.length} trailing character(s) after the first JSON object; ignoring trailing data.`);
+            return JSON.parse(raw.slice(0, end));
+        }
+    }
+    findJsonObjectEnd(raw) {
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let started = false;
+        for (let index = 0; index < raw.length; index += 1) {
+            const char = raw[index];
+            if (!started) {
+                if (/\s/.test(char)) {
+                    continue;
+                }
+                if (char !== "{") {
+                    return undefined;
+                }
+                started = true;
+                depth = 1;
+                continue;
+            }
+            if (inString) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (char === "\\") {
+                    escaped = true;
+                }
+                else if (char === "\"") {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === "\"") {
+                inString = true;
+            }
+            else if (char === "{") {
+                depth += 1;
+            }
+            else if (char === "}") {
+                depth -= 1;
+                if (depth === 0) {
+                    return index + 1;
+                }
+            }
+        }
+        return undefined;
+    }
+    async writeJsonFileAtomic(filePath, value) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+        await fs.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        await fs.rename(temporaryPath, filePath);
+    }
+    normalizeState(rawState) {
+        if ("sessions" in rawState) {
+            const state = rawState;
+            state.telegramContacts = state.telegramContacts ?? {};
+            state.settings = this.normalizeSettings(state.settings);
+            for (const session of Object.values(state.sessions)) {
+                this.normalizeSession(session);
+            }
+            for (const [key, contact] of Object.entries(state.telegramContacts)) {
+                const normalized = this.normalizeTelegramContact(contact);
+                if (normalized) {
+                    state.telegramContacts[key] = normalized;
+                }
+                else {
+                    delete state.telegramContacts[key];
+                }
+            }
+            return { state, migrated: false };
+        }
+        const legacy = rawState;
+        const migrated = { chats: {}, sessions: {}, telegramContacts: {}, settings: {} };
+        for (const [chatId, mapping] of Object.entries(legacy.chats || {})) {
+            const sessionId = randomUUID();
+            const now = mapping.updatedAt || new Date().toISOString();
+            const workspace = mapping.codex?.cwd || mapping.claude?.cwd || this.dataDir;
+            migrated.sessions[sessionId] = {
+                sessionId,
+                publicId: this.nextPublicSessionId(migrated),
+                mode: mapping.mode || this.defaultMode,
+                workspace,
+                codex: mapping.codex ? { ...mapping.codex, provider: "codex", cwd: mapping.codex.cwd || workspace } : undefined,
+                claude: mapping.claude ? { ...mapping.claude, provider: "claude", cwd: mapping.claude.cwd || workspace } : undefined,
+                createdAt: now,
+                updatedAt: now,
+            };
+            migrated.chats[this.chatKey(mapping.botId, chatId)] = {
+                botId: mapping.botId,
+                chatId,
+                sessionId,
+                boundAt: now,
+                updatedAt: now,
+            };
+        }
+        return { state: migrated, migrated: true };
+    }
+    mergeStates(primary, fallback) {
+        const state = {
+            chats: { ...fallback.chats, ...primary.chats },
+            sessions: { ...fallback.sessions, ...primary.sessions },
+            telegramContacts: { ...fallback.telegramContacts, ...primary.telegramContacts },
+            settings: this.normalizeSettings({ ...fallback.settings, ...primary.settings }),
+        };
+        for (const session of Object.values(state.sessions)) {
+            this.normalizeSession(session);
+        }
+        for (const [key, contact] of Object.entries(state.telegramContacts)) {
+            const normalized = this.normalizeTelegramContact(contact);
+            if (normalized) {
+                state.telegramContacts[key] = normalized;
+            }
+            else {
+                delete state.telegramContacts[key];
+            }
+        }
+        return state;
+    }
+    async recoverBindingsFromLogs(state) {
+        const latestByChat = new Map();
+        for (const session of Object.values(state.sessions)) {
+            const eventFile = this.sessionEventsPath(session.sessionId);
+            const primaryEntries = await this.readLogFile(eventFile);
+            const entries = primaryEntries.length > 0
+                ? primaryEntries
+                : await this.readLogFile(path.join(this.legacyLogsDir, `${session.sessionId}.jsonl`));
+            for (const entry of entries) {
+                if (!entry.chatId) {
+                    continue;
+                }
+                const current = latestByChat.get(entry.chatId);
+                if (!current || current.timestamp.localeCompare(entry.timestamp) < 0) {
+                    latestByChat.set(entry.chatId, {
+                        sessionId: session.sessionId,
+                        timestamp: entry.timestamp,
+                    });
+                }
+            }
+        }
+        for (const [chatId, recovered] of latestByChat.entries()) {
+            if (state.chats[chatId]) {
+                continue;
+            }
+            state.chats[chatId] = {
+                chatId,
+                sessionId: recovered.sessionId,
+                boundAt: recovered.timestamp,
+                updatedAt: recovered.timestamp,
+            };
+        }
+        return state;
+    }
+    normalizeSettings(settings) {
+        const normalized = settings ? { ...settings } : {};
+        if (normalized.defaultStartMode !== "codex" && normalized.defaultStartMode !== "claude") {
+            delete normalized.defaultStartMode;
+        }
+        return normalized;
+    }
+    normalizeSession(session) {
+        session.publicId = session.publicId || "";
+        session.workspace = session.workspace || session.codex?.cwd || session.claude?.cwd || this.dataDir;
+        session.workspaceUid = typeof session.workspaceUid === "string" && session.workspaceUid.trim() ? session.workspaceUid.trim() : undefined;
+        session.createdAt = session.createdAt || session.updatedAt || new Date().toISOString();
+        session.updatedAt = session.updatedAt || session.createdAt;
+        if (session.mode !== "codex" && session.mode !== "claude") {
+            session.mode = session.codex ? "codex" : session.claude ? "claude" : this.defaultMode;
+        }
+        for (const provider of ["codex", "claude"]) {
+            const binding = session[provider];
+            if (binding && !binding.cwd) {
+                binding.cwd = session.workspace;
+            }
+        }
+        return session;
+    }
+    normalizeTelegramContact(contact) {
+        if (contact.transport !== "telegram" || !contact.botId || !contact.chatId) {
+            return undefined;
+        }
+        return {
+            ...contact,
+            transport: "telegram",
+            chatType: contact.chatType || "private",
+            lastSeenAt: contact.lastSeenAt || new Date().toISOString(),
+        };
+    }
+    resolveChatSession(state, botId, chatId) {
+        const binding = this.resolveBinding(state, botId, chatId);
+        if (!binding) {
+            return undefined;
+        }
+        const session = state.sessions[binding.sessionId];
+        if (!session) {
+            return undefined;
+        }
+        return {
+            botId: binding.botId ?? botId,
+            chatId,
+            binding,
+            session,
+        };
+    }
+    mustResolveChatSession(state, botId, chatId) {
+        const result = this.resolveChatSession(state, botId, chatId);
+        if (!result) {
+            throw new Error(`Chat binding was not found for bot ${botId} chat ${chatId}.`);
+        }
+        return result;
+    }
+    ensureBoundSession(state, botId, chatId, workspace, now) {
+        const exactKey = this.chatKey(botId, chatId);
+        const migrated = this.materializeBindingForBot(state, botId, chatId);
+        let binding = state.chats[exactKey] ?? (migrated ? state.chats[exactKey] : undefined);
+        let record = binding ? state.sessions[binding.sessionId] : undefined;
+        if (!binding || !record) {
+            const sessionId = randomUUID();
+            record = {
+                sessionId,
+                publicId: this.nextPublicSessionId(state),
+                mode: this.defaultMode,
+                workspace,
+                createdAt: now,
+                updatedAt: now,
+            };
+            binding = {
+                botId,
+                chatId,
+                sessionId,
+                boundAt: now,
+                updatedAt: now,
+            };
+            state.sessions[sessionId] = record;
+            state.chats[exactKey] = binding;
+            return { binding, record };
+        }
+        if (!state.chats[exactKey]) {
+            binding = {
+                ...binding,
+                botId,
+                chatId,
+            };
+            state.chats[exactKey] = binding;
+        }
+        else if (!binding.botId) {
+            binding.botId = botId;
+        }
+        return { binding, record };
+    }
+    resolveBinding(state, botId, chatId) {
+        return state.chats[this.chatKey(botId, chatId)];
+    }
+    materializeBindingForBot(state, botId, chatId) {
+        const exactKey = this.chatKey(botId, chatId);
+        if (state.chats[exactKey]) {
+            return false;
+        }
+        const legacyBinding = state.chats[chatId];
+        if (!legacyBinding) {
+            return false;
+        }
+        state.chats[exactKey] = {
+            ...legacyBinding,
+            botId,
+            chatId,
+        };
+        delete state.chats[chatId];
+        return true;
+    }
+    sessionDirPath(sessionId) {
+        return path.join(this.sessionsDir, encodeURIComponent(sessionId));
+    }
+    sessionEventsPath(sessionId) {
+        return path.join(this.sessionDirPath(sessionId), "events.jsonl");
+    }
+    channelFilePath(botId, chatId) {
+        return path.join(this.telegramChannelsDir, encodeURIComponent(botId), `${encodeURIComponent(chatId)}.json`);
+    }
+    chatKey(botId, chatId) {
+        return botId ? `${botId}:${chatId}` : chatId;
+    }
+    ensurePublicSessionIds(state) {
+        const used = new Set();
+        for (const session of Object.values(state.sessions)) {
+            const parsed = this.parsePublicSessionNumber(session.publicId);
+            if (parsed !== undefined) {
+                used.add(parsed);
+            }
+        }
+        const missing = Object.values(state.sessions)
+            .filter((session) => this.parsePublicSessionNumber(session.publicId) === undefined)
+            .sort((left, right) => {
+            const timeCompare = left.createdAt.localeCompare(right.createdAt);
+            if (timeCompare !== 0) {
+                return timeCompare;
+            }
+            return left.sessionId.localeCompare(right.sessionId);
+        });
+        for (const session of missing) {
+            let next = 1;
+            while (used.has(next)) {
+                next += 1;
+            }
+            session.publicId = this.formatPublicSessionId(next);
+            used.add(next);
+        }
+    }
+    nextPublicSessionId(state) {
+        let max = 0;
+        for (const session of Object.values(state.sessions)) {
+            const parsed = this.parsePublicSessionNumber(session.publicId);
+            if (parsed !== undefined && parsed > max) {
+                max = parsed;
+            }
+        }
+        return this.formatPublicSessionId(max + 1);
+    }
+    parsePublicSessionNumber(publicId) {
+        if (!publicId) {
+            return undefined;
+        }
+        const match = publicId.trim().match(/^S(\d+)$/i);
+        if (!match) {
+            return undefined;
+        }
+        const parsed = Number.parseInt(match[1], 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+    formatPublicSessionId(value) {
+        return `S${String(value).padStart(3, "0")}`;
+    }
+}