@dinoxx/dinox-cli 2.3.0 → 2.5.2

package/dist/gateway/threadStore.js

@@ -0,0 +1,597 @@
+import { withPowerSyncWriteTransaction } from '../powersync/runtime.js';
+const THREAD_CHAT_TYPE = 'thread';
+const MESSAGE_ENTRY_TYPE = 'message';
+const LEGACY_MESSAGE_ENTRY_TYPE = 'thread';
+const CONTEXT_RESET_ENTRY_TYPE = 'internal';
+const CHAT_MESSAGE_VERSION = 'v1';
+const ORDER_INDEX_STEP = 1024;
+const RUN_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const MESSAGE_ENTRY_FILTER = '(entry_type IS NULL OR entry_type = \'\' OR entry_type = ? OR entry_type = ?)';
+export const TERMINAL_RUN_STATUSES = new Set([
+    'succeeded',
+    'failed',
+    'cancelled',
+    'interrupted',
+    'expired',
+]);
+function safeJson(value) {
+    return JSON.stringify(value ?? null);
+}
+function parseJson(value) {
+    if (typeof value !== 'string' || !value)
+        return null;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toOrderIndex(value) {
+    const parsed = typeof value === 'string' ? Number(value) : value;
+    return typeof parsed === 'number' && Number.isSafeInteger(parsed) ? parsed : null;
+}
+/** Mirrors desktop `withRunMetadata`: the UI reads `metadata.status` for streaming state. */
+export function withRunMetadata(message, runId, status) {
+    const uiStatus = status === 'succeeded' || status === 'waiting_approval'
+        ? 'done'
+        : TERMINAL_RUN_STATUSES.has(status)
+            ? 'error'
+            : 'streaming';
+    return { ...message, metadata: { ...(message.metadata ?? {}), runId, status: uiStatus } };
+}
+function withQueueMarker(message, marker) {
+    const { queue: _previous, ...metadata } = (message.metadata ?? {});
+    return { ...message, metadata: marker ? { ...metadata, queue: marker } : metadata };
+}
+/** The answering run merged this turn into a later one; it never gets its own reply. */
+export function withMergedInto(message, mergedIntoRunId) {
+    return { ...message, metadata: { ...(message.metadata ?? {}), mergedIntoRunId } };
+}
+function messageCreatedAt(message, fallback) {
+    const raw = message.metadata?.createTime;
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return new Date(raw).toISOString();
+    if (typeof raw === 'string' && raw.trim())
+        return raw;
+    return fallback;
+}
+/** Next `order_index` after `parentId` (midpoint before its next sibling) or at the end. */
+export async function resolveNextOrderIndex(tx, input) {
+    const row = await tx.getOptional(`SELECT MAX(order_index) AS max_order_index, COUNT(*) AS message_count,
+       (SELECT order_index FROM c_chat_message
+         WHERE id = ? AND type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}
+         LIMIT 1) AS parent_order_index
+     FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}`, [
+        input.parentId ?? '',
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        MESSAGE_ENTRY_TYPE,
+        LEGACY_MESSAGE_ENTRY_TYPE,
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        MESSAGE_ENTRY_TYPE,
+        LEGACY_MESSAGE_ENTRY_TYPE,
+    ]);
+    const maxOrderIndex = toOrderIndex(row?.max_order_index);
+    const parentOrderIndex = toOrderIndex(row?.parent_order_index);
+    const countBased = Math.max(0, Number(row?.message_count ?? 0)) * ORDER_INDEX_STEP;
+    if (parentOrderIndex != null) {
+        const next = await tx.getOptional(`SELECT MIN(order_index) AS next_order_index FROM c_chat_message
+       WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND order_index > ? AND ${MESSAGE_ENTRY_FILTER}`, [THREAD_CHAT_TYPE, input.threadId, parentOrderIndex, MESSAGE_ENTRY_TYPE, LEGACY_MESSAGE_ENTRY_TYPE]);
+        const nextOrderIndex = toOrderIndex(next?.next_order_index);
+        if (nextOrderIndex != null && nextOrderIndex - parentOrderIndex > 1) {
+            return parentOrderIndex + Math.floor((nextOrderIndex - parentOrderIndex) / 2);
+        }
+    }
+    return Math.max(maxOrderIndex ?? 0, parentOrderIndex ?? 0, countBased) + ORDER_INDEX_STEP;
+}
+/**
+ * The thread's last message, by transcript order. A new turn is appended after
+ * it: what the client believed was last can be stale or out of order (another
+ * device, a lagging sync, a display glitch), and trusting it would splice the
+ * turn into the middle of the conversation.
+ */
+async function resolveThreadTail(tx, threadId) {
+    const row = await tx.getOptional(`SELECT id FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}
+     ORDER BY order_index DESC, created_at DESC, id DESC LIMIT 1`, [THREAD_CHAT_TYPE, threadId, MESSAGE_ENTRY_TYPE, LEGACY_MESSAGE_ENTRY_TYPE]);
+    return row?.id ?? null;
+}
+export async function threadExists(db, threadId, userId) {
+    const row = await db.getOptional('SELECT id FROM c_thread WHERE id = ? AND user_id = ? AND is_del = 0 LIMIT 1', [threadId, userId]);
+    return Boolean(row?.id);
+}
+/** Creates (or revives) the thread a remote run targets. Returns true when a row was written. */
+async function ensureThread(tx, input, now) {
+    const existing = await tx.getOptional('SELECT id, is_del FROM c_thread WHERE id = ? LIMIT 1', [input.id]);
+    if (existing?.id && Number(existing.is_del) !== 1)
+        return false;
+    const name = (input.name ?? '').trim().slice(0, 120) || 'Untitled';
+    const values = [
+        name,
+        input.kind || 'chat',
+        input.userId,
+        input.projectId ?? null,
+        now,
+        now,
+        safeJson(input.metaData ?? {}),
+        input.cmdId ?? null,
+        safeJson(input.config ?? {}),
+    ];
+    if (existing?.id) {
+        await tx.execute(`UPDATE c_thread SET name = ?, kind = ?, user_id = ?, project_id = ?, last_opened_at = ?, updated_at = ?,
+         meta_data = ?, cmd_id = ?, config = ?, filter_condition = '{}', snapshot = '{}', memory = '{}',
+         is_del = 0, robot_session_id = NULL, compact_context = NULL
+       WHERE id = ?`, [...values, input.id]);
+        return true;
+    }
+    await tx.execute(`INSERT INTO c_thread (id, name, kind, user_id, project_id, last_opened_at, updated_at, meta_data, cmd_id, config,
+       created_at, messages, pinned_at, filter_condition, snapshot, memory, is_del, robot_session_id, compact_context)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '[]', NULL, '{}', '{}', '{}', 0, NULL, NULL)`, [input.id, ...values, now]);
+    return true;
+}
+async function writeChatMessage(tx, input) {
+    const existing = await tx.getOptional('SELECT id, order_index FROM c_chat_message WHERE id = ? LIMIT 1', [input.message.id]);
+    const orderIndex = toOrderIndex(existing?.order_index) ??
+        (await resolveNextOrderIndex(tx, { threadId: input.threadId, parentId: input.parentId }));
+    if (existing?.id) {
+        await tx.execute(`UPDATE c_chat_message SET role = ?, type = ?, entry_type = ?, source_id = ?, parent_id = ?, content = ?,
+         updated_at = ?, order_index = ?, version = ?, user_id = ?, deleted_at = NULL
+       WHERE id = ?`, [
+            input.message.role,
+            THREAD_CHAT_TYPE,
+            MESSAGE_ENTRY_TYPE,
+            input.threadId,
+            input.parentId,
+            safeJson(input.message),
+            input.updatedAt,
+            orderIndex,
+            CHAT_MESSAGE_VERSION,
+            input.userId,
+            input.message.id,
+        ]);
+        return;
+    }
+    await tx.execute(`INSERT INTO c_chat_message (id, role, type, entry_type, source_id, parent_id, content, created_at, updated_at,
+       order_index, meta_data, version, user_id, deleted_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, NULL)`, [
+        input.message.id,
+        input.message.role,
+        THREAD_CHAT_TYPE,
+        MESSAGE_ENTRY_TYPE,
+        input.threadId,
+        input.parentId,
+        safeJson(input.message),
+        input.createdAt,
+        input.updatedAt,
+        orderIndex,
+        CHAT_MESSAGE_VERSION,
+        input.userId,
+    ]);
+}
+/** Persists the accepted turn atomically: thread (if new), user message, queued run. */
+export async function enqueueRun(db, input) {
+    const now = new Date().toISOString();
+    return withPowerSyncWriteTransaction(db, async (tx) => {
+        const threadCreated = input.createThread
+            ? await ensureThread(tx, { ...input.createThread, userId: input.userId }, now)
+            : false;
+        const createdAt = messageCreatedAt(input.userMessage, now);
+        const parentId = input.queuedAfterMessageId ?? (await resolveThreadTail(tx, input.threadId)) ?? input.parentMessageId;
+        const userMessage = input.queued
+            ? withQueueMarker(input.userMessage, { state: 'queued', runId: input.runId, executor: 'gateway', queuedAt: now })
+            : input.userMessage;
+        await writeChatMessage(tx, {
+            threadId: input.threadId,
+            userId: input.userId,
+            message: userMessage,
+            parentId,
+            createdAt,
+            updatedAt: createdAt,
+        });
+        await tx.execute(`INSERT INTO local_thread_run (id, thread_id, user_id, status, trigger, user_message_id, assistant_message_id,
+         parent_message_id, queued_at, permission_mode, request_payload_json, assistant_snapshot_json, queue_index,
+         created_at, updated_at)
+       VALUES (?, ?, ?, 'queued', 'submit-message', ?, ?, ?, ?, 'default', ?, ?, ?, ?, ?)`, [
+            input.runId,
+            input.threadId,
+            input.userId,
+            input.userMessage.id,
+            input.assistantMessage.id,
+            parentId,
+            now,
+            safeJson({ ...input.requestPayload, metadata: { remoteDevice: { requestId: input.requestId } } }),
+            safeJson(withRunMetadata(input.assistantMessage, input.runId, 'queued')),
+            input.queueIndex,
+            now,
+            now,
+        ]);
+        return { threadCreated };
+    });
+}
+/** Live progress for `run.status` recovery; never touches synced tables. */
+export async function updateRunSnapshot(db, input) {
+    const now = new Date().toISOString();
+    await db.execute(`UPDATE local_thread_run SET status = ?, assistant_snapshot_json = ?, updated_at = ?, last_heartbeat_at = ?,
+       started_at = COALESCE(started_at, ?)
+     WHERE id = ? AND status NOT IN ('succeeded', 'failed', 'cancelled', 'interrupted', 'expired')`, [input.status, safeJson(withRunMetadata(input.assistant, input.runId, input.status)), now, now, now, input.runId]);
+}
+/** Ends the run and writes the final assistant message into the synced transcript. */
+export async function commitRunTerminal(db, input) {
+    const finishedAt = new Date().toISOString();
+    const assistant = withRunMetadata(input.assistant, input.runId, input.status);
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        await writeChatMessage(tx, {
+            threadId: input.threadId,
+            userId: input.userId,
+            message: assistant,
+            parentId: input.userMessageId,
+            createdAt: messageCreatedAt(assistant, finishedAt),
+            updatedAt: finishedAt,
+        });
+        await tx.execute(`UPDATE local_thread_run SET status = ?, error_text = ?, finished_at = ?, updated_at = ?, expires_at = NULL,
+         cleanup_after_at = ?, assistant_snapshot_json = ?
+       WHERE id = ?`, [
+            input.status,
+            input.errorText,
+            finishedAt,
+            finishedAt,
+            new Date(Date.parse(finishedAt) + RUN_RETENTION_MS).toISOString(),
+            safeJson(assistant),
+            input.runId,
+        ]);
+    });
+}
+export async function findRun(db, input) {
+    const row = await db.getOptional(`SELECT id, thread_id, status, request_payload_json, assistant_snapshot_json, updated_at
+     FROM local_thread_run WHERE id = ? AND user_id = ? LIMIT 1`, [input.runId, input.userId]);
+    if (!row)
+        return null;
+    const payload = parseJson(row.request_payload_json);
+    const requestId = payload?.metadata?.remoteDevice?.requestId;
+    return {
+        id: row.id,
+        threadId: row.thread_id,
+        status: row.status,
+        requestId: typeof requestId === 'string' ? requestId : null,
+        assistant: parseJson(row.assistant_snapshot_json),
+        updatedAt: row.updated_at,
+    };
+}
+/** Rewrites a user message's queue marker in place; a missing message is ignored. */
+async function writeQueueMarker(tx, messageId, marker, extra = {}) {
+    const row = await tx.getOptional('SELECT content FROM c_chat_message WHERE id = ? LIMIT 1', [messageId]);
+    const message = parseJson(row?.content);
+    if (!message)
+        return;
+    const now = new Date().toISOString();
+    await tx.execute(`UPDATE c_chat_message SET content = ?, updated_at = ?${extra.deletedAt ? ', deleted_at = ?' : ''} WHERE id = ?`, extra.deletedAt
+        ? [safeJson(withQueueMarker(message, marker)), now, extra.deletedAt, messageId]
+        : [safeJson(withQueueMarker(message, marker)), now, messageId]);
+}
+/** The queued turns start now: their messages stop showing as queued. */
+export async function startQueuedRuns(db, userMessageIds) {
+    if (userMessageIds.length === 0)
+        return;
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        for (const messageId of userMessageIds)
+            await writeQueueMarker(tx, messageId, null);
+    });
+}
+/** Ends a queued turn that was merged into a later one: no reply of its own is written. */
+export async function finishMergedRun(db, input) {
+    const now = new Date().toISOString();
+    const assistant = withRunMetadata(withMergedInto(input.assistant, input.mergedIntoRunId), input.runId, 'succeeded');
+    await db.execute(`UPDATE local_thread_run SET status = 'succeeded', finished_at = ?, updated_at = ?, assistant_snapshot_json = ?,
+       cleanup_after_at = ?
+     WHERE id = ?`, [now, now, safeJson(assistant), new Date(Date.parse(now) + RUN_RETENTION_MS).toISOString(), input.runId]);
+    return assistant;
+}
+/**
+ * The user took a queued turn back before it ran: the run is cancelled and its
+ * message removed from the transcript (marked `withdrawn` so other devices can
+ * tell a withdrawal from a deletion).
+ */
+export async function withdrawQueuedRun(db, input) {
+    const now = new Date().toISOString();
+    const assistant = withRunMetadata(input.assistant, input.runId, 'cancelled');
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        await writeQueueMarker(tx, input.userMessageId, { state: 'withdrawn', runId: input.runId, executor: 'gateway', queuedAt: now }, { deletedAt: now });
+        await tx.execute(`UPDATE local_thread_run SET status = 'cancelled', finished_at = ?, updated_at = ?, assistant_snapshot_json = ?,
+         error_text = 'withdrawn by user', cleanup_after_at = ?
+       WHERE id = ?`, [now, now, safeJson(assistant), new Date(Date.parse(now) + RUN_RETENTION_MS).toISOString(), input.runId]);
+    });
+    return assistant;
+}
+/** Runs left non-terminal by a previous process can never finish; mark them interrupted. */
+export async function interruptOrphanedRuns(db, userId) {
+    const now = new Date().toISOString();
+    const rows = await db.getAll(`SELECT id, user_message_id FROM local_thread_run
+     WHERE user_id = ? AND status NOT IN ('succeeded', 'failed', 'cancelled', 'interrupted', 'expired')
+       AND request_payload_json LIKE '%"gatewayId"%'`, [userId]);
+    for (const row of rows) {
+        await db.execute(`UPDATE local_thread_run SET status = 'interrupted', error_text = ?, finished_at = ?, updated_at = ? WHERE id = ?`, ['gateway host restarted', now, now, row.id]);
+        // A turn that was still queued will never run: it must not show as queued forever.
+        if (row.user_message_id)
+            await writeQueueMarker(db, row.user_message_id, null);
+    }
+    return rows.length;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function toBinding(value, legacy = false) {
+    if (!isRecord(value) || typeof value.sessionId !== 'string' || !value.sessionId)
+        return null;
+    return {
+        sessionId: value.sessionId,
+        topicId: typeof value.topicId === 'string' ? value.topicId : null,
+        lastSeenMessageId: typeof value.lastSeenMessageId === 'string' ? value.lastSeenMessageId : null,
+        ...(typeof value.cwd === 'string' && value.cwd ? { cwd: value.cwd } : {}),
+        ...(legacy ? { legacy: true } : {}),
+    };
+}
+/** `c_thread.robot_session_id`: v2 keeps a binding per gateway; v1 held a single one. */
+function parseBindings(raw) {
+    const parsed = parseJson(raw);
+    const bindings = {};
+    if (parsed?.v === 1 && typeof parsed.gatewayId === 'string') {
+        const binding = toBinding(parsed, true);
+        if (binding)
+            bindings[parsed.gatewayId] = binding;
+    }
+    else if (parsed?.v === 2 && isRecord(parsed.sessions)) {
+        for (const [gatewayId, value] of Object.entries(parsed.sessions)) {
+            const binding = toBinding(value);
+            if (binding)
+                bindings[gatewayId] = binding;
+        }
+    }
+    return bindings;
+}
+async function readBindings(db, threadId) {
+    const row = await db.getOptional('SELECT robot_session_id FROM c_thread WHERE id = ? LIMIT 1', [threadId]);
+    return parseBindings(row?.robot_session_id);
+}
+export async function readSessionBinding(db, threadId, gatewayId) {
+    return (await readBindings(db, threadId))[gatewayId] ?? null;
+}
+/** Replaces this gateway's binding and keeps every other gateway's. */
+export async function writeSessionBinding(db, threadId, gatewayId, binding) {
+    const { legacy: _legacy, ...stored } = binding;
+    await withPowerSyncWriteTransaction(db, async (tx) => {
+        const sessions = { ...(await readBindings(tx, threadId)), [gatewayId]: stored };
+        await tx.execute('UPDATE c_thread SET robot_session_id = ?, updated_at = ? WHERE id = ?', [
+            safeJson({ v: 2, sessions }),
+            new Date().toISOString(),
+            threadId,
+        ]);
+    });
+}
+/** Directories this gateway's sessions worked in, most recently used first. */
+export async function readRecentSessionFolders(db, gatewayId, limit = 8) {
+    const rows = await db.getAll(`SELECT robot_session_id FROM c_thread
+     WHERE robot_session_id LIKE ? AND (is_del IS NULL OR is_del = 0)
+     ORDER BY updated_at DESC LIMIT 200`, [`%${gatewayId}%`]);
+    const folders = [];
+    for (const row of rows) {
+        const cwd = parseBindings(row.robot_session_id)[gatewayId]?.cwd;
+        if (cwd && !folders.includes(cwd))
+            folders.push(cwd);
+        if (folders.length >= limit)
+            break;
+    }
+    return folders;
+}
+/** The instructions the user wrote for the thread's agent (`c_project.agent_md`); empty when none. */
+export async function readAgentInstructions(db, threadId) {
+    const row = await db.getOptional(`SELECT p.agent_md FROM c_thread t JOIN c_project p ON p.id = t.project_id
+     WHERE t.id = ? AND (p.is_del IS NULL OR p.is_del = 0) LIMIT 1`, [threadId]);
+    return row?.agent_md?.trim() ?? '';
+}
+/**
+ * The thread's current topic: the latest "new topic" marker the app wrote
+ * (`entry_type = 'internal'`, `meta_data.kind = 'context_reset'`). A new topic
+ * starts a fresh agent session; like the app, it covers rows written after the marker.
+ */
+export async function readCurrentTopic(db, threadId) {
+    // Other markers (e.g. agent switches) share the entry type, so filter by kind in SQL.
+    const row = await db.getOptional(`SELECT id, created_at FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND entry_type = ? AND deleted_at IS NULL
+       AND json_extract(meta_data, '$.kind') = 'context_reset'
+     ORDER BY julianday(created_at) DESC, id DESC LIMIT 1`, [THREAD_CHAT_TYPE, threadId, CONTEXT_RESET_ENTRY_TYPE]);
+    return row ? { id: row.id, createdAt: row.created_at } : null;
+}
+/** Marks a reply with the agent session that wrote it (`metadata.gateway`). */
+export function withGatewaySession(message, gateway) {
+    return {
+        ...message,
+        metadata: { ...(message.metadata ?? {}), gateway: { id: gateway.gatewayId, sessionId: gateway.sessionId } },
+    };
+}
+const TAIL_POLL_INTERVAL_MS = 250;
+/**
+ * Waits until a message exists in the local replica (deleted or not), e.g. the
+ * last message the client saw before sending a turn. False when it has not
+ * synced within the timeout or the wait was aborted.
+ */
+export async function waitForMessage(db, messageId, options) {
+    const deadline = Date.now() + options.timeoutMs;
+    for (;;) {
+        const row = await db.getOptional('SELECT id FROM c_chat_message WHERE id = ? LIMIT 1', [messageId]);
+        if (row)
+            return true;
+        if (options.signal?.aborted || Date.now() >= deadline)
+            return false;
+        await new Promise((resolve) => setTimeout(resolve, TAIL_POLL_INTERVAL_MS));
+    }
+}
+function messageText(message) {
+    const lines = [];
+    for (const part of message?.parts ?? []) {
+        if (part.type === 'text' && typeof part.text === 'string' && part.text.trim())
+            lines.push(part.text.trim());
+        if (part.type === 'file') {
+            const name = part.filename;
+            lines.push(`[attachment: ${typeof name === 'string' && name ? name : String(part.mediaType ?? 'file')}]`);
+        }
+    }
+    return lines.join('\n\n');
+}
+/**
+ * The newest transcript messages in a window, oldest first, with how many
+ * matching messages lie before the page. Bounds are exclusive: `since` is a
+ * topic start (by `created_at`, as the app scopes topics), `afterMessageId` and
+ * `beforeMessageId` are transcript positions; an id that no longer exists is no bound.
+ */
+export async function readTranscriptPage(db, input) {
+    const since = input.since ?? null;
+    const after = input.afterMessageId ?? null;
+    const before = input.beforeMessageId ?? null;
+    const ownSession = input.excludeSessionId ?? null;
+    const where = `type = ? AND source_id = ? AND deleted_at IS NULL AND ${MESSAGE_ENTRY_FILTER}
+     AND role IN ('user', 'assistant')
+     AND (? IS NULL OR julianday(created_at) > julianday(?))
+     AND order_index > COALESCE((SELECT order_index FROM c_chat_message WHERE id = ?), order_index - 1)
+     AND order_index < COALESCE((SELECT order_index FROM c_chat_message WHERE id = ?), order_index + 1)
+     AND (? IS NULL OR NOT (
+       COALESCE(json_extract(content, '$.metadata.gateway.sessionId'), '') = ?
+       OR id IN (SELECT parent_id FROM c_chat_message
+                 WHERE type = ? AND source_id = ? AND parent_id IS NOT NULL
+                   AND json_extract(content, '$.metadata.gateway.sessionId') = ?)
+     ))`;
+    const params = [
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        MESSAGE_ENTRY_TYPE,
+        LEGACY_MESSAGE_ENTRY_TYPE,
+        since,
+        since,
+        after,
+        before,
+        ownSession,
+        ownSession,
+        THREAD_CHAT_TYPE,
+        input.threadId,
+        ownSession,
+    ];
+    const [rows, total] = await Promise.all([
+        db.getAll(`SELECT id, role, content, responser_id, created_at FROM c_chat_message WHERE ${where}
+       ORDER BY order_index DESC, created_at DESC, id DESC LIMIT ?`, [...params, input.limit]),
+        db.getOptional(`SELECT COUNT(*) AS count FROM c_chat_message WHERE ${where}`, params),
+    ]);
+    const parsed = rows.reverse().map((row) => {
+        const message = parseJson(row.content);
+        const responserId = message?.metadata?.responserId;
+        return {
+            row,
+            responserId: row.role === 'assistant' ? (typeof responserId === 'string' && responserId) || row.responser_id || null : null,
+            text: messageText(message),
+        };
+    });
+    const names = await readAgentNames(db, parsed.map((item) => item.responserId).filter((id) => Boolean(id)));
+    return {
+        messages: parsed
+            .filter((item) => item.text)
+            .map(({ row, responserId, text }) => ({
+            id: row.id,
+            role: row.role,
+            speaker: responserId ? (names.get(responserId) ?? null) : null,
+            text,
+            createdAt: row.created_at,
+        })),
+        earlier: Math.max(0, Number(total?.count ?? 0) - rows.length),
+    };
+}
+/** Agent (`c_project`) display names by id; unnamed agents are left out. */
+async function readAgentNames(db, ids) {
+    const unique = [...new Set(ids)];
+    if (unique.length === 0)
+        return new Map();
+    const rows = await db.getAll(`SELECT id, name FROM c_project WHERE id IN (${unique.map(() => '?').join(', ')})`, unique);
+    return new Map(rows.filter((row) => row.name?.trim()).map((row) => [row.id, row.name.trim()]));
+}
+/** File parts resolve only to resources this user owns with an https storage URL. */
+export async function resolveTrustedResource(db, input) {
+    const row = await db.getOptional(`SELECT storage_url, name, mime_type FROM c_resource
+     WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0) AND deleted_at IS NULL LIMIT 1`, [input.resourceId, input.userId]);
+    if (!row?.storage_url?.startsWith('https://'))
+        return null;
+    return { url: row.storage_url, name: row.name ?? 'attachment', mediaType: row.mime_type };
+}
+function robotMetaData(input) {
+    return JSON.stringify({
+        gateway: {
+            machineId: input.machineId,
+            ...(input.agentId ? { agentId: input.agentId } : {}),
+            ...(input.settings ? { settings: input.settings } : {}),
+        },
+    });
+}
+export async function upsertRobot(db, input) {
+    const now = new Date().toISOString();
+    // The backend rejects NULL c_robot columns, and PowerSync omits NULLs only from inserts.
+    const cwd = input.cwd ?? '';
+    const metaData = robotMetaData(input);
+    const existing = await db.getOptional('SELECT name, device_id, device_name, agent_type, cwd, meta_data, is_del FROM c_robot WHERE id = ? LIMIT 1', [
+        input.id,
+    ]);
+    if (existing) {
+        const unchanged = existing.name === input.name
+            && existing.device_id === input.deviceId
+            && existing.device_name === input.deviceName
+            && existing.agent_type === input.agentType
+            && (existing.cwd ?? '') === cwd
+            && sameJson(existing.meta_data, metaData)
+            && !existing.is_del;
+        // Every daemon start re-registers; skip no-op writes so they do not queue uploads.
+        if (unchanged)
+            return;
+        // A removed gateway that is added again revives its robot (ids are deterministic).
+        await db.execute(`UPDATE c_robot SET name = ?, device_id = ?, device_name = ?, agent_type = ?, cwd = ?, meta_data = ?,
+         updated_at = ?, is_del = 0
+       WHERE id = ?`, [input.name, input.deviceId, input.deviceName, input.agentType, cwd, metaData, now, input.id]);
+        return;
+    }
+    await db.execute(`INSERT INTO c_robot (id, name, device_id, device_name, agent_type, cwd, config, meta_data, created_at, updated_at,
+       user_id, is_del)
+     VALUES (?, ?, ?, ?, ?, ?, '{}', ?, ?, ?, ?, 0)`, [input.id, input.name, input.deviceId, input.deviceName, input.agentType, cwd, metaData, now, now, input.userId]);
+}
+/**
+ * Soft-deletes this machine's gateway robots that are no longer configured
+ * (removed, or replaced before ids were deterministic), so the app never
+ * offers an agent that nothing hosts. Robots from other machines are untouched.
+ */
+export async function retireRemovedRobots(db, input) {
+    const rows = await db.getAll(`SELECT id, meta_data FROM c_robot WHERE user_id = ? AND COALESCE(is_del, 0) = 0`, [input.userId]);
+    const keep = new Set(input.keepIds);
+    const retired = rows
+        .filter((row) => !keep.has(row.id) && robotMachineId(row.meta_data) === input.machineId)
+        .map((row) => row.id);
+    for (const id of retired)
+        await softDeleteRobot(db, id);
+    return retired;
+}
+/** The backend re-serializes JSON columns, so compare them parsed. */
+function sameJson(stored, expected) {
+    try {
+        return JSON.stringify(JSON.parse(stored ?? '')) === expected;
+    }
+    catch {
+        return false;
+    }
+}
+function robotMachineId(metaData) {
+    try {
+        const parsed = JSON.parse(metaData ?? '');
+        return typeof parsed?.gateway?.machineId === 'string' ? parsed.gateway.machineId : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function softDeleteRobot(db, robotId) {
+    await db.execute('UPDATE c_robot SET is_del = 1, updated_at = ? WHERE id = ?', [new Date().toISOString(), robotId]);
+}