@oar-sh/oar 0.9.11 → 0.9.13

package/server/migrations/0018-background-task-rows.mjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Migration: the task console's rows outlive a relay restart.
+ *
+ * `background_task_rows` holds what the relay keeps of a background task
+ * that has a console (a shell or Monitor task naming its output file), per
+ * store key (the id the worker posts under, its SDK session id) and task:
+ *
+ * - `state` 'live': a task of the worker's last set. After a restart it is
+ *   held back until the worker reports again: the worker's set decides which
+ *   are still running, and those of a worker that does not report are marked
+ *   ended, never shown as running again.
+ * - `state` 'ended': the dimmed row the panel keeps for an hour after the end,
+ *   with its status and exit code. `ended_at` (epoch ms) is what the hour
+ *   counts from.
+ * - `row_json` the task row as the store holds it, without the health
+ *   reading (the poller reads the file again).
+ *
+ * Rows go when the hour is up, when the conversation is deleted, and live
+ * rows when the worker's set no longer names them.
+ *
+ * Additive and idempotent. Safe to run on every boot. An older build never
+ * reads the table; its consoles start empty after a restart as before.
+ *
+ * Usage: node server/migrations/0018-background-task-rows.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const BACKGROUND_TASK_ROWS_COLUMNS = Object.freeze(['store_key', 'task_id', 'state', 'row_json', 'ended_at', 'updated_at']);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** Why the table cannot be used (a table of that name with other columns), or ''. */
+export function backgroundTaskRowsTableProblem(db) {
+  if (!tableExists(db, 'background_task_rows')) return 'no background_task_rows table';
+  const present = new Set(db.prepare(`PRAGMA table_info(background_task_rows)`).all().map((column) => column.name));
+  const missing = BACKGROUND_TASK_ROWS_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `background_task_rows lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateBackgroundTaskRows(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'background_task_rows')) {
+    db.exec(`
+      CREATE TABLE background_task_rows (
+        store_key  TEXT NOT NULL,
+        task_id    TEXT NOT NULL,
+        state      TEXT NOT NULL CHECK (state IN ('live', 'ended')),
+        row_json   TEXT NOT NULL,
+        ended_at   INTEGER,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (store_key, task_id)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_background_task_rows_ended
+    ON background_task_rows(state, ended_at)
+  `);
+  return { applied: tablesAdded > 0, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateBackgroundTaskRows(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0018 on ${dbPath}`);
+    console.log(result.applied
+      ? `  background task rows: tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0018 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/public/app/action-confirmations.js

@@ -20,6 +20,7 @@ import {
 } from './api-client.js';
 import { isSuspendHostActionVisible } from './settings-modal.js';
 import { describeRelayRestartError } from './relay-restart-error.mjs';
+import { initRelayRestartUi, openRestartRelayConfirmation } from './relay-restart-ui.js';
 import {
   applyHostSuspendState,
   describeHostSuspendBlocker,
@@ -106,21 +107,10 @@ export async function confirmKillCurrentSession() {
   }
 }
 
-export function openRestartRelayConfirmation() {
-  openSummaryModal({
-    title: 'Restart web relay',
-    subtitle: 'Queues restart via /api/relay/shutdown',
-    kind: 'restart-relay',
-    bodyHtml: `
-      <p>Queue a manual relay restart now?</p>
-      <p>The restart waits until the current turn is idle, so it does not interrupt an in-flight turn immediately.</p>
-      <div class="summary-modal-actions">
-        <button class="chat-title-action-btn" type="button" onclick="confirmRestartWebRelay()">🌄 Restart web relay</button>
-        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
-      </div>
-    `,
-  });
-}
+// ⋯ → Restart web relay first shows what the restart would wait for and
+// leave running (relay-restart-ui.js); its buttons land in
+// confirmRestartWebRelay below or in confirmRestartRelayNow.
+export { openRestartRelayConfirmation };
 
 export function openEmptyQueueConfirmation() {
   menuDeps.lockChatActionsMenuShield(350);
@@ -375,6 +365,10 @@ export async function confirmRestartWebRelay() {
       showTransientRelayNotice('Relay is already shutting down/restarting.', 7000);
       return;
     }
+    if (result.status === 'shutting_down') {
+      showTransientRelayNotice('Nothing was running: the relay is restarting now.', 7000);
+      return;
+    }
     const queue = result.queue || {};
     showTransientRelayNotice(
       `Relay restart queued (pending=${Number(queue.pendingCount || 0)}, processing=${Number(queue.processingCount || 0)}).`,
@@ -399,6 +393,9 @@ export function initActionConfirmations({
     syncQueueStatusMenuEntry: typeof syncQueueStatusMenuEntry === 'function' ? syncQueueStatusMenuEntry : menuDeps.syncQueueStatusMenuEntry,
     refreshSessionWorkerStatus: typeof refreshSessionWorkerStatus === 'function' ? refreshSessionWorkerStatus : menuDeps.refreshSessionWorkerStatus,
   };
+  // The restart confirmations' and banner's inline handlers live on window
+  // either way (bootstrap exposes this module's own).
+  initRelayRestartUi();
   if (!exposeOnWindow) return;
   window.openKillSessionConfirmation = openKillSessionConfirmation;
   window.openRestartRelayConfirmation = openRestartRelayConfirmation;

package/server/public/app/api-client.js

@@ -45,7 +45,7 @@ export function areNetworkRequestsEnabled() {
   return networkRequestsEnabled;
 }
 
-export async function apiFetch(url, opts = {}) {
+export async function apiFetch(url, { onErrorResponse, ...opts } = {}) {
   // A keepalive request is a page's last word; it goes out even when the
   // page's regular network work is already suspended.
   if (!networkRequestsEnabled && !opts.keepalive) return null;
@@ -61,6 +61,9 @@ export async function apiFetch(url, opts = {}) {
     });
     if (!response.ok) {
       console.error('API error', response.status, url);
+      // A caller that shows why a request failed reads the answer here; the
+      // result is still null.
+      if (typeof onErrorResponse === 'function') await onErrorResponse(response);
       return null;
     }
     noteFetchSuccess();
@@ -328,12 +331,14 @@ export async function updateClaudeSettings({
   model = undefined,
   enabledModels = undefined,
   attributionMode = undefined,
+  backgroundCommandLimitMinutes = undefined,
 } = {}) {
   const payload = {};
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
   if (typeof attributionMode === 'string' && attributionMode.trim()) payload.attributionMode = attributionMode.trim();
+  if (Number.isFinite(backgroundCommandLimitMinutes)) payload.backgroundCommandLimitMinutes = backgroundCommandLimitMinutes;
   return settingsRequest('/api/settings/claude', payload, 'Failed to update Claude settings');
 }
 
@@ -572,6 +577,29 @@ export async function updateBackgroundTaskTimeoutSetting(timeoutMinutes) {
   });
 }
 
+export async function loadTaskStallMinutesSetting() {
+  return apiFetch('/api/settings/task-stall-minutes');
+}
+
+export async function updateTaskStallMinutesSetting(minutes) {
+  return apiFetch('/api/settings/task-stall-minutes', {
+    method: 'POST',
+    body: JSON.stringify({ minutes: Number(minutes) }),
+  });
+}
+
+// "After a relay restart, tell interrupted sessions to carry on" (off by default).
+export async function loadRestartResumeSetting() {
+  return apiFetch('/api/settings/restart-resume');
+}
+
+export async function updateRestartResumeSetting(enabled) {
+  return apiFetch('/api/settings/restart-resume', {
+    method: 'POST',
+    body: JSON.stringify({ enabled: enabled === true }),
+  });
+}
+
 export async function loadPwaAppNameSetting() {
   return apiFetch('/api/settings/pwa-app-name');
 }
@@ -1412,6 +1440,31 @@ export async function cancelRelayRestart(body = {}) {
   });
 }
 
+// The queued restart's state, and the picture for a restart asked now: the
+// sessions it would wait for, the messages it would hold, the background
+// tasks and whether they survive (routes/relay-restart-routes.mjs).
+export async function loadRelayRestartPreview(action = 'restart') {
+  return apiFetchOrThrow(`/api/relay/shutdown?action=${encodeURIComponent(action)}`);
+}
+
+export async function keepWaitingForRelayRestart(body = {}) {
+  return apiFetchOrThrow('/api/relay/shutdown/keep-waiting', {
+    method: 'POST',
+    body: JSON.stringify({ requestedBy: 'localhost-api', ...(body || {}) }),
+  });
+}
+
+export async function loadRelayRestartMaxWaitSetting() {
+  return apiFetch('/api/settings/relay-restart-max-wait');
+}
+
+export async function updateRelayRestartMaxWaitSetting(maxWaitMinutes) {
+  return apiFetchOrThrow('/api/settings/relay-restart-max-wait', {
+    method: 'POST',
+    body: JSON.stringify({ maxWaitMinutes: Number(maxWaitMinutes) }),
+  });
+}
+
 export async function requestQueueEmpty(body = {}) {
   return apiFetchOrThrow('/api/queue/empty', {
     method: 'POST',
@@ -1423,8 +1476,22 @@ export async function requestQueueEmpty(body = {}) {
   });
 }
 
-export async function sendMessage(body) {
-  return apiFetch('/api/message', { method: 'POST', body: JSON.stringify(body) });
+// Null on any failure, like apiFetch. A send the relay refused for a reason
+// the user can act on (a 409 such as "this conversation's model is no longer
+// available") hands that reason to onRefused first, so the composer can say
+// it instead of "could not be sent". A replayed send that already landed
+// (DUPLICATE_MESSAGE_ID) is not a refusal.
+export async function sendMessage(body, { onRefused } = {}) {
+  return apiFetch('/api/message', {
+    method: 'POST',
+    body: JSON.stringify(body),
+    onErrorResponse: async (response) => {
+      if (response.status !== 409 || typeof onRefused !== 'function') return;
+      const payload = await response.json().catch(() => null);
+      const reason = readableServerError(payload?.error);
+      if (reason && payload?.code !== 'DUPLICATE_MESSAGE_ID') onRefused(reason, payload);
+    },
+  });
 }
 
 // Raw fetch instead of apiFetch: a rejected bootstrap (bad CWD, unavailable