@cloudcli-ai/cloudcli 1.37.2 → 1.37.3

package/server/modules/browser-use/browser-use.routes.ts

@@ -1,9 +1,45 @@
 import express from 'express';
+import type { Response } from 'express';
 
 import { browserUseService } from '@/modules/browser-use/browser-use.service.js';
 
 const router = express.Router();
 
+/**
+ * Stable machine-readable error codes for the browser-use API.
+ *
+ * The server always replies with the structured envelope used by AppError
+ * (`{ success: false, error: { code, message, details } }`). Clients map
+ * `code` to localized copy; `message` is an English fallback and `details`
+ * may carry the underlying error text for diagnostics.
+ */
+export const BROWSER_USE_ERROR_CODES = {
+  STATUS_LOAD_FAILED: 'BROWSER_USE_STATUS_LOAD_FAILED',
+  SETTINGS_LOAD_FAILED: 'BROWSER_USE_SETTINGS_LOAD_FAILED',
+  SETTINGS_SAVE_FAILED: 'BROWSER_USE_SETTINGS_SAVE_FAILED',
+  RUNTIME_INSTALL_FAILED: 'BROWSER_USE_RUNTIME_INSTALL_FAILED',
+  SESSIONS_LOAD_FAILED: 'BROWSER_USE_SESSIONS_LOAD_FAILED',
+  SESSION_STOP_FAILED: 'BROWSER_USE_SESSION_STOP_FAILED',
+  SESSION_DELETE_FAILED: 'BROWSER_USE_SESSION_DELETE_FAILED',
+} as const;
+
+function sendError(
+  res: Response,
+  statusCode: number,
+  code: string,
+  message: string,
+  details?: unknown,
+): void {
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      code,
+      message,
+      details,
+    },
+  });
+}
+
 function readParam(value: string | string[] | undefined): string {
   return Array.isArray(value) ? value[0] || '' : value || '';
 }
@@ -12,10 +48,13 @@ router.get('/status', async (_req, res) => {
   try {
     res.json({ success: true, data: await browserUseService.getStatus() });
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to load Browser status.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.STATUS_LOAD_FAILED,
+      'Failed to load Browser status.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -23,10 +62,13 @@ router.get('/settings', async (_req, res) => {
   try {
     res.json({ success: true, data: { settings: await browserUseService.getSettings() } });
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to load Browser settings.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.SETTINGS_LOAD_FAILED,
+      'Failed to load Browser settings.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -35,26 +77,38 @@ router.put('/settings', async (req, res) => {
     const settings = await browserUseService.updateSettings(req.body || {});
     res.json({ success: true, data: { settings } });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to save Browser settings.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SETTINGS_SAVE_FAILED,
+      'Failed to save Browser settings.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
 router.post('/runtime/install', async (_req, res) => {
   try {
     const result = await browserUseService.installRuntime();
-    res.status(result.success ? 200 : 500).json({
-      success: result.success,
-      data: result,
-      error: result.success ? undefined : result.message,
-    });
+    if (result.success) {
+      res.json({ success: true, data: result });
+      return;
+    }
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.RUNTIME_INSTALL_FAILED,
+      'Failed to install Browser runtime.',
+      result.message,
+    );
   } catch (error) {
-    res.status(500).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to install Browser runtime.',
-    });
+    sendError(
+      res,
+      500,
+      BROWSER_USE_ERROR_CODES.RUNTIME_INSTALL_FAILED,
+      'Failed to install Browser runtime.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -62,10 +116,13 @@ router.get('/sessions', async (_req, res) => {
   try {
     res.json({ success: true, data: { sessions: await browserUseService.listSessions() } });
   } catch (error) {
-    res.status(401).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to list browser sessions.',
-    });
+    sendError(
+      res,
+      401,
+      BROWSER_USE_ERROR_CODES.SESSIONS_LOAD_FAILED,
+      'Failed to list browser sessions.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -74,10 +131,13 @@ router.post('/sessions/:sessionId/stop', async (req, res) => {
     const result = await browserUseService.stopSession(readParam(req.params.sessionId));
     res.json({ success: true, data: result });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to stop browser session.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SESSION_STOP_FAILED,
+      'Failed to stop browser session.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 
@@ -86,10 +146,13 @@ router.delete('/sessions/:sessionId', async (req, res) => {
     const result = await browserUseService.deleteSession(readParam(req.params.sessionId));
     res.json({ success: true, data: result });
   } catch (error) {
-    res.status(400).json({
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to delete browser session.',
-    });
+    sendError(
+      res,
+      400,
+      BROWSER_USE_ERROR_CODES.SESSION_DELETE_FAILED,
+      'Failed to delete browser session.',
+      error instanceof Error ? error.message : undefined,
+    );
   }
 });
 

package/server/modules/database/connection.ts

@@ -10,11 +10,12 @@
  * `getConnection()` to obtain the shared singleton.
  */
 
-import Database from 'better-sqlite3';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
+import Database from 'better-sqlite3';
+
 import { APP_CONFIG_TABLE_SCHEMA_SQL } from '@/modules/database/schema.js';
 
 const __filename = fileURLToPath(import.meta.url);

package/server/modules/database/index.ts

@@ -12,6 +12,16 @@ export { providerModelsDb } from '@/modules/database/repositories/provider-model
 export { projectsDb } from '@/modules/database/repositories/projects.db.js';
 export { pushSubscriptionsDb } from '@/modules/database/repositories/push-subscriptions.js';
 export { scanStateDb } from '@/modules/database/repositories/scan-state.db.js';
+// sessionDraftsDb: used by User for drafts and Scheduled Messages for server-owned queued turns.
+export { sessionDraftsDb } from '@/modules/database/repositories/session-drafts.db.js';
+export type {
+  QueuedSessionMessageRecord,
+  SessionDraftRecord,
+} from '@/modules/database/repositories/session-drafts.db.js';
 export { sessionsDb } from '@/modules/database/repositories/sessions.db.js';
 export { userDb } from '@/modules/database/repositories/users.js';
+// userPreferencesDb: used by the User module to persist the settings that used to live in browser localStorage.
+export { userPreferencesDb } from '@/modules/database/repositories/user-preferences.db.js';
 export { vapidKeysDb } from '@/modules/database/repositories/vapid-keys.js';
+export { scheduledMessagesDb } from './repositories/scheduled-messages.db.js';
+export type { ScheduledMessageRow, ScheduledMessageStatus } from './repositories/scheduled-messages.db.js';

package/server/modules/database/migrations.ts

@@ -7,7 +7,11 @@ import {
   PROJECTS_TABLE_SCHEMA_SQL,
   PROVIDER_MODELS_TABLE_SCHEMA_SQL,
   PUSH_SUBSCRIPTIONS_TABLE_SCHEMA_SQL,
+  SESSION_DRAFTS_TABLE_SCHEMA_SQL,
+  SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL,
+  SCHEDULED_MESSAGES_TABLE_SCHEMA_SQL,
   SESSIONS_TABLE_SCHEMA_SQL,
+  USER_PREFERENCES_TABLE_SCHEMA_SQL,
   USER_NOTIFICATION_PREFERENCES_TABLE_SCHEMA_SQL,
   VAPID_KEYS_TABLE_SCHEMA_SQL,
 } from '@/modules/database/schema.js';
@@ -403,6 +407,29 @@ const addProviderSessionIdMapping = (db: Database): void => {
   `);
 };
 
+/**
+ * Adds the `forked_from_session_id` column recording where a branched session
+ * came from.
+ *
+ * Nothing is backfilled: a session that predates forking was not forked.
+ */
+/**
+ * Adds the transcript path to the superseded-session record.
+ *
+ * Only rows written before this column existed lack it, and there is nothing
+ * to backfill from — the session stopped pointing at that file when the row
+ * was created — so they keep a NULL and the delete path skips them.
+ */
+const addSupersededTranscriptPathColumn = (db: Database): void => {
+  const columnNames = getTableInfo(db, 'superseded_provider_sessions').map((column) => column.name);
+  addColumnToTableIfNotExists(db, 'superseded_provider_sessions', columnNames, 'jsonl_path', 'TEXT');
+};
+
+const addForkedFromSessionIdColumn = (db: Database): void => {
+  const columnNames = getTableInfo(db, 'sessions').map((column) => column.name);
+  addColumnToTableIfNotExists(db, 'sessions', columnNames, 'forked_from_session_id', 'TEXT');
+};
+
 /**
  * Adds the `model` column that records which model each session runs with.
  *
@@ -477,6 +504,10 @@ export const runMigrations = (db: Database) => {
       CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
       ON provider_models(provider, sort_order, id)
     `);
+    db.exec(USER_PREFERENCES_TABLE_SCHEMA_SQL);
+    db.exec(SESSION_DRAFTS_TABLE_SCHEMA_SQL);
+    db.exec(SUPERSEDED_PROVIDER_SESSIONS_TABLE_SCHEMA_SQL);
+    addSupersededTranscriptPathColumn(db);
 
     db.exec(PROJECTS_TABLE_SCHEMA_SQL);
     rebuildProjectsTableWithPrimaryKeySchema(db);
@@ -487,11 +518,17 @@ export const runMigrations = (db: Database) => {
     addProviderSessionIdMapping(db);
     addSessionModelColumn(db);
     addSessionEffortColumn(db);
+    addForkedFromSessionIdColumn(db);
     ensureProjectsForSessionPaths(db);
+    db.exec(SCHEDULED_MESSAGES_TABLE_SCHEMA_SQL);
 
     db.exec('CREATE INDEX IF NOT EXISTS idx_session_ids_lookup ON sessions(session_id)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_provider_session_id ON sessions(provider_session_id)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_project_path ON sessions(project_path)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_forked_from ON sessions(forked_from_session_id)');
+    // The due-message poll runs on a timer; without this it table-scans.
+    db.exec('CREATE INDEX IF NOT EXISTS idx_scheduled_messages_due ON scheduled_messages(status, scheduled_for)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_scheduled_messages_session ON scheduled_messages(session_id)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_is_archived ON sessions(isArchived)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_projects_is_starred ON projects(isStarred)');
     db.exec('CREATE INDEX IF NOT EXISTS idx_projects_is_archived ON projects(isArchived)');

package/server/modules/database/repositories/scheduled-messages.db.ts

@@ -0,0 +1,127 @@
+import { randomUUID } from 'node:crypto';
+
+import { getConnection } from '@/modules/database/connection.js';
+
+export type ScheduledMessageStatus = 'pending' | 'sent' | 'failed' | 'cancelled';
+
+export type ScheduledMessageRow = {
+  id: string;
+  user_id: number;
+  session_id: string;
+  content: string;
+  options: string;
+  scheduled_for: string;
+  status: ScheduledMessageStatus;
+  failure_reason: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+const COLUMNS =
+  'id, user_id, session_id, content, options, scheduled_for, status, failure_reason, created_at, updated_at';
+
+export const scheduledMessagesDb = {
+  create(input: {
+    userId: number;
+    sessionId: string;
+    content: string;
+    options: unknown;
+    scheduledFor: Date;
+  }): ScheduledMessageRow {
+    const db = getConnection();
+    const id = randomUUID();
+
+    db.prepare(
+      `INSERT INTO scheduled_messages (id, user_id, session_id, content, options, scheduled_for, status)
+       VALUES (?, ?, ?, ?, ?, ?, 'pending')`
+    ).run(
+      id,
+      input.userId,
+      input.sessionId,
+      input.content,
+      JSON.stringify(input.options ?? {}),
+      input.scheduledFor.toISOString(),
+    );
+
+    return db.prepare(`SELECT ${COLUMNS} FROM scheduled_messages WHERE id = ?`).get(id) as ScheduledMessageRow;
+  },
+
+  /** Everything still to come or recently resolved, newest schedule first. */
+  listForSession(userId: number, sessionId: string): ScheduledMessageRow[] {
+    return getConnection()
+      .prepare(
+        `SELECT ${COLUMNS} FROM scheduled_messages
+         WHERE user_id = ? AND session_id = ?
+         ORDER BY scheduled_for ASC`
+      )
+      .all(userId, sessionId) as ScheduledMessageRow[];
+  },
+
+  listPendingForUser(userId: number): ScheduledMessageRow[] {
+    return getConnection()
+      .prepare(
+        `SELECT ${COLUMNS} FROM scheduled_messages
+         WHERE user_id = ? AND status = 'pending'
+         ORDER BY scheduled_for ASC`
+      )
+      .all(userId) as ScheduledMessageRow[];
+  },
+
+  /**
+   * Claims every message whose time has passed, marking them in the same
+   * statement that selects them.
+   *
+   * Claiming is what makes a missed schedule work: the server can be down at
+   * the moment a message was due, and the next poll after it starts picks the
+   * message up instead of skipping it. Doing it in one transaction is what
+   * stops two overlapping polls from sending the same message twice.
+   */
+  claimDue(now: Date): ScheduledMessageRow[] {
+    const db = getConnection();
+    const nowIso = now.toISOString();
+
+    return db.transaction(() => {
+      const due = db
+        .prepare(
+          `SELECT ${COLUMNS} FROM scheduled_messages
+           WHERE status = 'pending' AND scheduled_for <= ?
+           ORDER BY scheduled_for ASC`
+        )
+        .all(nowIso) as ScheduledMessageRow[];
+
+      for (const row of due) {
+        db.prepare(
+          `UPDATE scheduled_messages SET status = 'sent', updated_at = CURRENT_TIMESTAMP WHERE id = ?`
+        ).run(row.id);
+      }
+
+      return due;
+    })();
+  },
+
+  markFailed(id: string, reason: string): void {
+    getConnection()
+      .prepare(
+        `UPDATE scheduled_messages
+         SET status = 'failed', failure_reason = ?, updated_at = CURRENT_TIMESTAMP
+         WHERE id = ?`
+      )
+      .run(reason.slice(0, 500), id);
+  },
+
+  /**
+   * Cancels a pending message, or dismisses a failed one so its banner goes
+   * away. Returns false when it had already fired successfully.
+   */
+  cancel(userId: number, id: string): boolean {
+    const result = getConnection()
+      .prepare(
+        `UPDATE scheduled_messages
+         SET status = 'cancelled', updated_at = CURRENT_TIMESTAMP
+         WHERE id = ? AND user_id = ? AND status IN ('pending', 'failed')`
+      )
+      .run(id, userId);
+
+    return result.changes > 0;
+  },
+};

package/server/modules/database/repositories/session-drafts.db.ts

@@ -0,0 +1,171 @@
+import { getConnection } from '@/modules/database/connection.js';
+
+/**
+ * One chat scope's unsent state: the text still in the composer, plus the
+ * message queued behind an in-flight turn. Both are optional — a scope can
+ * hold only a draft, only a queued message, or both.
+ */
+export type SessionDraftRecord = {
+  scope: string;
+  text: string;
+  queuedMessage: unknown | null;
+  updatedAt: string;
+};
+
+type DraftRow = {
+  draft_scope: string;
+  draft_text: string;
+  queued_message: string | null;
+  updated_at: string;
+};
+
+/** A server-owned queued turn together with the exact stored value used to claim it once. */
+export type QueuedSessionMessageRecord = {
+  userId: number;
+  sessionId: string;
+  queuedMessage: unknown;
+  claimToken: string;
+};
+
+type QueuedMessageRow = {
+  user_id: number;
+  draft_scope: string;
+  queued_message: string;
+};
+
+/** A queued message that no longer parses is treated as absent, not fatal. */
+function parseQueuedMessage(raw: string | null): unknown | null {
+  if (!raw) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(raw) as unknown;
+  } catch {
+    return null;
+  }
+}
+
+function toRecord(row: DraftRow): SessionDraftRecord {
+  return {
+    scope: row.draft_scope,
+    text: row.draft_text,
+    queuedMessage: parseQueuedMessage(row.queued_message),
+    updatedAt: row.updated_at,
+  };
+}
+
+export const sessionDraftsDb = {
+  /**
+   * Returns every draft the user has, newest first.
+   *
+   * The client pulls the whole set once per load: drafts are short strings, and
+   * having them all up front means switching sessions restores a draft written
+   * on another device without a round trip.
+   */
+  getDrafts(userId: number): SessionDraftRecord[] {
+    const db = getConnection();
+    const rows = db
+      .prepare(
+        `SELECT draft_scope, draft_text, queued_message, updated_at
+         FROM session_drafts
+         WHERE user_id = ?
+         ORDER BY datetime(updated_at) DESC`
+      )
+      .all(userId) as DraftRow[];
+
+    return rows.map(toRecord);
+  },
+
+  /** Lists persisted queued turns whose scopes are real chat sessions. */
+  listQueuedMessages(): QueuedSessionMessageRecord[] {
+    const rows = getConnection()
+      .prepare(
+        `SELECT drafts.user_id, drafts.draft_scope, drafts.queued_message
+         FROM session_drafts AS drafts
+         INNER JOIN sessions ON sessions.session_id = drafts.draft_scope
+         WHERE drafts.queued_message IS NOT NULL`
+      )
+      .all() as QueuedMessageRow[];
+
+    return rows.map((row) => ({
+      userId: row.user_id,
+      sessionId: row.draft_scope,
+      queuedMessage: parseQueuedMessage(row.queued_message),
+      claimToken: row.queued_message,
+    }));
+  },
+
+  /** Atomically removes a queued turn only if it has not been edited since listing. */
+  claimQueuedMessage(candidate: QueuedSessionMessageRecord): boolean {
+    const result = getConnection()
+      .prepare(
+        `UPDATE session_drafts
+         SET queued_message = NULL, updated_at = CURRENT_TIMESTAMP
+         WHERE user_id = ? AND draft_scope = ? AND queued_message = ?`
+      )
+      .run(candidate.userId, candidate.sessionId, candidate.claimToken);
+    return result.changes > 0;
+  },
+
+  /** Restores a claim lost to the narrow race where another run starts first. */
+  restoreQueuedMessage(candidate: QueuedSessionMessageRecord): void {
+    getConnection()
+      .prepare(
+        `UPDATE session_drafts
+         SET queued_message = ?, updated_at = CURRENT_TIMESTAMP
+         WHERE user_id = ? AND draft_scope = ? AND queued_message IS NULL`
+      )
+      .run(candidate.claimToken, candidate.userId, candidate.sessionId);
+  },
+
+  /** Removes the placeholder row left after its last queued turn is claimed. */
+  deleteEmptyDraft(userId: number, scope: string): void {
+    getConnection()
+      .prepare(
+        `DELETE FROM session_drafts
+         WHERE user_id = ? AND draft_scope = ? AND draft_text = '' AND queued_message IS NULL`
+      )
+      .run(userId, scope);
+  },
+
+  /**
+   * Writes one scope's draft, or deletes the row when nothing is left to keep.
+   *
+   * Deleting on empty is what stops the table growing a permanent row for every
+   * session the user ever opened and typed a character into.
+   */
+  saveDraft(
+    userId: number,
+    scope: string,
+    draft: { text: string; queuedMessage: unknown | null }
+  ): void {
+    const db = getConnection();
+
+    if (!draft.text && draft.queuedMessage === null) {
+      db.prepare('DELETE FROM session_drafts WHERE user_id = ? AND draft_scope = ?')
+        .run(userId, scope);
+      return;
+    }
+
+    db.prepare(
+      `INSERT INTO session_drafts (user_id, draft_scope, draft_text, queued_message, updated_at)
+       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(user_id, draft_scope) DO UPDATE SET
+         draft_text = excluded.draft_text,
+         queued_message = excluded.queued_message,
+         updated_at = CURRENT_TIMESTAMP`
+    ).run(
+      userId,
+      scope,
+      draft.text,
+      draft.queuedMessage === null ? null : JSON.stringify(draft.queuedMessage)
+    );
+  },
+
+  deleteDraft(userId: number, scope: string): void {
+    const db = getConnection();
+    db.prepare('DELETE FROM session_drafts WHERE user_id = ? AND draft_scope = ?')
+      .run(userId, scope);
+  },
+};