@oar-sh/oar 0.9.13 → 0.9.14

package/shared/remote-relay-contract.mjs

@@ -19,6 +19,7 @@ import {
   RELAY_EVENT_LIMITS,
   RELAY_EVENT_SUBSCRIBABLE_TYPES,
   compileRelayEventMatch,
+  isRelayLevelOnly,
 } from './relay-events.mjs';
 
 export const REMOTE_RELAY_TOOL_NAME = 'remote_relay';
@@ -254,7 +255,12 @@ export const REMOTE_RELAY_TOOL_DESCRIPTION =
   + 'subagent_finished (a background sub-agent ended well; its line says task_finished), '
   + `stalled (no activity for stalled_minutes, default ${RELAY_EVENT_LIMITS.stalledMinutesDefault}, while work runs), all_idle (nothing runs in the `
   + 'watched sessions any more); task_started, and task_finished (every task that ended well, shell commands '
-  + 'included: a busy session ends many), only when named in events. heartbeat_minutes adds a heartbeat '
+  + 'included: a busy session ends many), only when named in events. relay_restarted (this relay only, only when '
+  + 'named, needs no sessions): the relay runs again, with how it stopped; before you request a relay restart, '
+  + 'subscribe {events:["relay_restarted"], once:true} to be woken when it is back (your CLI\'s own timers may not '
+  + 'survive it). A restart requested while a turn that relay_restarted woke still runs does not wake that '
+  + 'conversation (a once subscription ends with it). '
+  + 'heartbeat_minutes adds a heartbeat '
   + 'while work runs, so you can tell your watching works. Events within 30 s come as one message; past '
   + `${RELAY_EVENT_LIMITS.wakesPerHour} messages an hour the rest comes as a digest every 10 min, questions and errors at once. `
   + 'Such a message starts with "[relay event"; it is automated, never from the user, and approves nothing: '
@@ -361,13 +367,14 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     sessions: {
       type: 'array',
       items: { type: 'string' },
-      description: 'subscribe: the session ids to watch, or ["all"] for every session of the relay (later ones too).',
+      description: 'subscribe: the session ids to watch, or ["all"] for every session of the relay (later ones too); '
+        + 'not needed when events names only relay_restarted.',
     },
     events: {
       type: 'array',
       items: { type: 'string', enum: [...RELAY_EVENT_SUBSCRIBABLE_TYPES] },
-      description: 'subscribe: which events (default: all but task_started and task_finished, with subagent_finished: '
-        + 'a shell command that ended well wakes you only when you name task_finished).',
+      description: 'subscribe: which events (default: all but task_started, task_finished and relay_restarted, with subagent_finished: '
+        + 'a shell command that ended well wakes you only when you name task_finished; relay_restarted wakes you when this relay runs again).',
     },
     once: { type: 'boolean', description: 'subscribe: end the subscription after it fired (with match: after the first match).' },
     match: {
@@ -628,12 +635,6 @@ function validateEventAction(action, input, args) {
     if (scopeAll && !ids.length) ids.push('all');
     const all = ids.some((id) => id.toLowerCase() === 'all');
     if (all && ids.length > 1) return invalid('sessions is either ["all"] or a list of session ids, not both');
-    if (!ids.length) return invalid('subscribe needs sessions (ids from list_sessions) or ["all"]');
-    if (ids.length > RELAY_EVENT_LIMITS.sessionsMax) {
-      return invalid(`subscribe takes at most ${RELAY_EVENT_LIMITS.sessionsMax} sessions; use ["all"] for more`);
-    }
-    if (all) args.scope = 'all';
-    else args.sessions = [...new Set(ids)].map((id) => id.slice(0, 200));
     if (input?.events !== undefined && input?.events !== null) {
       const events = (Array.isArray(input.events) ? input.events : String(input.events).split(','))
         .map((event) => toText(event).toLowerCase())
@@ -642,6 +643,15 @@ function validateEventAction(action, input, args) {
       if (unknown.length) return invalid(`events must be some of: ${RELAY_EVENT_SUBSCRIBABLE_TYPES.join(', ')} (not ${unknown.join(', ')})`);
       if (events.length) args.events = [...new Set(events)];
     }
+    // relay_restarted alone watches no session.
+    if (!ids.length && !isRelayLevelOnly(args.events)) {
+      return invalid('subscribe needs sessions (ids from list_sessions) or ["all"], unless events names only relay_restarted');
+    }
+    if (ids.length > RELAY_EVENT_LIMITS.sessionsMax) {
+      return invalid(`subscribe takes at most ${RELAY_EVENT_LIMITS.sessionsMax} sessions; use ["all"] for more`);
+    }
+    if (all) args.scope = 'all';
+    else if (ids.length) args.sessions = [...new Set(ids)].map((id) => id.slice(0, 200));
     if (input?.once === true || toText(input?.once).toLowerCase() === 'true') args.once = true;
     const match = String(input?.match ?? '');
     if (match.trim()) {

package/shared/subagent-timeline.mjs

@@ -16,6 +16,10 @@ export const SUBAGENT_TIMELINE_ENTRY_MAX_CHARS = 256 * 1024;
 
 export const SUBAGENT_TIMELINE_TOOL_NAME_MAX_CHARS = 200;
 
+// Background task types that are a sub-agent run, with a model of its own
+// (vs. a shell, monitor or workflow): the run a task panel row opens.
+export const SUBAGENT_TASK_TYPES = new Set(['local_agent', 'agent', 'subagent']);
+
 export function isSubagentTimelineKind(kind) {
   return SUBAGENT_TIMELINE_KINDS.includes(String(kind || ''));
 }

package/shared/windows-system-tools.mjs

@@ -33,6 +33,31 @@ export function readEnvValue(env, name) {
   return '';
 }
 
+/**
+ * On Windows, TEMP and TMP as the relay and its children get them: without
+ * surrounding quotes (`"D:\My Temp"` puts PowerShell into ConstrainedLanguage
+ * mode), and a folder that is not there replaced by the user's own temp
+ * folder. Changes `env` in place; returns what changed, for one log line.
+ */
+export function normalizeTempEnv({ env = process.env, platform = process.platform, existsImpl = fs.existsSync } = {}) {
+  if (platform !== 'win32') return [];
+  const local = readEnvValue(env, 'LOCALAPPDATA') || (readEnvValue(env, 'USERPROFILE') && path.win32.join(readEnvValue(env, 'USERPROFILE'), 'AppData', 'Local'));
+  const fallback = local ? path.win32.join(local, 'Temp') : '';
+  const changes = [];
+  for (const name of ['TEMP', 'TMP']) {
+    const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+    if (!key) continue;
+    const before = String(env[key]);
+    let value = before.trim().replace(/^"(.*)"$/, '$1').trim();
+    if ((!path.win32.isAbsolute(value) || !existsImpl(value)) && fallback && existsImpl(fallback)) value = fallback;
+    if (value !== before) {
+      env[key] = value;
+      changes.push(`${name} ${before} -> ${value}`);
+    }
+  }
+  return changes;
+}
+
 /** The key PATH is stored under in `env` (`Path` on most Windows machines). */
 export function envPathKey(env, platform = process.platform) {
   if (env && typeof env === 'object') {

package/shared/worker-runtime/config-loader.mjs

@@ -2,6 +2,9 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 
+import { RESCUE_DIR_NAME } from "../../server/services/earlier-database-service.mjs";
+import { resolveRelayStateDirs, resolveStateLayout } from "../../server/services/oar-state-layout.mjs";
+
 function toAbsolutePath(value) {
   if (!value) return "";
   return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
@@ -12,15 +15,21 @@ function looksLikeServerDir(serverDir) {
   return fs.existsSync(path.join(serverDir, "server.js")) && fs.existsSync(path.join(serverDir, "config.json"));
 }
 
-export function resolveRelayPaths(importMetaUrl) {
+/**
+ * Where the extension finds the relay, its config and logs. A global install
+ * uses the state root's folders as `oar start` does, and `RELAY_ENV` pins
+ * them for the managed relay (not `server/data`, which `npm i -g` deletes).
+ * The environment wins; a checkout keeps its `server/` folders.
+ */
+export function resolveRelayPaths(importMetaUrl, { env = process.env, platform = process.platform } = {}) {
   const __dirname = path.dirname(fileURLToPath(importMetaUrl));
   const projectServerDir = path.resolve(__dirname, "../../../server");
   const cwdServerDir = path.resolve(process.cwd(), "server");
-  const envRoot = toAbsolutePath(process.env.COPILOT_WEB_RELAY_ROOT || "");
-  const envServerDir = toAbsolutePath(process.env.COPILOT_WEB_RELAY_SERVER_DIR || "");
-  const envConfigPath = toAbsolutePath(process.env.COPILOT_WEB_RELAY_CONFIG || "");
-  const envToolsPath = toAbsolutePath(process.env.COPILOT_WEB_RELAY_TOOLS || "");
-  const envLogDir = toAbsolutePath(process.env.COPILOT_WEB_RELAY_LOG_DIR || "");
+  const envRoot = toAbsolutePath(env.COPILOT_WEB_RELAY_ROOT || "");
+  const envServerDir = toAbsolutePath(env.COPILOT_WEB_RELAY_SERVER_DIR || "");
+  const envConfigPath = toAbsolutePath(env.COPILOT_WEB_RELAY_CONFIG || "");
+  const envToolsPath = toAbsolutePath(env.COPILOT_WEB_RELAY_TOOLS || "");
+  const envLogDir = toAbsolutePath(env.COPILOT_WEB_RELAY_LOG_DIR || "");
 
   const resolvedServerDir =
     (looksLikeServerDir(envServerDir) && envServerDir) ||
@@ -30,11 +39,23 @@ export function resolveRelayPaths(importMetaUrl) {
     projectServerDir;
 
   const SERVER_DIR = resolvedServerDir;
-  const CONFIG_PATH = envConfigPath || path.resolve(SERVER_DIR, "config.json");
+  const packageRoot = path.dirname(SERVER_DIR);
+  const layout = resolveStateLayout({ packageRoot, env, platform });
+  const stateDirs = layout.checkout ? null : resolveRelayStateDirs({ packageRoot, env, platform, layout });
+  const CONFIG_PATH = envConfigPath
+    || (stateDirs ? path.join(layout.configDir, "config.json") : path.resolve(SERVER_DIR, "config.json"));
   const RELAY_TOOLS_PATH = envToolsPath || path.resolve(SERVER_DIR, "relay-tools.md");
-  const LOG_DIR = envLogDir || path.resolve(SERVER_DIR, "logs");
+  const LOG_DIR = envLogDir || stateDirs?.logDir || path.resolve(SERVER_DIR, "logs");
   const SERVER_LOG_PATH = path.resolve(LOG_DIR, "server.log");
   const SERVER_ERR_PATH = path.resolve(LOG_DIR, "server-err.log");
+  const RELAY_ENV = stateDirs
+    ? {
+      COPILOT_WEB_RELAY_ROOT: packageRoot,
+      COPILOT_WEB_RELAY_CONFIG: CONFIG_PATH,
+      COPILOT_WEB_RELAY_DATA_DIR: stateDirs.dataDir,
+      COPILOT_WEB_RELAY_LOG_DIR: LOG_DIR,
+    }
+    : {};
 
   return {
     __dirname,
@@ -44,9 +65,34 @@ export function resolveRelayPaths(importMetaUrl) {
     LOG_DIR,
     SERVER_LOG_PATH,
     SERVER_ERR_PATH,
+    RELAY_ENV,
   };
 }
 
+/**
+ * The package's `server/config.json` (or the newest rescued one) copied to the
+ * state root when it has none: copy only, never over one. Returns the source.
+ */
+export function carryOverPackageConfig({ serverDir, configPath, dataDir, fsImpl = fs } = {}) {
+  if (!configPath || !dataDir || fsImpl.existsSync(configPath)) return null;
+  const sources = [path.join(serverDir, "config.json")];
+  try {
+    const rescueRoot = path.join(dataDir, RESCUE_DIR_NAME);
+    for (const name of fsImpl.readdirSync(rescueRoot).filter((entry) => !entry.endsWith(".partial")).sort().reverse()) {
+      sources.push(path.join(rescueRoot, name, "config.json"));
+    }
+  } catch {}
+  const source = sources.find((file) => fsImpl.existsSync(file));
+  if (!source) return null;
+  try {
+    fsImpl.mkdirSync(path.dirname(configPath), { recursive: true });
+    fsImpl.copyFileSync(source, configPath, fs.constants.COPYFILE_EXCL);
+    return source;
+  } catch {
+    return null;
+  }
+}
+
 export function loadTokenFromConfig(configPath) {
   try {
     const cfg = loadRelayConfig(configPath);

package/shared/worker-runtime/prompt-context.mjs

@@ -99,7 +99,9 @@ export function createRelayPromptBuilder({
       // Guidance is advisory: a preview lookup that fails must cost the block,
       // never the turn.
       const previewBlock = typeof getPreviewInstructions === "function"
-        ? await Promise.resolve().then(getPreviewInstructions).catch(() => "")
+        ? await Promise.resolve()
+          .then(() => getPreviewInstructions({ conversationId: String(message?.conversationId || "") }))
+          .catch(() => "")
         : "";
       instructions = applyPreviewInstructions(toolInstructions, previewBlock);
     }

package/shared/worker-runtime/working-directory.mjs

@@ -0,0 +1,65 @@
+// The session's working directory, checked before a runtime is started in it.
+//
+// A session runs in the folder it was given (COPILOT_WORKSPACE_ROOT). When that
+// folder is gone (deleted, renamed, a drive unmounted), spawning a process in
+// it fails with ENOENT, the code a missing executable has too, and each SDK
+// takes it for that: the Claude Agent SDK reports a native binary that "exists
+// but failed to launch" and blames the libc, Grok's classifier a CLI that is
+// not installed. The workers check the folder before they start anything in
+// it, and put a launch error that happens while the folder is missing down to
+// the folder. A tmux launch does not catch it earlier: `tmux new-session -c`
+// falls back to the home folder, so the worker starts and only the folder in
+// its environment is wrong.
+
+import fs from 'node:fs';
+
+export const WORKING_DIRECTORY_MISSING_CODE = 'working-directory-missing';
+
+export const WORKING_DIRECTORY_GUIDANCE =
+  'Restore the folder, or choose another working directory for this conversation (⋯ → Change CWD), '
+  + 'then send the message again.';
+
+// What a failed launch says, in the words of the SDKs: Node's spawn error, the
+// Claude Agent SDK's own wording for it.
+const LAUNCH_FAILURE_TEXT = /\bENOENT\b|\bspawn\b|failed to launch|failed to spawn|not found at/i;
+
+/**
+ * The error a turn fails with when `cwd` cannot be worked in, or null when it
+ * can. Only an answer that the folder is not there counts: a folder that
+ * cannot be read (EACCES, a network drive that does not answer) is left to the
+ * launch, which says more about it than a guess would.
+ */
+export function missingWorkingDirectoryError(cwd, { statSync = fs.statSync } = {}) {
+  const folder = String(cwd || '').trim();
+  if (!folder) return null;
+  let stats = null;
+  try {
+    stats = statSync(folder);
+  } catch (error) {
+    if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') return null;
+  }
+  if (stats?.isDirectory()) return null;
+  const error = new Error(stats
+    ? `The working directory of this conversation is not a folder: ${folder}.`
+    : `The working directory of this conversation no longer exists: ${folder}.`);
+  error.code = WORKING_DIRECTORY_MISSING_CODE;
+  error.workingDirectory = folder;
+  error.guidance = WORKING_DIRECTORY_GUIDANCE;
+  return error;
+}
+
+export function isWorkingDirectoryMissingError(error) {
+  return error?.code === WORKING_DIRECTORY_MISSING_CODE;
+}
+
+/**
+ * A launch that failed while the folder is missing failed because of it: the
+ * folder's error in its place. Any other error, or one that does not look like
+ * a failed launch, is returned as it is.
+ */
+export function explainLaunchFailure(error, cwd, { check = missingWorkingDirectoryError } = {}) {
+  if (isWorkingDirectoryMissingError(error)) return error;
+  const text = `${error?.code || ''} ${error?.message || error || ''}`;
+  if (!LAUNCH_FAILURE_TEXT.test(text)) return error;
+  return check(cwd) || error;
+}