@oar-sh/oar 0.9.2 → 0.9.4

package/server/migrations/0004-steer-settle-markers.mjs

@@ -0,0 +1,119 @@
+'use strict';
+
+/**
+ * Migration: give steering settle stubs a durable shape the transcript can
+ * render on reload.
+ *
+ * 1. `messages.source_message_id` — the user message an assistant row answers.
+ *    The link used to live only in `queue.response_message_id`, and the queue
+ *    keeps just the newest 200 finished rows, so older assistant rows lost
+ *    their anchor and fell back to response-time ordering: an absorbed
+ *    (handed-off) reply then sorted below the steered message it hands off to,
+ *    and the merge never applied. Backfilled from whatever queue rows remain.
+ * 2. `messages.resend_of_message_id` — on a user message sent with Resend,
+ *    the stopped steer it re-sends. Durable, so "Resent" survives reloads and
+ *    other devices, and the relay can refuse a second Resend of one original.
+ * 3. Fold stubs saved as kind='absorbed' become kind='folded'. 'absorbed'
+ *    tells the client the reply continues through the NEXT user message, so
+ *    the next ordinary message after a fold was styled as steered.
+ *
+ * Idempotent: the column is added once, the backfill only fills NULLs, and the
+ * kind rewrite matches nothing once applied. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0004-steer-settle-markers.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { STEER_FOLDED_TEXT } from '../../shared/steer-settle-markers.mjs';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => String(column.name)));
+}
+
+export function migrateSteerSettleMarkers(db) {
+  if (!tableExists(db, 'messages')) {
+    return { applied: false, reason: 'messages table not found', sourceLinksBackfilled: 0, foldStubsRekinded: 0 };
+  }
+  let columns = columnNames(db, 'messages');
+  let columnAdded = false;
+  if (!columns.has('source_message_id')) {
+    db.exec(`ALTER TABLE messages ADD COLUMN source_message_id TEXT`);
+    columnAdded = true;
+  }
+  if (!columns.has('resend_of_message_id')) {
+    db.exec(`ALTER TABLE messages ADD COLUMN resend_of_message_id TEXT`);
+    columnAdded = true;
+  }
+  if (columnAdded) columns = columnNames(db, 'messages');
+  let sourceLinksBackfilled = 0;
+  let foldStubsRekinded = 0;
+  db.transaction(() => {
+    // Walk the (small, pruned) queue rather than correlating every message
+    // against it.
+    if (tableExists(db, 'queue') && columnNames(db, 'queue').has('response_message_id')) {
+      const link = db.prepare(`
+        UPDATE messages SET source_message_id = ?
+        WHERE id = ? AND role = 'assistant' AND source_message_id IS NULL
+      `);
+      const rows = db.prepare(`
+        SELECT id, response_message_id FROM queue
+        WHERE response_message_id IS NOT NULL AND response_message_id != ''
+      `).all();
+      for (const row of rows) {
+        sourceLinksBackfilled += link.run(String(row.id), String(row.response_message_id)).changes;
+      }
+    }
+    if (columns.has('kind')) {
+      foldStubsRekinded = db.prepare(`
+        UPDATE messages SET kind = 'folded'
+        WHERE role = 'assistant' AND kind = 'absorbed' AND TRIM(text) = ?
+      `).run(STEER_FOLDED_TEXT).changes;
+    }
+  })();
+  return {
+    applied: columnAdded || sourceLinksBackfilled > 0 || foldStubsRekinded > 0,
+    columnAdded,
+    sourceLinksBackfilled,
+    foldStubsRekinded,
+  };
+}
+
+export function migrate(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    return migrateSteerSettleMarkers(db);
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+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 0004 on ${dbPath}`);
+    console.log(result.applied
+      ? `  column added: ${result.columnAdded}; source links backfilled: ${result.sourceLinksBackfilled}; fold stubs re-kinded: ${result.foldStubsRekinded}`
+      : `  skipped: ${result.reason || 'nothing to change'}`);
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0004 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0005-remote-relays.mjs

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * Migration: storage for remote relays (agents working across OAR relays).
+ *
+ * 1. `messages.origin_json` — on a user row that another relay's agent sent:
+ *    who sent it (relay, source conversation, model, hop count). Drives the
+ *    "from <relay>" badge, keeps such rows from unlocking relays, and skips
+ *    the reply-ready push.
+ * 2. `conversations.origin_json` — on a conversation another relay's agent
+ *    created: the "via <relay>" marker in the conversation list.
+ * 3. `conversation_remote_relay_unlocks` — which remote relays the user has
+ *    mentioned (and so unlocked) in which conversation. Keyed by the remote's
+ *    local registry id, so a renamed remote keeps its unlocks.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0005-remote-relays.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => String(column.name)));
+}
+
+export function migrateRemoteRelays(db) {
+  let columnsAdded = 0;
+  for (const table of ['messages', 'conversations']) {
+    if (!tableExists(db, table)) continue;
+    if (!columnNames(db, table).has('origin_json')) {
+      db.exec(`ALTER TABLE ${table} ADD COLUMN origin_json TEXT`);
+      columnsAdded += 1;
+    }
+  }
+  const unlocksExisted = tableExists(db, 'conversation_remote_relay_unlocks');
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS conversation_remote_relay_unlocks (
+      conversation_id TEXT NOT NULL,
+      remote_relay_id TEXT NOT NULL,
+      message_id      TEXT,
+      created_at      TEXT NOT NULL,
+      PRIMARY KEY (conversation_id, remote_relay_id)
+    )
+  `);
+  return {
+    applied: columnsAdded > 0 || !unlocksExisted,
+    columnsAdded,
+    unlocksTableCreated: !unlocksExisted,
+  };
+}
+
+export function migrate(dbPath) {
+  const db = new Database(dbPath);
+  try {
+    return migrateRemoteRelays(db);
+  } finally {
+    db.close();
+  }
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+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 0005 on ${dbPath}`);
+    console.log(result.applied
+      ? `  origin columns added: ${result.columnsAdded}; unlocks table created: ${result.unlocksTableCreated}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0005 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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

@@ -5,16 +5,26 @@ import {
   openSummaryModal,
   closeSummaryModal,
   setSummaryModalLoading,
+  renderSummaryModalContent,
+  summaryModalState,
   showTransientRelayNotice,
 } from './store.js';
 import {
   killSessionWorker,
   requestRelayRestart,
   requestHostSuspend,
+  getHostSuspendState,
+  cancelHostSuspend,
   requestQueueEmpty,
   refreshWorkspaceRootHints,
 } from './api-client.js';
 import { isSuspendHostActionVisible } from './settings-modal.js';
+import {
+  applyHostSuspendState,
+  describeHostSuspendBlocker,
+  formatCountdown,
+  isHostSuspendPending,
+} from './host-suspend-ui.js';
 
 let killSessionInFlight = false;
 let restartRelayInFlight = false;
@@ -129,22 +139,111 @@ export function openEmptyQueueConfirmation() {
   });
 }
 
+const SUSPEND_MODAL_KIND = 'suspend-host';
+
+/**
+ * Body of the Suspend host modal for one activity snapshot. Pure so the three
+ * shapes (idle, busy, already pending) are unit-testable without a DOM.
+ */
+export function renderSuspendHostModalBody({ state = null, blockers = [], supported = true } = {}) {
+  const list = Array.isArray(blockers) ? blockers : [];
+  const items = list.map((b) => `<li>${escHtml(describeHostSuspendBlocker(b))}</li>`).join('');
+  if (!supported) {
+    return `
+      <p>Host suspend is only available when the relay runs on Windows.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Close</button>
+      </div>`;
+  }
+  if (isHostSuspendPending(state)) {
+    const status = String(state?.status || '');
+    const countdown = status === 'countdown' ? formatCountdown(state.fireAt) : null;
+    const headline = status === 'suspending'
+      ? '<p>The host is suspending now.</p>'
+      : status === 'countdown'
+        ? `<p>Everything is idle. The host suspends in <strong>${escHtml(countdown || 'a moment')}</strong> unless you cancel.</p>`
+        : '<p>A suspend is already queued. The PC will not go to sleep until these finish, then after 2 minutes of quiet:</p>';
+    return `
+      ${headline}
+      ${items ? `<ul class="suspend-host-blockers">${items}</ul>` : ''}
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn danger-btn" type="button" onclick="cancelQueuedHostSuspend()"${status === 'suspending' ? ' disabled data-keep-disabled="1"' : ''}>Cancel queued suspend</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Close</button>
+      </div>`;
+  }
+  if (!list.length) {
+    return `
+      <p>Put this PC to sleep?</p>
+      <p>Nothing is running. The host suspends <strong>30 seconds</strong> after you confirm; a banner with a countdown lets you cancel until then.</p>
+      <div class="summary-modal-actions">
+        <button class="chat-title-action-btn" type="button" onclick="confirmSuspendHost()">💤 Suspend host</button>
+        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+      </div>`;
+  }
+  return `
+    <p><strong>Agents are still active.</strong> The PC will not suspend until these finish, then after 2 minutes of quiet:</p>
+    <ul class="suspend-host-blockers">${items}</ul>
+    <p>You can cancel the queued suspend from the banner or this menu at any time.</p>
+    <div class="summary-modal-actions">
+      <button class="chat-title-action-btn" type="button" onclick="confirmSuspendHost()">💤 Suspend when idle</button>
+      <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
+    </div>`;
+}
+
+async function loadSuspendHostModal() {
+  const result = await getHostSuspendState();
+  if (summaryModalState.kind !== SUSPEND_MODAL_KIND) return;
+  if (!result?.ok) {
+    renderSummaryModalContent({
+      title: 'Suspend host',
+      subtitle: 'Suspend-to-RAM once agents are done',
+      kind: SUSPEND_MODAL_KIND,
+      refresh: loadSuspendHostModal,
+      bodyHtml: `
+        <div class="summary-error">Could not read what is running right now.</div>
+        <div class="summary-modal-actions">
+          <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Close</button>
+        </div>`,
+    });
+    return;
+  }
+  if (result.state) applyHostSuspendState(result.state);
+  renderSummaryModalContent({
+    title: 'Suspend host',
+    subtitle: isHostSuspendPending(result.state) ? 'Suspend queued' : 'Suspend-to-RAM once agents are done',
+    kind: SUSPEND_MODAL_KIND,
+    refresh: loadSuspendHostModal,
+    bodyHtml: renderSuspendHostModalBody({
+      state: result.state,
+      blockers: result.blockers,
+      supported: result.supported !== false,
+    }),
+  });
+}
+
 export function openSuspendHostConfirmation() {
-  if (!isSuspendHostActionVisible()) return;
+  if (!isSuspendHostActionVisible() && !isHostSuspendPending()) return;
   menuDeps.lockChatActionsMenuShield(350);
   menuDeps.closeChatActionsMenu();
   openSummaryModal({
     title: 'Suspend host',
-    subtitle: 'Requests suspend-to-RAM',
-    kind: 'suspend-host',
-    bodyHtml: `
-      <p>Put this PC to sleep now?</p>
-      <p>This requests suspend-to-RAM immediately.</p>
-      <div class="summary-modal-actions">
-        <button class="chat-title-action-btn" type="button" onclick="confirmSuspendHost()">💤 Suspend host</button>
-        <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Cancel</button>
-      </div>
-    `,
+    subtitle: 'Suspend-to-RAM once agents are done',
+    kind: SUSPEND_MODAL_KIND,
+    refresh: loadSuspendHostModal,
+    bodyHtml: '<div class="summary-loading">Checking what is still running…</div>',
+  });
+  setSummaryModalLoading(true);
+  loadSuspendHostModal().catch(() => {
+    if (summaryModalState.kind !== SUSPEND_MODAL_KIND) return;
+    renderSummaryModalContent({
+      title: 'Suspend host',
+      kind: SUSPEND_MODAL_KIND,
+      bodyHtml: `
+        <div class="summary-error">Could not read what is running right now.</div>
+        <div class="summary-modal-actions">
+          <button class="chat-title-action-btn" type="button" onclick="closeSummaryModal()">Close</button>
+        </div>`,
+    });
   });
   window.setTimeout(() => {
     const modal = document.getElementById('summary-modal');
@@ -152,7 +251,7 @@ export function openSuspendHostConfirmation() {
     const ariaVisible = String(modal?.getAttribute('aria-hidden') || 'true') === 'false';
     const displayVisible = modal ? window.getComputedStyle(modal).display !== 'none' : false;
     if (classVisible && ariaVisible && displayVisible) return;
-    const confirmed = window.confirm('Put this PC to sleep now?\n\nThis requests suspend-to-RAM.');
+    const confirmed = window.confirm('Put this PC to sleep once all agents are done?\n\nThe suspend is queued and fires after everything has been idle.');
     if (!confirmed) return;
     confirmSuspendHost().catch(() => {});
   }, 90);
@@ -170,9 +269,37 @@ export async function confirmSuspendHost() {
     });
     closeSummaryModal();
     if (!result?.ok) {
-      alert('Failed to suspend host');
+      alert('Failed to queue host suspend');
+      return;
+    }
+    if (result.state) applyHostSuspendState(result.state);
+    const status = String(result.state?.status || '');
+    if (result.alreadyPending) {
+      showTransientRelayNotice('A host suspend is already queued.', 5000);
+    } else if (status === 'countdown') {
+      showTransientRelayNotice('Host suspend queued: everything is idle, sleeping in 30 seconds. Cancel from the banner.', 7000);
+    } else {
+      showTransientRelayNotice('Host suspend queued: the PC sleeps once all agents are done.', 7000);
+    }
+  } finally {
+    suspendHostInFlight = false;
+    setSummaryModalLoading(false);
+  }
+}
+
+export async function cancelQueuedHostSuspend() {
+  if (suspendHostInFlight) return;
+  suspendHostInFlight = true;
+  setSummaryModalLoading(true);
+  try {
+    const result = await cancelHostSuspend();
+    closeSummaryModal();
+    if (!result?.ok) {
+      alert('Failed to cancel the queued host suspend');
       return;
     }
+    if (result.state) applyHostSuspendState(result.state);
+    showTransientRelayNotice(result.cancelled ? 'Queued host suspend cancelled.' : 'No host suspend was pending.', 4000);
   } finally {
     suspendHostInFlight = false;
     setSummaryModalLoading(false);
@@ -263,5 +390,6 @@ export function initActionConfirmations({
   window.confirmKillCurrentSession = confirmKillCurrentSession;
   window.confirmRestartWebRelay = confirmRestartWebRelay;
   window.confirmSuspendHost = confirmSuspendHost;
+  window.cancelQueuedHostSuspend = cancelQueuedHostSuspend;
   window.confirmEmptyQueue = confirmEmptyQueue;
 }

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

@@ -457,6 +457,91 @@ export async function updatePwaAppNameSetting(appName) {
   });
 }
 
+// ─── Remote relays (Settings → Relays) ───────────────────────────────────────
+// Adding a relay has several distinct refusals the form has to tell apart
+// (needs a token, this is this relay, bad address), so these calls hand back
+// the relay's JSON body on failure too — `{ ok:false, status, code, error }` —
+// instead of apiFetch's bare null. They never throw; null only when network
+// requests are paused.
+
+async function remoteRelayRequest(path, { method = 'GET', body = undefined, timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
+  if (!networkRequestsEnabled) return null;
+  try {
+    const response = await fetch(`${BASE}${path}`, {
+      signal: requestTimeoutSignal(timeoutMs),
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...authHeaders(),
+      },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    const payload = await response.json().catch(() => null);
+    noteFetchSuccess();
+    const result = payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : {};
+    if (!response.ok) {
+      return {
+        ...result,
+        ok: false,
+        status: response.status,
+        error: String(result.error || `Request failed (${response.status})`),
+      };
+    }
+    return { ok: true, ...result, status: response.status };
+  } catch (error) {
+    noteFetchFailure(path, error);
+    return { ok: false, status: 0, code: 'NETWORK', error: toErrorMessage(error) };
+  }
+}
+
+function remoteRelayPath(id, suffix = '') {
+  return `/api/remote-relays/${encodeURIComponent(String(id || '').trim())}${suffix}`;
+}
+
+/** `{ relays, self }`; never carries tokens. Null on any failure. */
+export async function loadRemoteRelays() {
+  return apiFetch('/api/remote-relays');
+}
+
+/**
+ * Probes and saves a remote relay, and (pairBack) asks it to add this relay.
+ * The probe and the pair-back are two remote round trips of up to 15 s each,
+ * hence the long timeout.
+ */
+export async function addRemoteRelay({ url, token = '', pairBack = true, selfUrl = '' } = {}) {
+  const body = { url: String(url || '').trim(), pairBack: pairBack !== false };
+  const trimmedToken = String(token || '').trim();
+  if (trimmedToken) body.token = trimmedToken;
+  const trimmedSelfUrl = String(selfUrl || '').trim();
+  if (trimmedSelfUrl) body.selfUrl = trimmedSelfUrl;
+  return remoteRelayRequest('/api/remote-relays', { method: 'POST', body, timeoutMs: LONG_REQUEST_TIMEOUT_MS });
+}
+
+/** `patch`: any of `{ permission, url, token, tokenMode }`. */
+export async function updateRemoteRelay(id, patch = {}) {
+  return remoteRelayRequest(remoteRelayPath(id), { method: 'PATCH', body: patch || {} });
+}
+
+export async function removeRemoteRelay(id) {
+  return remoteRelayRequest(remoteRelayPath(id), { method: 'DELETE' });
+}
+
+export async function checkRemoteRelay(id) {
+  return remoteRelayRequest(remoteRelayPath(id, '/check'), { method: 'POST', body: {}, timeoutMs: LONG_REQUEST_TIMEOUT_MS });
+}
+
+/** `{ publicUrl, inboundEnabled }` for this relay. */
+export async function loadRemoteRelaySettings() {
+  return apiFetch('/api/settings/remote-relays');
+}
+
+export async function updateRemoteRelaySettings(patch = {}) {
+  const body = {};
+  if (typeof patch.publicUrl === 'string') body.publicUrl = patch.publicUrl.trim();
+  if (typeof patch.inboundEnabled === 'boolean') body.inboundEnabled = patch.inboundEnabled;
+  return remoteRelayRequest('/api/settings/remote-relays', { method: 'POST', body });
+}
+
 export async function loadUpdateState() {
   return apiFetch('/api/update/state');
 }
@@ -655,10 +740,30 @@ export async function searchMessages(options = {}) {
   return apiFetch(`/api/search/messages?${params.toString()}`);
 }
 
+// Raw fetch instead of apiFetch: a refused delete (the conversation is still
+// working, or its session would not stop) must surface the server's reason.
+// The long timeout covers stopping the session and deleting its CLI session.
 export async function deleteConversation(id) {
   const convId = String(id || '').trim();
-  if (!convId) return null;
-  return apiFetch(`/api/conversation/${convId}`, { method: 'DELETE' });
+  if (!convId || !areNetworkRequestsEnabled()) return null;
+  const url = `/api/conversation/${encodeURIComponent(convId)}`;
+  try {
+    const response = await fetch(`${BASE}${url}`, {
+      signal: requestTimeoutSignal(LONG_REQUEST_TIMEOUT_MS),
+      method: 'DELETE',
+      headers: {
+        'Content-Type': 'application/json',
+        ...authHeaders(),
+      },
+    });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) return { ...(payload || {}), ok: false, status: response.status };
+    noteFetchSuccess();
+    return payload || { ok: true };
+  } catch (error) {
+    noteFetchFailure(url, error);
+    return null;
+  }
 }
 
 export async function updateMessageShareVisibility(conversationId, messageId, hiddenFromShares) {
@@ -856,6 +961,24 @@ export async function requestHostSuspend(body = {}) {
   });
 }
 
+export async function getHostSuspendState() {
+  return apiFetch('/api/host/suspend');
+}
+
+export async function cancelHostSuspend(body = {}) {
+  return apiFetch('/api/host/suspend/cancel', {
+    method: 'POST',
+    body: JSON.stringify({ requestedBy: 'localhost-api', ...(body || {}) }),
+  });
+}
+
+export async function cancelRelayRestart(body = {}) {
+  return apiFetch('/api/relay/shutdown/cancel', {
+    method: 'POST',
+    body: JSON.stringify({ requestedBy: 'localhost-api', ...(body || {}) }),
+  });
+}
+
 export async function requestQueueEmpty(body = {}) {
   return apiFetch('/api/queue/empty', {
     method: 'POST',