@deadragdoll/tellymcp 0.0.9 → 0.0.11

package/dist/services/features/telegram-mcp/src/shared/integrations/xchange/sqliteRecordStore.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertXchangeRecord = upsertXchangeRecord;
+exports.listXchangeRecords = listXchangeRecords;
+exports.getXchangeRecord = getXchangeRecord;
+exports.markXchangeRecordRead = markXchangeRecordRead;
+const node_path_1 = __importDefault(require("node:path"));
+const node_sqlite_1 = require("node:sqlite");
+const client_1 = require("../terminal/client");
+const DB_FILE_NAME = "xchange.sqlite3";
+function parseJson(raw, fallback) {
+    if (!raw?.trim()) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function toRecord(row) {
+    return {
+        record_id: row.record_id,
+        session_id: row.session_id,
+        category: row.category,
+        direction: row.direction,
+        status: row.status,
+        ...(row.kind ? { kind: row.kind } : {}),
+        summary: row.summary,
+        body_text: row.body_text,
+        action_desc: row.action_desc,
+        tools: parseJson(row.tools_json, []),
+        ...(row.note_path ? { note_path: row.note_path } : {}),
+        ...(row.note_relative_path ? { note_relative_path: row.note_relative_path } : {}),
+        ...(row.source_session_id ? { source_session_id: row.source_session_id } : {}),
+        ...(row.source_label ? { source_label: row.source_label } : {}),
+        ...(row.source_client_uuid ? { source_client_uuid: row.source_client_uuid } : {}),
+        ...(row.source_local_session_id
+            ? { source_local_session_id: row.source_local_session_id }
+            : {}),
+        ...(row.target_session_id ? { target_session_id: row.target_session_id } : {}),
+        ...(row.target_label ? { target_label: row.target_label } : {}),
+        ...(row.target_client_uuid ? { target_client_uuid: row.target_client_uuid } : {}),
+        ...(row.target_local_session_id
+            ? { target_local_session_id: row.target_local_session_id }
+            : {}),
+        ...(row.project_uuid ? { project_uuid: row.project_uuid } : {}),
+        ...(row.project_name ? { project_name: row.project_name } : {}),
+        ...(row.requires_reply !== null
+            ? { requires_reply: Boolean(row.requires_reply) }
+            : {}),
+        ...(row.expected_reply ? { expected_reply: row.expected_reply } : {}),
+        ...(row.in_reply_to ? { in_reply_to: row.in_reply_to } : {}),
+        attachments: parseJson(row.attachments_json, []),
+        tags: parseJson(row.tags_json, []),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ...(row.read_at ? { read_at: row.read_at } : {}),
+    };
+}
+async function resolveDbPath(config, workspaceDir, exchangeDirName) {
+    const dir = await (0, client_1.ensureXchangeDir)(config, workspaceDir, exchangeDirName);
+    return node_path_1.default.join(dir, DB_FILE_NAME);
+}
+function applySchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS xchange_records (
+      record_id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      category TEXT NOT NULL,
+      direction TEXT NOT NULL,
+      status TEXT NOT NULL,
+      kind TEXT,
+      summary TEXT NOT NULL,
+      body_text TEXT NOT NULL,
+      action_desc TEXT NOT NULL,
+      tools_json TEXT NOT NULL,
+      note_path TEXT,
+      note_relative_path TEXT,
+      source_session_id TEXT,
+      source_label TEXT,
+      source_client_uuid TEXT,
+      source_local_session_id TEXT,
+      target_session_id TEXT,
+      target_label TEXT,
+      target_client_uuid TEXT,
+      target_local_session_id TEXT,
+      project_uuid TEXT,
+      project_name TEXT,
+      requires_reply INTEGER,
+      expected_reply TEXT,
+      in_reply_to TEXT,
+      attachments_json TEXT NOT NULL,
+      tags_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      read_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_xchange_records_session_created
+      ON xchange_records(session_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_xchange_records_session_status
+      ON xchange_records(session_id, status, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_xchange_records_session_category
+      ON xchange_records(session_id, category, created_at DESC);
+  `);
+}
+async function withDatabase(config, workspaceDir, exchangeDirName, callback) {
+    const dbPath = await resolveDbPath(config, workspaceDir, exchangeDirName);
+    const db = new node_sqlite_1.DatabaseSync(dbPath);
+    try {
+        applySchema(db);
+        return callback(db);
+    }
+    finally {
+        db.close();
+    }
+}
+async function upsertXchangeRecord(config, workspaceDir, exchangeDirName, record) {
+    await withDatabase(config, workspaceDir, exchangeDirName, (db) => {
+        db.prepare(`
+      INSERT OR REPLACE INTO xchange_records (
+        record_id, session_id, category, direction, status, kind, summary, body_text, action_desc,
+        tools_json, note_path, note_relative_path, source_session_id, source_label,
+        source_client_uuid, source_local_session_id, target_session_id, target_label,
+        target_client_uuid, target_local_session_id, project_uuid, project_name, requires_reply,
+        expected_reply, in_reply_to, attachments_json, tags_json, created_at, updated_at, read_at
+      ) VALUES (
+        @record_id, @session_id, @category, @direction, @status, @kind, @summary, @body_text, @action_desc,
+        @tools_json, @note_path, @note_relative_path, @source_session_id, @source_label,
+        @source_client_uuid, @source_local_session_id, @target_session_id, @target_label,
+        @target_client_uuid, @target_local_session_id, @project_uuid, @project_name, @requires_reply,
+        @expected_reply, @in_reply_to, @attachments_json, @tags_json, @created_at, @updated_at, @read_at
+      )
+    `).run({
+            record_id: record.record_id,
+            session_id: record.session_id,
+            category: record.category,
+            direction: record.direction,
+            status: record.status,
+            kind: record.kind ?? null,
+            summary: record.summary,
+            body_text: record.body_text,
+            action_desc: record.action_desc,
+            tools_json: JSON.stringify(record.tools),
+            note_path: record.note_path ?? null,
+            note_relative_path: record.note_relative_path ?? null,
+            source_session_id: record.source_session_id ?? null,
+            source_label: record.source_label ?? null,
+            source_client_uuid: record.source_client_uuid ?? null,
+            source_local_session_id: record.source_local_session_id ?? null,
+            target_session_id: record.target_session_id ?? null,
+            target_label: record.target_label ?? null,
+            target_client_uuid: record.target_client_uuid ?? null,
+            target_local_session_id: record.target_local_session_id ?? null,
+            project_uuid: record.project_uuid ?? null,
+            project_name: record.project_name ?? null,
+            requires_reply: typeof record.requires_reply === "boolean"
+                ? Number(record.requires_reply)
+                : null,
+            expected_reply: record.expected_reply ?? null,
+            in_reply_to: record.in_reply_to ?? null,
+            attachments_json: JSON.stringify(record.attachments),
+            tags_json: JSON.stringify(record.tags),
+            created_at: record.created_at,
+            updated_at: record.updated_at,
+            read_at: record.read_at ?? null,
+        });
+    });
+}
+async function listXchangeRecords(config, workspaceDir, exchangeDirName, sessionId, filter = {}) {
+    return withDatabase(config, workspaceDir, exchangeDirName, (db) => {
+        const conditions = ["session_id = ?"];
+        const values = [sessionId];
+        if (filter.status) {
+            conditions.push("status = ?");
+            values.push(filter.status);
+        }
+        if (filter.category) {
+            conditions.push("category = ?");
+            values.push(filter.category);
+        }
+        if (filter.direction) {
+            conditions.push("direction = ?");
+            values.push(filter.direction);
+        }
+        let sql = `
+      SELECT * FROM xchange_records
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY created_at DESC
+    `;
+        if (typeof filter.limit === "number" && Number.isFinite(filter.limit)) {
+            sql += " LIMIT ?";
+            values.push(Math.max(1, Math.trunc(filter.limit)));
+        }
+        const rows = db.prepare(sql).all(...values);
+        return rows.map(toRecord);
+    });
+}
+async function getXchangeRecord(config, workspaceDir, exchangeDirName, sessionId, recordId) {
+    return withDatabase(config, workspaceDir, exchangeDirName, (db) => {
+        const row = db.prepare(`
+      SELECT * FROM xchange_records
+      WHERE session_id = ? AND record_id = ?
+      LIMIT 1
+    `).get(sessionId, recordId);
+        return row ? toRecord(row) : null;
+    });
+}
+async function markXchangeRecordRead(config, workspaceDir, exchangeDirName, sessionId, recordId, readAt = new Date().toISOString()) {
+    return withDatabase(config, workspaceDir, exchangeDirName, (db) => {
+        const result = db.prepare(`
+      UPDATE xchange_records
+      SET status = 'read', updated_at = ?, read_at = COALESCE(read_at, ?)
+      WHERE session_id = ? AND record_id = ?
+    `).run(readAt, readAt, sessionId, recordId);
+        return (result.changes ?? 0) > 0;
+    });
+}

package/dist/services/features/telegram-mcp/src/shared/lib/gatewayScope.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGatewayToken = normalizeGatewayToken;
+exports.gatewayTokenToScopeKey = gatewayTokenToScopeKey;
+exports.resolveGatewayScopeKey = resolveGatewayScopeKey;
+const node_crypto_1 = require("node:crypto");
+function normalizeGatewayToken(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const token = value.trim();
+    return token ? token : null;
+}
+function gatewayTokenToScopeKey(token) {
+    return (0, node_crypto_1.createHash)("sha256").update(token).digest("hex");
+}
+function resolveGatewayScopeKey(input) {
+    const gatewayToken = normalizeGatewayToken(input.gateway_token);
+    if (gatewayToken) {
+        return gatewayTokenToScopeKey(gatewayToken);
+    }
+    const scopeKey = normalizeGatewayToken(input.scope_key);
+    return scopeKey;
+}

package/dist/services/features/telegram-mcp/src/shared/lib/logger/logger.js

@@ -18,7 +18,13 @@ function createLogger(config) {
         targets: (0, pinoTargets_1.createPinoTargets)({
             level: config.logging.level,
             fileEnabled: config.logging.fileEnabled,
+            ...(config.logging.stderrLevel
+                ? { stderrLevel: config.logging.stderrLevel }
+                : {}),
             filePath: config.logging.filePath,
+            ...(config.logging.fileLevel
+                ? { fileLevel: config.logging.fileLevel }
+                : {}),
         }),
     });
     const baseLogger = (0, pino_1.default)({

package/dist/services/features/telegram-mcp/src/shared/lib/project-identity/projectIdentity.js

@@ -1,9 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectIdentityResolver = void 0;
+exports.resolveSessionDefaultsForCwd = resolveSessionDefaultsForCwd;
+exports.readSessionMarkerState = readSessionMarkerState;
+exports.writeSessionMarkerState = writeSessionMarkerState;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+function resolveSessionDefaultsForCwd(input) {
+    const inputCwd = resolveInputCwd(input.cwd);
+    const resolvedCwd = inputCwd || resolveInputCwd(input.fallbackCwd) || process.cwd();
+    const titleBase = (0, node_path_1.basename)(resolvedCwd) || "Project";
+    const explicitSessionId = input.session_id?.trim();
+    const explicitSessionLabel = input.session_label?.trim();
+    const sessionMarker = explicitSessionId || explicitSessionLabel
+        ? null
+        : readSessionMarkerState(resolvedCwd, input.logger);
+    const derivedSessionId = sessionMarker?.localSessionId ||
+        `${slugify(titleBase) || "session"}-${shortHash(resolvedCwd)}`;
+    const derivedSessionLabel = sessionMarker?.sessionLabel || titleBase;
+    if (!sessionMarker && !explicitSessionId && !explicitSessionLabel) {
+        writeSessionMarkerState({
+            cwd: resolvedCwd,
+            localSessionId: explicitSessionId || derivedSessionId,
+            sessionLabel: explicitSessionLabel || derivedSessionLabel,
+            ...(input.logger ? { logger: input.logger } : {}),
+        });
+    }
+    return {
+        sessionId: explicitSessionId || derivedSessionId,
+        sessionLabel: explicitSessionLabel || derivedSessionLabel,
+        cwd: resolvedCwd,
+        sessionIdDerived: !explicitSessionId,
+        sessionLabelDerived: !explicitSessionLabel,
+    };
+}
 const SESSION_MARKER_FILE_NAME = ".mcpsession.json";
 function slugify(input) {
     return input
@@ -52,6 +83,106 @@ function resolveInputCwd(value) {
     const trimmed = normalizeOptionalString(value);
     return trimmed ? (0, node_path_1.resolve)(trimmed) : undefined;
 }
+function readSessionMarkerState(inputCwd, logger) {
+    const resolvedCwd = (0, node_path_1.resolve)(inputCwd);
+    const markerPath = (0, node_path_1.join)(resolvedCwd, SESSION_MARKER_FILE_NAME);
+    if (!(0, node_fs_1.existsSync)(markerPath)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(markerPath, "utf8"));
+        const localSessionId = typeof parsed.local_session_id === "string"
+            ? parsed.local_session_id.trim()
+            : "";
+        if (!localSessionId) {
+            return null;
+        }
+        return {
+            localSessionId,
+            ...(typeof parsed.session_label === "string" &&
+                parsed.session_label.trim()
+                ? { sessionLabel: parsed.session_label.trim() }
+                : {}),
+            ...(typeof parsed.cwd === "string" && parsed.cwd.trim()
+                ? { cwd: parsed.cwd.trim() }
+                : {}),
+            ...(typeof parsed.env_file === "string" && parsed.env_file.trim()
+                ? { envFile: parsed.env_file.trim() }
+                : {}),
+            ...(typeof parsed.last_seen_tools_hash === "string" &&
+                parsed.last_seen_tools_hash.trim()
+                ? { lastSeenToolsHash: parsed.last_seen_tools_hash.trim() }
+                : {}),
+            ...(typeof parsed.last_notified_tools_hash === "string" &&
+                parsed.last_notified_tools_hash.trim()
+                ? { lastNotifiedToolsHash: parsed.last_notified_tools_hash.trim() }
+                : {}),
+            ...(typeof parsed.updated_at === "string" && parsed.updated_at.trim()
+                ? { updatedAt: parsed.updated_at.trim() }
+                : {}),
+        };
+    }
+    catch (error) {
+        logger?.warn("Failed to read .mcpsession.json, ignoring marker", {
+            cwd: resolvedCwd,
+            markerPath,
+            error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+        });
+        return null;
+    }
+}
+function writeSessionMarkerState(input) {
+    const resolvedCwd = (0, node_path_1.resolve)(input.cwd);
+    if (!(0, node_fs_1.existsSync)(resolvedCwd)) {
+        input.logger?.debug("Skipping .mcpsession.json write because cwd does not exist locally", {
+            cwd: resolvedCwd,
+            sessionId: input.localSessionId,
+        });
+        return;
+    }
+    const markerPath = (0, node_path_1.join)(resolvedCwd, SESSION_MARKER_FILE_NAME);
+    const legacyTellyStatePath = (0, node_path_1.join)(resolvedCwd, ".tellysession.json");
+    const now = new Date().toISOString();
+    const current = readSessionMarkerState(resolvedCwd, input.logger);
+    try {
+        (0, node_fs_1.writeFileSync)(markerPath, `${JSON.stringify({
+            version: 1,
+            local_session_id: input.localSessionId,
+            ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
+            cwd: resolvedCwd,
+            ...(typeof input.envFile === "string" && input.envFile.trim()
+                ? { env_file: input.envFile.trim() }
+                : current?.envFile
+                    ? { env_file: current.envFile }
+                    : {}),
+            ...(typeof input.lastSeenToolsHash === "string" && input.lastSeenToolsHash.trim()
+                ? { last_seen_tools_hash: input.lastSeenToolsHash.trim() }
+                : current?.lastSeenToolsHash
+                    ? { last_seen_tools_hash: current.lastSeenToolsHash }
+                    : {}),
+            ...(typeof input.lastNotifiedToolsHash === "string" &&
+                input.lastNotifiedToolsHash.trim()
+                ? { last_notified_tools_hash: input.lastNotifiedToolsHash.trim() }
+                : current?.lastNotifiedToolsHash
+                    ? { last_notified_tools_hash: current.lastNotifiedToolsHash }
+                    : {}),
+            created_at: now,
+            updated_at: now,
+            ...(current ? { first_seen_local_session_id: current.localSessionId } : {}),
+        }, null, 2)}\n`, "utf8");
+        if ((0, node_fs_1.existsSync)(legacyTellyStatePath)) {
+            (0, node_fs_1.rmSync)(legacyTellyStatePath, { force: true });
+        }
+    }
+    catch (error) {
+        input.logger?.warn("Failed to write .mcpsession.json", {
+            cwd: resolvedCwd,
+            markerPath,
+            sessionId: input.localSessionId,
+            error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+        });
+    }
+}
 class ProjectIdentityResolver {
     config;
     logger;
@@ -76,29 +207,13 @@ class ProjectIdentityResolver {
         return this.identity;
     }
     resolveSessionDefaults(input) {
-        const inputCwd = resolveInputCwd(input.cwd);
-        const resolvedCwd = inputCwd || this.identity.cwd;
-        const titleBase = (0, node_path_1.basename)(resolvedCwd) || this.identity.resolvedTitle || "Project";
-        const sessionMarker = this.readSessionMarker(resolvedCwd);
-        const derivedSessionId = sessionMarker?.localSessionId ||
-            `${slugify(titleBase) || "session"}-${shortHash(resolvedCwd)}`;
-        const derivedSessionLabel = sessionMarker?.sessionLabel || titleBase;
-        const explicitSessionId = input.session_id?.trim();
-        const explicitSessionLabel = input.session_label?.trim();
-        if (!sessionMarker) {
-            this.writeSessionMarker(resolvedCwd, {
-                localSessionId: explicitSessionId || derivedSessionId,
-                sessionLabel: explicitSessionLabel || derivedSessionLabel,
-                cwd: resolvedCwd,
-            });
-        }
-        return {
-            sessionId: explicitSessionId || derivedSessionId,
-            sessionLabel: explicitSessionLabel || derivedSessionLabel,
-            cwd: resolvedCwd,
-            sessionIdDerived: !explicitSessionId,
-            sessionLabelDerived: !explicitSessionLabel,
-        };
+        return resolveSessionDefaultsForCwd({
+            ...input,
+            session_id: input.session_id?.trim() || this.config.project.sessionId?.trim(),
+            session_label: input.session_label?.trim() || this.config.project.sessionLabel?.trim(),
+            fallbackCwd: this.identity.cwd,
+            logger: this.logger,
+        });
     }
     persistSessionMarker(input) {
         const resolvedCwd = resolveInputCwd(input.cwd) || this.identity.cwd;
@@ -107,6 +222,7 @@ class ProjectIdentityResolver {
             localSessionId: input.sessionId,
             sessionLabel: input.sessionLabel || current?.sessionLabel,
             cwd: resolvedCwd,
+            envFile: input.envFile || current?.envFile,
         });
     }
     removeSessionMarker(cwd) {
@@ -163,61 +279,16 @@ class ProjectIdentityResolver {
         };
     }
     readSessionMarker(cwd) {
-        const markerPath = (0, node_path_1.join)(cwd, SESSION_MARKER_FILE_NAME);
-        if (!(0, node_fs_1.existsSync)(markerPath)) {
-            return null;
-        }
-        try {
-            const parsed = JSON.parse((0, node_fs_1.readFileSync)(markerPath, "utf8"));
-            const localSessionId = typeof parsed.local_session_id === "string"
-                ? parsed.local_session_id.trim()
-                : "";
-            if (!localSessionId) {
-                return null;
-            }
-            return {
-                localSessionId,
-                ...(typeof parsed.session_label === "string" &&
-                    parsed.session_label.trim()
-                    ? { sessionLabel: parsed.session_label.trim() }
-                    : {}),
-                ...(typeof parsed.cwd === "string" && parsed.cwd.trim()
-                    ? { cwd: parsed.cwd.trim() }
-                    : {}),
-            };
-        }
-        catch (error) {
-            this.logger.warn("Failed to read .mcpsession.json, ignoring marker", {
-                cwd,
-                markerPath,
-                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
-            });
-            return null;
-        }
+        return readSessionMarkerState(cwd, this.logger);
     }
     writeSessionMarker(inputCwd, input) {
-        const markerPath = (0, node_path_1.join)(inputCwd, SESSION_MARKER_FILE_NAME);
-        const now = new Date().toISOString();
-        const current = this.readSessionMarker(inputCwd);
-        try {
-            (0, node_fs_1.writeFileSync)(markerPath, `${JSON.stringify({
-                version: 1,
-                local_session_id: input.localSessionId,
-                ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
-                cwd: input.cwd,
-                created_at: now,
-                updated_at: now,
-                ...(current ? { first_seen_local_session_id: current.localSessionId } : {}),
-            }, null, 2)}\n`, "utf8");
-        }
-        catch (error) {
-            this.logger.warn("Failed to write .mcpsession.json", {
-                cwd: inputCwd,
-                markerPath,
-                sessionId: input.localSessionId,
-                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
-            });
-        }
+        writeSessionMarkerState({
+            cwd: inputCwd,
+            localSessionId: input.localSessionId,
+            sessionLabel: input.sessionLabel,
+            envFile: input.envFile,
+            logger: this.logger,
+        });
     }
 }
 exports.ProjectIdentityResolver = ProjectIdentityResolver;

package/dist/services/features/telegram-mcp/src/shared/lib/telegramXchangeRecords.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveXchangeSummary = deriveXchangeSummary;
+exports.writeTelegramMessageXchangeRecord = writeTelegramMessageXchangeRecord;
+exports.writeLocalTaskXchangeRecord = writeLocalTaskXchangeRecord;
+const xchangeRecordHints_1 = require("./xchangeRecordHints");
+const ids_1 = require("./ids/ids");
+const sqliteRecordStore_1 = require("../integrations/xchange/sqliteRecordStore");
+function resolveWorkspaceDir(session, sessionId) {
+    const workspaceDir = session?.cwd?.trim();
+    if (!workspaceDir) {
+        throw new Error(`Workspace cwd is not registered for console '${sessionId}'.`);
+    }
+    return workspaceDir;
+}
+function deriveXchangeSummary(text, fallback) {
+    const firstLine = text
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find(Boolean);
+    const summary = firstLine || fallback;
+    return summary.length > 160 ? `${summary.slice(0, 157)}...` : summary;
+}
+async function writeTelegramMessageXchangeRecord(input) {
+    const recordId = (0, ids_1.createInboxMessageId)(new Date(input.createdAt));
+    const workspaceDir = resolveWorkspaceDir(input.session, input.sessionId);
+    const kind = input.kind ?? "request";
+    const prefersBrowserScreenshot = (0, xchangeRecordHints_1.detectIncomingTelegramBrowserScreenshotRequest)({
+        kind,
+        text: input.text,
+        ...(input.summary?.trim() ? { summary: input.summary.trim() } : {}),
+    });
+    await (0, sqliteRecordStore_1.upsertXchangeRecord)(input.config.terminal, workspaceDir, input.config.exchange.dir, {
+        record_id: recordId,
+        session_id: input.sessionId,
+        category: "telegram_message",
+        direction: "incoming",
+        status: "new",
+        kind,
+        summary: input.summary?.trim() ||
+            deriveXchangeSummary(input.text, "Telegram message"),
+        body_text: input.text,
+        action_desc: (0, xchangeRecordHints_1.buildIncomingTelegramMessageActionDesc)(kind, prefersBrowserScreenshot),
+        tools: (0, xchangeRecordHints_1.buildIncomingTelegramMessageTools)(kind, prefersBrowserScreenshot),
+        attachments: input.attachments ?? [],
+        tags: input.tags ?? ["telegram", "human"],
+        created_at: input.createdAt,
+        updated_at: input.createdAt,
+    });
+    return recordId;
+}
+async function writeLocalTaskXchangeRecord(input) {
+    const recordId = (0, ids_1.createInboxMessageId)(new Date(input.createdAt));
+    const workspaceDir = resolveWorkspaceDir(input.session, input.sessionId);
+    await (0, sqliteRecordStore_1.upsertXchangeRecord)(input.config.terminal, workspaceDir, input.config.exchange.dir, {
+        record_id: recordId,
+        session_id: input.sessionId,
+        category: input.category ?? "local_handoff",
+        direction: input.direction ?? "local",
+        status: "new",
+        ...(input.kind ? { kind: input.kind } : {}),
+        summary: input.summary.trim(),
+        body_text: input.text,
+        action_desc: input.actionDesc,
+        tools: input.tools,
+        attachments: input.attachments ?? [],
+        tags: input.tags ?? ["local", "task"],
+        created_at: input.createdAt,
+        updated_at: input.createdAt,
+    });
+    return recordId;
+}