@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/gateway/threadStore.js

@@ -0,0 +1,430 @@
+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;
+}
+export async function readSessionBinding(db, threadId) {
+    const row = await db.getOptional('SELECT robot_session_id FROM c_thread WHERE id = ? LIMIT 1', [threadId]);
+    const parsed = parseJson(row?.robot_session_id);
+    if (parsed?.v !== 1 || typeof parsed.sessionId !== 'string' || typeof parsed.gatewayId !== 'string')
+        return null;
+    return {
+        sessionId: parsed.sessionId,
+        topicId: typeof parsed.topicId === 'string' ? parsed.topicId : null,
+        gatewayId: parsed.gatewayId,
+    };
+}
+export async function writeSessionBinding(db, threadId, binding) {
+    await db.execute('UPDATE c_thread SET robot_session_id = ?, updated_at = ? WHERE id = ?', [
+        safeJson({ v: 1, ...binding }),
+        new Date().toISOString(),
+        threadId,
+    ]);
+}
+/**
+ * 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.
+ */
+export async function readCurrentTopicId(db, threadId) {
+    const rows = await db.getAll(`SELECT id, meta_data FROM c_chat_message
+     WHERE type = ? AND source_id = ? AND entry_type = ? AND deleted_at IS NULL
+     ORDER BY julianday(created_at) DESC, id DESC LIMIT 20`, [THREAD_CHAT_TYPE, threadId, CONTEXT_RESET_ENTRY_TYPE]);
+    for (const row of rows) {
+        if (parseJson(row.meta_data)?.kind === 'context_reset')
+            return row.id;
+    }
+    return null;
+}
+/** 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 } : {}) } });
+}
+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]);
+}

package/dist/gateway/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Dinox agent gateway: hosts external agent runtimes (Hermes, OpenClaw, pi,
+ * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
+ *
+ * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
+ * owns its conversation context (gateway-session mode): each turn sends only
+ * the new user message, while Dinox keeps a display/sync copy of the transcript.
+ */
+export type GatewayKind = 'acp' | 'echo';
+/** Local-only gateway definition (never synced: it may carry commands and env). */
+export type GatewayDefinition = {
+    /** Stable id; also the `c_robot.id` the app binds agents to. */
+    id: string;
+    name: string;
+    kind: GatewayKind;
+    /** Detected agent type (`cursor`, `opencode`, ...); one gateway per type per machine. */
+    agentId?: string;
+    /** NATS device id the app addresses (`[a-z0-9][a-z0-9_-]{0,63}`). */
+    deviceId: string;
+    /** ACP: executable started over stdio, e.g. `hermes` with args `["acp"]`. */
+    command?: string;
+    args?: string[];
+    /** Working directory handed to the agent's sessions. */
+    cwd?: string;
+    /** Extra environment for the agent process (secrets stay on this machine). */
+    env?: Record<string, string>;
+    enabled: boolean;
+    /** Offer the read-only Dinox knowledge tools (MCP) to the agent; default true. */
+    dinoxTools?: boolean;
+    createdAt: string;
+};
+export type GatewayToolStatus = 'pending' | 'running' | 'completed' | 'failed';
+/** Normalized agent output, independent of the adapter protocol. */
+export type GatewayEvent = {
+    type: 'text-delta';
+    text: string;
+} | {
+    type: 'reasoning-delta';
+    text: string;
+} | {
+    type: 'tool';
+    toolCallId: string;
+    title?: string;
+    status?: GatewayToolStatus;
+    input?: unknown;
+    output?: unknown;
+} | {
+    type: 'approval-request';
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+} | {
+    type: 'approval-resolved';
+    approvalId: string;
+    approved: boolean;
+} | {
+    type: 'usage';
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+};
+/**
+ * A choice the agent exposes per session (an ACP select config option), e.g.
+ * its model or mode. Values are the agent's own ids; `group` is set when the
+ * agent groups its values (OpenCode groups models by provider).
+ */
+export type GatewayConfigOption = {
+    id: string;
+    name: string;
+    /** ACP semantic category: `model`, `mode`, `thought_level`, ... (UX only). */
+    category: string | null;
+    description: string | null;
+    currentValue: string;
+    values: Array<{
+        value: string;
+        name: string;
+        description: string | null;
+        group: string | null;
+    }>;
+};
+export type GatewayStopReason = 'end_turn' | 'cancelled' | 'max_tokens' | 'refusal' | 'error';
+export type GatewayTurnInput = {
+    /** Agent session to continue; absent starts a new one. */
+    sessionId: string | null;
+    prompt: string;
+    /** Attachments the user sent with this turn (trusted, https). */
+    resources: Array<{
+        uri: string;
+        name: string;
+        mediaType?: string | null;
+    }>;
+    signal: AbortSignal;
+    /** Option id → value to apply to the session before the prompt; unknown entries are skipped. */
+    config?: Readonly<Record<string, string>>;
+    onEvent: (event: GatewayEvent) => void;
+    /** Resolves with the user's decision for an `approval-request` event. */
+    awaitApproval: (approvalId: string) => Promise<boolean>;
+};
+export type GatewayTurnResult = {
+    sessionId: string;
+    stopReason: GatewayStopReason;
+    error?: string;
+};
+export type GatewayAdapterInfo = {
+    kind: GatewayKind;
+    agentName: string | null;
+    agentVersion: string | null;
+};
+/** One agent runtime. Implementations keep their own process/connection state. */
+export interface GatewayAdapter {
+    readonly kind: GatewayKind;
+    info(): GatewayAdapterInfo;
+    runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
+    /** The agent's session settings (models, modes); absent when it has none. */
+    describeConfig?(): Promise<GatewayConfigOption[]>;
+    dispose(): Promise<void>;
+}

package/dist/gateway/types.js

@@ -0,0 +1,9 @@
+/**
+ * Dinox agent gateway: hosts external agent runtimes (Hermes, OpenClaw, pi,
+ * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
+ *
+ * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
+ * owns its conversation context (gateway-session mode): each turn sends only
+ * the new user message, while Dinox keeps a display/sync copy of the transcript.
+ */
+export {};

package/dist/skills/registry.js

@@ -18,6 +18,13 @@ const REGISTRY_ENTRIES = [
         name: 'dino-manage-boxes',
         generated: [commands('SKILL.md', 'skill:dino-manage-boxes')],
     },
+    {
+        name: 'dino-manage-properties',
+        generated: [
+            commands('SKILL.md', 'skill:dino-manage-properties'),
+            commands('references/templates.md', 'skill:dino-manage-properties:templates'),
+        ],
+    },
     {
         name: 'dino-manage-prompts',
         generated: [commands('SKILL.md', 'skill:dino-manage-prompts')],