@oar-sh/oar 0.9.15 → 0.9.16

package/server/server-runtime.mjs

@@ -45,6 +45,8 @@ import { registerClaudeCloudRoutes } from './routes/claude-cloud-routes.mjs';
 import { createPreviewScopeResolver, registerPreviewRoutes } from './routes/preview-routes.mjs';
 import { registerRemoteRelayRoutes } from './routes/remote-relay-routes.mjs';
 import { registerRelayEventRoutes } from './routes/relay-event-routes.mjs';
+import { registerRelayScheduleRoutes } from './routes/relay-schedule-routes.mjs';
+import { registerRelayAskRoutes } from './routes/relay-ask-routes.mjs';
 import { createRemoteRelayRepository } from './repositories/remote-relay-repository.mjs';
 import { createConversationGroupRepository } from './repositories/conversation-group-repository.mjs';
 import { createShareRepository } from './repositories/share-repository.mjs';
@@ -84,6 +86,9 @@ import {
 } from './services/restart-resume-service.mjs';
 import { createBackgroundWorkView } from './services/background-work-view.mjs';
 import { createRelayEventService } from './services/relay-event-service.mjs';
+import { createRelayScheduleService } from './services/relay-schedule-service.mjs';
+import { createRelayAskService } from './services/relay-ask-service.mjs';
+import { createRelayAskLinkService } from './services/relay-ask-link-service.mjs';
 import { createRelayEventLinkService } from './services/relay-event-link-service.mjs';
 import { buildClaudeAttributionSettings, normalizeClaudeAttributionMode, resolveClaudeAttributionMode, DEFAULT_CLAUDE_ATTRIBUTION_MODE } from '../shared/claude-attribution.mjs';
 import {
@@ -5128,6 +5133,11 @@ function createCompactedConversation(sourceConversationId) {
     targetRuntimeSession = ensureRuntimeSessionBinding(targetConversationId, null, now);
   });
   tx();
+  // Its schedules go on in the new conversation, both the ones that fire
+  // into it and the ones it set: the archived source would end them.
+  try { relayScheduleService.carryToCompacted(sourceConversationId, targetConversationId); } catch {}
+  // And so do its questions that don't block, asked in it or by it.
+  try { relayAskService.carryToCompacted(sourceConversationId, targetConversationId); } catch {}
 
   return {
     sourceConversationId,
@@ -5458,6 +5468,37 @@ relayEventService = createRelayEventService({
   logger: console,
 });
 
+// ─── Relay schedules ──────────────────────────────────────────────────────────
+// Prompts agents scheduled with remote_relay's `schedule`: kept in the
+// database, their timers rebuilt at boot (services/relay-schedule-service.mjs).
+const relayScheduleService = createRelayScheduleService({
+  db,
+  stmts,
+  emit: (event, payload) => io.emit(event, payload),
+  // The scheduled message is an ordinary pending one, like a relay event's.
+  wake: () => {
+    void primePendingSessionWorkers('relay-schedule');
+    sessionWorkerWebSocketService?.emitQueueChanged?.('relay-schedule');
+  },
+  // A firing into another session is a prompt of the conversation that set
+  // it: the agents' loop guard counts it (and holds it once it wants the user).
+  admitFiring: ({ createdBy }) => remoteRelayDispatcher.admitScheduledFiring({ createdBy }),
+  logger: console,
+});
+
+// ─── Questions that don't block ───────────────────────────────────────────────
+// remote_relay's `ask`: a card in the session and the Inbox; the answer
+// reaches the askers as a relay event (services/relay-ask-service.mjs).
+const relayAskService = createRelayAskService({
+  db,
+  emit: (event, payload) => io.emit(event, payload),
+  relayEvents: relayEventService,
+  // urgency "now" only.
+  pushQuestion: (question) => pushDispatchService.notifyQuestion?.(question),
+  logger: console,
+});
+if (!relayAskService.isAvailable()) console.warn(`[relay-asks] not available this boot: ${relayAskService.problem()}`);
+
 /** A worker died: its tasks are gone, and whoever watches its sessions hears of it. */
 function noteWorkerDeathForEvents(sessionId, conversationIds, reason) {
   const ids = new Set((conversationIds || []).map((id) => String(id || '').trim()).filter(Boolean));
@@ -6883,7 +6924,10 @@ const remoteRelayRegistry = createRemoteRelayRegistry({
   platform: process.platform,
   version: RUNNING_VERSION,
   emit: (event, payload) => io.emit(event, payload),
-  onRemove: (entry) => { void relayEventLinkService?.noteRelayRemoved(entry); },
+  onRemove: (entry) => {
+    void relayEventLinkService?.noteRelayRemoved(entry);
+    try { relayAskService.noteRelayRemoved(entry?.id); } catch {}
+  },
   logger: console,
 });
 relayEventLinkService = createRelayEventLinkService({
@@ -6892,6 +6936,13 @@ relayEventLinkService = createRelayEventLinkService({
   client: remoteRelayClient,
   logger: console,
 });
+// The answers to asks this relay's agents put on paired relays.
+const relayAskLinkService = createRelayAskLinkService({
+  asks: relayAskService,
+  registry: remoteRelayRegistry,
+  client: remoteRelayClient,
+  logger: console,
+});
 const remoteRelayPairing = createRemoteRelayPairing({
   registry: remoteRelayRegistry,
   client: remoteRelayClient,
@@ -6946,6 +6997,9 @@ const remoteRelayDispatcher = createRemoteRelayDispatcher({
   resolveConversationId: (id) => resolveConversationRecord({ conversationId: id, sdkSessionId: id })?.id || id,
   relayEvents: relayEventService,
   relayEventLink: relayEventLinkService,
+  relaySchedules: relayScheduleService,
+  relayAsks: relayAskService,
+  relayAskLink: relayAskLinkService,
   logger: console,
 });
 
@@ -7165,6 +7219,8 @@ const sharedRouteDeps = {
   collectHostActivity,
   usageLimitPauseService,
   relayEventService,
+  relayScheduleService,
+  relayAskService,
   sessionActivityTracker,
   resolveConversationRecord,
   markSharedViewerPresence,
@@ -7210,6 +7266,22 @@ registerRelayEventRoutes(app, {
   relayEventService,
   remoteRelayInbound,
 });
+registerRelayScheduleRoutes(app, {
+  auth,
+  relayScheduleService,
+  remoteRelayInbound,
+});
+registerRelayAskRoutes(app, {
+  auth,
+  db,
+  stmts,
+  formatQuestionRow,
+  relayAskService,
+  relayAskLinkService,
+  remoteRelayInbound,
+  remoteRelayRegistry,
+  remoteRelayClient,
+});
 registerRelayRestartRoutes(app, {
   auth,
   // Read only: a GET neither fires the restart nor asks the question.
@@ -7572,6 +7644,11 @@ void primePendingSessionWorkers('startup');
 // heartbeat are swept from here on.
 relayEventService.start();
 relayEventLinkService.start();
+// Schedules get their timers back; one that came due while the relay was
+// down fires now, once.
+relayScheduleService.start();
+// Asks on paired relays still open there: look for their answers again.
+relayAskLinkService.start();
 runtimeTimers.pendingWorkerPrime = setInterval(() => {
   void primePendingSessionWorkers('maintenance');
   detachedWorkerWatch.sweep().catch((error) => {
@@ -7892,6 +7969,8 @@ function shutdownRuntime(reason = 'unknown', { exitCode = 0 } = {}) {
   try { relayEventService.noteRelayExit({ action: runtimeShutdownExitCode === RELAY_RESTART_EXIT_CODE ? 'restart' : 'shutdown', reason }); } catch {}
   try { relayEventService.stop(); } catch {}
   try { relayEventLinkService.stop(); } catch {}
+  try { relayScheduleService.stop(); } catch {}
+  try { relayAskLinkService.stop(); } catch {}
   tmuxInspectorSocketService.stop();
   stopWorkspaceFileWatcher();
   sshTunnelManager.stop();

package/server/services/cache-rebuild-service.mjs

@@ -68,6 +68,9 @@ export function createCacheRebuildService({
   // Session groups: a purged head leaves its group, and a wipe is followed
   // by a repair of what the wiped rows headed. Absent in older wiring.
   conversationGroups = null,
+  // (conversationId, { deleted }) => void: a conversation this service
+  // archived or removed (its relay schedules end). Absent in older wiring.
+  onConversationGone = null,
 }) {
   const legacyConversationList = buildLegacyConversationList(db);
   const boundConversationList = buildBoundConversationList(db);
@@ -99,10 +102,19 @@ export function createCacheRebuildService({
       db.prepare(`DELETE FROM conversations WHERE id = ?`).run(sid);
     })();
     closePreviews(sid);
+    noteGone(sid, { deleted: true });
     deleteOrphanedUploads(orphanedUploads);
     return orphanedUploads;
   }
 
+  function noteGone(conversationId, options) {
+    try {
+      onConversationGone?.(conversationId, options);
+    } catch (error) {
+      console.warn(`[cache] the end of a conversation was not passed on: ${error?.message || error}`);
+    }
+  }
+
   function closePreviews(conversationId) {
     try {
       closeConversationPreviews?.(conversationId);
@@ -115,7 +127,9 @@ export function createCacheRebuildService({
     const sid = normalizeId(conversationId);
     if (!sid) return false;
     const result = db.prepare(`UPDATE conversations SET archived = 1, updated_at = ? WHERE id = ? AND status != 'deleted'`).run(new Date().toISOString(), sid);
-    return Number(result?.changes || 0) > 0;
+    const archived = Number(result?.changes || 0) > 0;
+    if (archived) noteGone(sid, { deleted: false });
+    return archived;
   }
 
   function fullWipeCache() {
@@ -176,7 +190,10 @@ export function createCacheRebuildService({
     })();
 
     for (const conversationId of conversationIds) {
-      if (!manualTitleConversationSet.has(conversationId)) closePreviews(conversationId);
+      if (!manualTitleConversationSet.has(conversationId)) {
+        closePreviews(conversationId);
+        noteGone(conversationId, { deleted: true });
+      }
     }
 
     deleteOrphanedUploads(uploadHashes);

package/server/services/conversation-preferences-service.mjs

@@ -41,6 +41,9 @@ export function persistConversationPreferences({
   // fallback is the relay default (on / summarized).
   thinkingEnabled = undefined,
   thinkingDisplay = undefined,
+  // The owner's "agents in this conversation may start sessions" (a boolean;
+  // `undefined` leaves it alone). The route decides who may write it.
+  mayCreateSessions = undefined,
   updatedAt = new Date().toISOString(),
   createIfMissing = false,
   createTitle = 'Session',
@@ -56,6 +59,7 @@ export function persistConversationPreferences({
   const enabled = writesThinkingEnabled ? parseThinkingEnabled(thinkingEnabled) : DEFAULT_THINKING_ENABLED;
   const writesThinkingDisplay = thinkingDisplay !== undefined;
   const display = writesThinkingDisplay ? parseThinkingDisplay(thinkingDisplay) : null;
+  const writesMayCreateSessions = mayCreateSessions !== undefined;
   if (!db || !stmts || !convId || !mode) {
     return {
       ok: false,
@@ -66,6 +70,7 @@ export function persistConversationPreferences({
       autoCompactWindow: null,
       thinkingEnabled: DEFAULT_THINKING_ENABLED,
       thinkingDisplay: DEFAULT_THINKING_DISPLAY,
+      mayCreateSessions: false,
       updatedAt,
     };
   }
@@ -99,6 +104,10 @@ export function persistConversationPreferences({
       extraSets.push('thinking_display = ?');
       extraValues.push(display);
     }
+    if (writesMayCreateSessions) {
+      extraSets.push('may_create_sessions = ?');
+      extraValues.push(mayCreateSessions === true ? 1 : 0);
+    }
     try {
       if (extraSets.length) {
         db.prepare(`
@@ -136,12 +145,20 @@ export function persistConversationPreferences({
       thinkingDisplay: writesThinkingDisplay
         ? display
         : parseThinkingDisplay(existing?.thinking_display),
+      mayCreateSessions: writesMayCreateSessions
+        ? mayCreateSessions === true
+        : readMayCreateSessions(existing),
       updatedAt,
     };
   });
   return writePreferences();
 }
 
+/** The owner's "agents in this conversation may start sessions" of a conversations row. */
+export function readMayCreateSessions(row) {
+  return Number(row?.may_create_sessions) === 1;
+}
+
 export function persistConversationModelPreference({
   db,
   stmts,

package/server/services/relay-ask-link-service.mjs

@@ -0,0 +1,174 @@
+'use strict';
+
+/**
+ * The asking side of questions that don't block on paired relays: while an
+ * ask this relay's agent put on a paired relay is open there (a mirror row,
+ * relay-ask-service.mjs), this relay asks that relay every few seconds how it
+ * stands (POST /api/relay-asks/remote/status) and closes what closed there;
+ * the ask service tells the conversation that asked. Only this relay calls,
+ * so a pairing in one direction is enough. A relay that does not answer is
+ * asked less often until it does; nothing is lost meanwhile, the asks wait
+ * there.
+ */
+
+import { REMOTE_RELAY_ERROR_CODES } from '../../shared/remote-relay-contract.mjs';
+import { RELAY_ASK_LIMITS } from '../../shared/relay-asks.mjs';
+
+// The routes a relay serves its paired relays for asks (routes/relay-ask-routes.mjs).
+export const RELAY_ASK_REMOTE_PATHS = Object.freeze({
+  ask: '/api/relay-asks/remote/ask',
+  status: '/api/relay-asks/remote/status',
+  withdraw: '/api/relay-asks/remote/withdraw',
+  answer: '/api/relay-asks/remote/answer',
+  dismiss: '/api/relay-asks/remote/dismiss',
+  inbox: '/api/relay-asks/remote/inbox',
+});
+
+const LOG_PREFIX = '[relay-asks]';
+
+function toText(value) {
+  return String(value ?? '').trim();
+}
+
+/**
+ * A paired relay that predates asks answers their routes with Express's HTML
+ * 404: no JSON, no code. A 404 of these routes always carries one.
+ */
+export function isMissingRelayAskRoute(error) {
+  return toText(error?.code) === REMOTE_RELAY_ERROR_CODES.notFound && !toText(error?.remoteBody?.code);
+}
+
+export function relayWithoutAsksText(name) {
+  return `Relay "${toText(name) || 'the paired relay'}" runs an OAR version without questions that don't block; it needs an update before its sessions can be asked for from here.`;
+}
+
+export function createRelayAskLinkService({
+  asks,
+  // `get(id)`: the registry entry (address and token) of a paired relay.
+  registry,
+  // `request(relay, method, path, { body, timeoutMs })`: remote-relay-client.mjs.
+  client,
+  setTimer = (fn, ms) => {
+    const timer = setTimeout(fn, ms);
+    timer.unref?.();
+    return timer;
+  },
+  clearTimer = (timer) => clearTimeout(timer),
+  logger = console,
+  pollMs = RELAY_ASK_LIMITS.remotePollMs,
+  failingPollMs = RELAY_ASK_LIMITS.remotePollFailingMs,
+  timeoutMs = 15_000,
+} = {}) {
+  if (!asks) throw new Error('asks is required');
+  // paired relay id → { timer, running, again }
+  const links = new Map();
+  let started = false;
+
+  function warn(line) {
+    try { logger?.warn?.(`${LOG_PREFIX} ${line}`); } catch {}
+  }
+
+  function linkState(relayId) {
+    if (!links.has(relayId)) links.set(relayId, { timer: null, running: null, again: false });
+    return links.get(relayId);
+  }
+
+  function forget(relayId) {
+    const link = links.get(relayId);
+    if (link?.timer) clearTimer(link.timer);
+    links.delete(relayId);
+  }
+
+  function schedule(relayId, delayMs) {
+    if (!started) return;
+    const link = linkState(relayId);
+    if (link.timer) clearTimer(link.timer);
+    link.timer = setTimer(() => {
+      link.timer = null;
+      void fetchNow(relayId);
+    }, Math.max(0, delayMs));
+  }
+
+  async function fetchOnce(relayId) {
+    const ids = asks.pendingMirrorIds(relayId);
+    if (!ids.length) return { ok: true, idle: true };
+    const relay = registry?.get?.(relayId) || null;
+    if (!relay) {
+      asks.noteRelayRemoved(relayId);
+      return { ok: false, removed: true };
+    }
+    let response;
+    try {
+      response = await client.request(relay, 'POST', RELAY_ASK_REMOTE_PATHS.status, { body: { ids }, timeoutMs });
+    } catch (error) {
+      return { ok: false, error: toText(error?.message || error).slice(0, 300) || 'no answer' };
+    }
+    if (!response || !Array.isArray(response.asks)) return { ok: false, error: 'unexpected answer' };
+    asks.applyRemoteStatus(relayId, { relayName: toText(relay.name), statuses: response.asks });
+    return { ok: true };
+  }
+
+  /** Asks a paired relay now (one already running is followed by one more). Never throws. */
+  function fetchNow(relayId) {
+    const id = toText(relayId);
+    const link = linkState(id);
+    if (link.timer) {
+      clearTimer(link.timer);
+      link.timer = null;
+    }
+    if (link.running) {
+      link.again = true;
+      return link.running;
+    }
+    link.running = (async () => {
+      let result;
+      try {
+        result = await fetchOnce(id);
+      } catch (error) {
+        warn(`status from paired relay ${id.slice(0, 12)} failed: ${toText(error?.message || error).slice(0, 200)}`);
+        result = { ok: false };
+      } finally {
+        link.running = null;
+      }
+      if (result.removed) {
+        forget(id);
+      } else if (link.again) {
+        link.again = false;
+        schedule(id, 0);
+      } else if (asks.pendingMirrorIds(id).length) {
+        schedule(id, result.ok ? pollMs : failingPollMs);
+      } else {
+        forget(id);
+      }
+      return result;
+    })();
+    return link.running;
+  }
+
+  /** An ask was just put on that relay: look for its answer from now on. */
+  function noteAsked(relayId) {
+    const id = toText(relayId);
+    if (!id || links.get(id)?.timer || links.get(id)?.running) return;
+    schedule(id, pollMs);
+  }
+
+  function start() {
+    if (started) return;
+    started = true;
+    let delay = 0;
+    for (const relayId of asks.mirrorRelays()) {
+      schedule(relayId, delay);
+      delay += 250;
+    }
+  }
+
+  function stop() {
+    started = false;
+    for (const link of links.values()) {
+      if (link.timer) clearTimer(link.timer);
+      link.timer = null;
+    }
+  }
+
+  return { start, stop, fetchNow, noteAsked, isPolling: (relayId) => links.has(toText(relayId)) };
+}