@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

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.
  *
@@ -430,6 +457,19 @@ const addSessionEffortColumn = (db: Database): void => {
   addColumnToTableIfNotExists(db, 'sessions', columnNames, 'effort', 'TEXT');
 };
 
+/**
+ * Adds the reasoning-effort metadata columns to the custom-model library.
+ *
+ * Existing rows stay NULL on purpose: no effort levels were ever declared for
+ * them, and a guessed list could offer levels the model rejects. Those models
+ * keep hiding the composer's Reasoning section until the user declares levels.
+ */
+const addProviderModelEffortColumns = (db: Database): void => {
+  const columnNames = getTableInfo(db, 'provider_models').map((column) => column.name);
+  addColumnToTableIfNotExists(db, 'provider_models', columnNames, 'effort_values', 'TEXT DEFAULT NULL');
+  addColumnToTableIfNotExists(db, 'provider_models', columnNames, 'effort_default', 'TEXT DEFAULT NULL');
+};
+
 const ensureProjectsForSessionPaths = (db: Database): void => {
   if (!tableExists(db, 'sessions')) {
     return;
@@ -477,6 +517,11 @@ export const runMigrations = (db: Database) => {
       CREATE INDEX IF NOT EXISTS idx_provider_models_provider_order
       ON provider_models(provider, sort_order, id)
     `);
+    addProviderModelEffortColumns(db);
+    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 +532,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/provider-models.ts

@@ -1,5 +1,6 @@
 import { getConnection } from '@/modules/database/connection.js';
 import type {
+  CustomProviderModelEffort,
   CustomProviderModelInput,
   CustomProviderModelRecord,
   LLMProvider,
@@ -11,6 +12,56 @@ type CustomProviderModelRow = {
   model_id: string;
   model_name: string;
   sort_order: number;
+  effort_values: string | null;
+  effort_default: string | null;
+};
+
+const CUSTOM_PROVIDER_MODEL_COLUMNS = `
+  id, provider, model_id, model_name, sort_order, effort_values, effort_default
+`;
+
+/**
+ * Decodes the stored effort columns. Anything that is not a non-empty JSON
+ * array of strings reads back as "no metadata" rather than failing the whole
+ * catalog, so one hand-edited row cannot break every model picker.
+ */
+const readStoredEffort = (row: CustomProviderModelRow): CustomProviderModelEffort | null => {
+  if (!row.effort_values) {
+    return null;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(row.effort_values);
+  } catch {
+    return null;
+  }
+
+  if (!Array.isArray(parsed)) {
+    return null;
+  }
+  const values = parsed.filter((value): value is string => typeof value === 'string' && value.length > 0);
+  if (values.length === 0) {
+    return null;
+  }
+
+  return row.effort_default && values.includes(row.effort_default)
+    ? { values, default: row.effort_default }
+    : { values };
+};
+
+/** Encodes effort metadata into the two nullable columns; no levels means NULL for both. */
+const toStoredEffortColumns = (
+  effort: CustomProviderModelEffort | null | undefined,
+): { values: string | null; defaultValue: string | null } => {
+  if (!effort || effort.values.length === 0) {
+    return { values: null, defaultValue: null };
+  }
+
+  return {
+    values: JSON.stringify(effort.values),
+    defaultValue: effort.default ?? null,
+  };
 };
 
 const toCustomProviderModelRecord = (
@@ -21,6 +72,7 @@ const toCustomProviderModelRecord = (
   modelId: row.model_id,
   model: row.model_name,
   sortOrder: row.sort_order,
+  effort: readStoredEffort(row),
 });
 
 const readCustomProviderModelRow = (
@@ -28,7 +80,7 @@ const readCustomProviderModelRow = (
   recordId: number,
 ): CustomProviderModelRow | null => {
   const row = getConnection().prepare(`
-    SELECT id, provider, model_id, model_name, sort_order
+    SELECT ${CUSTOM_PROVIDER_MODEL_COLUMNS}
     FROM provider_models
     WHERE provider = ? AND id = ?
   `).get(provider, recordId) as CustomProviderModelRow | undefined;
@@ -47,7 +99,7 @@ const readCustomProviderModelRow = (
 export const providerModelsDb = {
   listCustomProviderModels(provider: LLMProvider): CustomProviderModelRecord[] {
     const rows = getConnection().prepare(`
-      SELECT id, provider, model_id, model_name, sort_order
+      SELECT ${CUSTOM_PROVIDER_MODEL_COLUMNS}
       FROM provider_models
       WHERE provider = ?
       ORDER BY sort_order ASC, lower(model_name) ASC, id ASC
@@ -69,7 +121,7 @@ export const providerModelsDb = {
     modelId: string,
   ): CustomProviderModelRecord | null {
     const row = getConnection().prepare(`
-      SELECT id, provider, model_id, model_name, sort_order
+      SELECT ${CUSTOM_PROVIDER_MODEL_COLUMNS}
       FROM provider_models
       WHERE provider = ? AND model_id = ?
     `).get(provider, modelId) as CustomProviderModelRow | undefined;
@@ -88,10 +140,20 @@ export const providerModelsDb = {
       WHERE provider = ?
     `).get(provider) as { next_order: number };
 
+    const effort = toStoredEffortColumns(input.effort);
     const result = db.prepare(`
-      INSERT INTO provider_models (provider, model_id, model_name, sort_order)
-      VALUES (?, ?, ?, ?)
-    `).run(provider, input.id, input.model, nextOrder.next_order);
+      INSERT INTO provider_models (
+        provider, model_id, model_name, sort_order, effort_values, effort_default
+      )
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(
+      provider,
+      input.id,
+      input.model,
+      nextOrder.next_order,
+      effort.values,
+      effort.defaultValue,
+    );
 
     const row = readCustomProviderModelRow(provider, Number(result.lastInsertRowid));
     if (!row) {
@@ -119,6 +181,17 @@ export const providerModelsDb = {
         WHERE provider = ? AND id = ?
       `).run(input.id, input.model, provider, recordId);
 
+      // An omitted `effort` keeps the stored levels so clients that only edit
+      // the name or id cannot wipe them; `null` explicitly clears them.
+      if (input.effort !== undefined) {
+        const effort = toStoredEffortColumns(input.effort);
+        db.prepare(`
+          UPDATE provider_models
+          SET effort_values = ?, effort_default = ?
+          WHERE provider = ? AND id = ?
+        `).run(effort.values, effort.defaultValue, provider, recordId);
+      }
+
       if (previous.model_id !== input.id) {
         db.prepare(`
           UPDATE sessions

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);
+  },
+};