@oar-sh/oar 0.9.14 → 0.9.15

package/server/public/app/settings-modal.js

@@ -1502,6 +1502,11 @@ const WINDOWS_BOOT_CUSTOMISATION_LABELS = Object.freeze({
   'boot-delay': 'boot delay',
   launcher: 'launcher edited or from an older OAR',
   'launcher-missing': 'launcher missing',
+  user: 'account',
+  'run-level': 'run level',
+  settings: 'settings',
+  other: 'other parts',
+  unreadable: 'unreadable',
 });
 
 function windowsAutostartStatusText() {
@@ -1511,21 +1516,30 @@ function windowsAutostartStatusText() {
   }
   if (boot?.lastError) return boot.lastError;
   if (boot?.readError) return `The boot task could not be read: ${boot.readError}`;
+  const [startupEntry] = windowsAutostartState?.signinHandMade || [];
+  if (startupEntry) {
+    const starts = startupEntry.otherInstall ? ` (it starts the OAR install in ${startupEntry.otherInstall})` : '';
+    return `A Startup entry OAR did not make is there: ${startupEntry.path}${starts}. OAR leaves it as it is; to replace it, keeping a copy: oar autostart signin --replace.`;
+  }
   if (windowsAutostartState?.mode === 'boot' && windowsAutostartState?.signinEnabled) {
     return 'A sign-in Startup entry also exists and can double-start the relay. Re-select "At system startup" to clean it up.';
   }
+  // OAR never deletes or writes over an entry it did not make (as `oar autostart`).
+  const replaceHint = 'OAR leaves it as it is; to replace it, keeping a copy: oar autostart boot --replace';
   if (windowsAutostartState?.mode === 'boot' && boot?.customised) {
     const labels = (boot.customisations || []).map((name) => WINDOWS_BOOT_CUSTOMISATION_LABELS[name] || name);
-    return `The boot task or its launcher differs from what OAR generates (${labels.join(', ')}). Re-selecting "At system startup" regenerates both and keeps a changed launcher as a .bak copy.`;
+    return boot.handMade?.length
+      ? `The boot task or its launcher was changed by hand (${labels.join(', ')}). ${replaceHint}.`
+      : `The boot task or its launcher differs from what OAR generates (${labels.join(', ')}). Re-selecting "At system startup" regenerates it.`;
   }
   if (windowsAutostartState?.mode === 'boot' && boot?.launcherBackupPath) {
     return `The previous launcher was replaced and kept as ${boot.launcherBackupPath}.`;
   }
   if (boot?.taskStatus === 'foreign') {
-    return `A task named "${boot.taskName}" exists but was not created by OAR. Selecting "At system startup" replaces it.`;
+    return `A task named "${boot.taskName}" exists but was not created by OAR. ${replaceHint}.`;
   }
   if (boot?.legacyTaskPresent && windowsAutostartState?.mode !== 'boot') {
-    return 'A pre-rebrand boot task exists. Selecting "At system startup" migrates it (one admin confirmation).';
+    return `A pre-rebrand boot task exists. ${replaceHint}.`;
   }
   return '';
 }

package/server/routes/sessions-routes.mjs

@@ -9,6 +9,7 @@ import { randomUUID } from 'crypto';
 import { createSdkSessionSyncService } from '../services/sdk-session-sync-service.mjs';
 import { serveFileWithRangeSupport } from '../services/file-serving.mjs';
 import { stripRelayPromptContext } from '../services/relay-prompt-sanitizer.mjs';
+import { describeWindowsAutostart, handMadeLines, switchBlockers } from '../services/windows-boot-autostart-service.mjs';
 import {
   buildConversationHistoryPageInfo,
   normalizeConversationHistoryLimit,
@@ -7299,6 +7300,7 @@ export function registerSessionsRoutes(app, deps) {
         legacyTaskPresent: boot.legacyTaskPresent,
         customised: boot.customised === true,
         customisations: Array.isArray(boot.customisations) ? boot.customisations : [],
+        handMade: Array.isArray(boot.handMade) ? boot.handMade : [],
         launcherBackupPath: boot.launcherBackupPath || null,
         readError: boot.readError || null,
         pendingElevation: boot.pendingElevation || null,
@@ -7306,6 +7308,9 @@ export function registerSessionsRoutes(app, deps) {
         manualCommand: boot.manualCommand || null,
       } : null,
       signinEnabled: signin.enabled,
+      // The Startup entries OAR did not make, which it leaves as they are.
+      signinHandMade: (windowsAutostartService.listEntries?.() || []).filter((entry) => !entry.generated)
+        .map(({ path: entryPath, otherInstall }) => ({ path: entryPath, otherInstall: otherInstall || null })),
     };
   }
 
@@ -7342,9 +7347,31 @@ export function registerSessionsRoutes(app, deps) {
       if (!windowsAutostartService.getState().supported) {
         return res.status(400).json({ error: 'Windows autostart is only available on Windows' });
       }
+      if (mode === 'boot' && !windowsBootAutostartService) {
+        return res.status(500).json({ error: 'Windows boot autostart is unavailable' });
+      }
+      // The rules of `oar autostart`: only entries OAR generated are deleted
+      // or written over. A hand-made one (a Startup entry, our task or its
+      // launcher changed by hand, a task someone else made) that would stay
+      // beside the new mode, or be replaced by it, stops the switch with the
+      // same message; replacing it is `oar autostart <mode> --replace`.
+      const boot = windowsBootAutostartService ? await windowsBootAutostartService.getState() : null;
+      const now = describeWindowsAutostart({
+        signinEntries: windowsAutostartService.listEntries?.() || [],
+        boot: boot?.supported ? boot : {},
+      });
+      if (now.mode === 'unknown') {
+        return res.status(409).json({ error: 'The boot task could not be read, so nothing was changed; the relay log has the details.' });
+      }
+      const blocking = switchBlockers(now, mode);
+      if (blocking.length) return res.status(409).json({ error: handMadeLines(blocking, mode).join(' ') });
       if (mode === 'boot') {
-        if (!windowsBootAutostartService) {
-          return res.status(500).json({ error: 'Windows boot autostart is unavailable' });
+        // A generated launcher that is missing or of an earlier version is
+        // regenerated by enabling again; a hand-made one stays.
+        const regenerate = boot.customised && !boot.handMade?.length;
+        if (now.mode === 'boot' && !regenerate) {
+          windowsAutostartService.setEnabled(false);
+          return res.json({ ...(await windowsAutostartMergedState()), accepted: true });
         }
         // The sweep's completion also removes the Startup .cmd entries; the
         // sign-in service is not touched here so a declined UAC leaves the
@@ -7352,19 +7379,23 @@ export function registerSessionsRoutes(app, deps) {
         const result = await windowsBootAutostartService.requestEnable();
         return res.json({ ...(await windowsAutostartMergedState()), accepted: result.accepted });
       }
-      // Leaving boot mode needs its own elevated sweep before the sign-in
-      // half applies; a declined UAC must not leave both modes armed.
-      const boot = windowsBootAutostartService ? await windowsBootAutostartService.getState() : null;
-      let accepted = true;
-      if (boot?.supported && (boot.taskStatus === 'ready' || boot.taskStatus === 'foreign' || boot.legacyTaskPresent)) {
-        if (boot.taskStatus === 'foreign' && mode === 'signin') {
-          // Someone else's task under our name: never delete it as a side
-          // effect of picking sign-in mode.
-          windowsAutostartService.setEnabled(true);
-          return res.json({ ...(await windowsAutostartMergedState()), accepted: true });
-        }
-        accepted = (await windowsBootAutostartService.requestDisable()).accepted;
+      // Leaving boot mode needs its own elevated sweep; the sign-in half
+      // applies once the prompt was confirmed and the task is gone, so a
+      // declined or failed one leaves the earlier mode as it was.
+      if (now.mode === 'boot') {
+        const result = await windowsBootAutostartService.requestDisable({
+          onSettled: (ok) => {
+            if (!ok) return;
+            try {
+              windowsAutostartService.setEnabled(mode === 'signin');
+            } catch (error) {
+              console.warn(`[autostart] the boot task is gone, but the sign-in entry could not be changed: ${error?.message || error}`);
+            }
+          },
+        });
+        return res.json({ ...(await windowsAutostartMergedState()), accepted: result.accepted });
       }
+      const accepted = true;
       windowsAutostartService.setEnabled(mode === 'signin');
       return res.json({ ...(await windowsAutostartMergedState()), accepted });
     } catch (error) {

package/server/services/oar-cli-helpers.mjs

@@ -66,7 +66,7 @@ export function describeRelayAddress({ config, lanAddress = null, wslNat = false
   return { url, lines, qrUrl, tunnelUrl };
 }
 
-const VALUE_OPTIONS = ['--port', '--migrate-from', '--to'];
+const VALUE_OPTIONS = ['--port', '--migrate-from', '--to', '--autostart'];
 const LAUNCHER_FLAGS = ['--install-extension', '--no-install-extension', '--migrate-from'];
 const COMMAND_OPTIONS = { '--setup': 'setup', '--start': 'start', '--stop': 'stop', '--status': 'status' };
 const CLI_COMMANDS = {
@@ -79,8 +79,10 @@ const CLI_COMMANDS = {
   doctor: {},
   help: {},
   version: {},
-  setup: { flags: ['--lan', '--local', '--new-token', '--defaults', '--start'], values: ['--port', '--migrate-from'] },
+  setup: { flags: ['--lan', '--local', '--new-token', '--defaults', '--start'], values: ['--port', '--migrate-from', '--autostart'] },
   service: { words: ['install', 'remove', 'status'] },
+  autostart: { words: ['signin', 'boot', 'off', 'status'], flags: ['--replace'] },
+  uninstall: { flags: ['--purge'] },
   update: { flags: ['--beta'], values: ['--to'] },
   copilot: { flags: ['--install-extension', '--no-install-extension'], values: ['--port', '--migrate-from'], forwards: true },
 };
@@ -95,10 +97,16 @@ export function usageText() {
     '  oar restart            Restart the relay (waits for running turns)',
     '  oar status             Is the relay running, on which port, as a service',
     '  oar url                Relay URL, with a QR code when a phone can reach it',
-    '  oar setup              Auth token, access and port; asks, or takes',
-    '                         [--port <port>] [--lan | --local] [--new-token] [--defaults] [--start]',
+    '  oar setup              Auth token, access, port and autostart; asks, or takes',
+    '                         [--port <port>] [--lan | --local] [--new-token] [--autostart signin|boot|off]',
+    '                         [--defaults] [--start]',
+    '  oar autostart signin | boot | off | status [--replace]',
+    '                         Start the relay at sign-in or at boot (Windows: boot asks for an admin once);',
+    '                         --replace replaces hand-made entries, keeping a copy',
     '  oar service install | remove | status',
     '                         Start the relay at login',
+    '  oar uninstall [--purge]',
+    '                         Remove autostart and the package; the data stays (--purge deletes it)',
     '  oar copilot [--port <port>] [--install-extension] [--no-install-extension] [-- gh copilot args...]',
     '                         Relay plus a Copilot terminal session',
     '  oar doctor             Check the install and the provider CLIs',

package/server/services/windows-autostart-service.mjs

@@ -191,6 +191,31 @@ export function readLauncherNodePath(script, serverPath) {
   return null;
 }
 
+/**
+ * The package folder of another OAR install a launcher starts (its Node line
+ * runs a `server\server.js` other than `packageRoot`'s), or null.
+ */
+export function otherInstallOf(script, packageRoot, pathImpl = path) {
+  const own = pathImpl.resolve(String(packageRoot || '')).toLowerCase();
+  for (const line of String(script == null ? '' : script).split(/\r?\n/)) {
+    const match = line.trimEnd().match(/^"[^"]+" "([^"]+)[\\/]server[\\/]server\.js"(?: & exit(?: \/b)?)?$/i);
+    if (match && pathImpl.resolve(match[1].replaceAll('%%', '%')).toLowerCase() !== own) return match[1].replaceAll('%%', '%');
+  }
+  return null;
+}
+
+/**
+ * Where a copy of `target` goes before `--replace` writes over or removes
+ * it: `<name>.bak` in `dir`, numbered when one is there already, so no
+ * earlier copy is lost.
+ */
+export function backupPathFor(target, dir, fsImpl = fs, pathImpl = path) {
+  const base = pathImpl.join(dir, `${pathImpl.basename(target)}.bak`);
+  let candidate = base;
+  for (let index = 2; fsImpl.existsSync(candidate); index += 1) candidate = `${base}-${index}`;
+  return candidate;
+}
+
 /**
  * Same launcher, whatever the line endings, trailing blanks and the length
  * of the padding. `ignoreCase` for telling whether a launcher is one an
@@ -346,13 +371,6 @@ export function createWindowsAutostartService({
     };
   }
 
-  function removeLegacyEntry() {
-    const target = legacyEntryPath();
-    if (!fsImpl.existsSync(target)) return false;
-    fsImpl.unlinkSync(target);
-    return true;
-  }
-
   const workingDirectory = () => resolveOarRoot(env, platform);
   const serverPath = () => pathImpl.join(pathImpl.resolve(String(packageRoot || '')), 'server', 'server.js');
 
@@ -418,7 +436,46 @@ export function createWindowsAutostartService({
     return changed;
   }
 
-  function setEnabled(enabled) {
+  /**
+   * Whether `script` is an entry OAR generates or generated for this install
+   * and its config (with whatever Node it runs). Anything else, an entry
+   * edited by hand or one of another install, is hand-made.
+   */
+  function isGenerated(script) {
+    const entryNodePath = readLauncherNodePath(script, serverPath());
+    if (!entryNodePath) return false;
+    const stateDirs = resolveRelayStateDirs({ packageRoot, env, platform, fsImpl, pathImpl });
+    return launcherScriptsMatch(script, buildScript({ stateDirs, nodePathOverride: entryNodePath }))
+      || buildEarlierWindowsAutostartScripts({
+        packageRoot, nodePath: entryNodePath, configPath, ...stateDirs, workingDirectory: workingDirectory(), pathImpl,
+      }).some((earlier) => launcherScriptsMatch(script, earlier, { ignoreCase: true }));
+  }
+
+  /**
+   * The sign-in entries there are, each `{ path, generated, otherInstall }`:
+   * `otherInstall` is the package folder of the other OAR install a
+   * hand-made entry starts (an entry left from a moved or second install).
+   */
+  function listEntries() {
+    if (!supported) return [];
+    return [entryPath(), legacyEntryPath()]
+      .filter((target) => fsImpl.existsSync(target))
+      .map((target) => {
+        const script = String(fsImpl.readFileSync(target, 'utf8'));
+        const generated = isGenerated(script);
+        return { path: target, generated, otherInstall: generated ? null : otherInstallOf(script, packageRoot, pathImpl) };
+      });
+  }
+
+  /**
+   * Switches the sign-in entry on or off. Only entries OAR generated are
+   * written over or removed: a hand-made one stays byte-identical and is
+   * returned in `kept`, and while one is there no second entry is added.
+   * `replace` (with `backupDir`, never inside the Startup folder, which
+   * would open the copy at sign-in) first moves each hand-made entry there
+   * as `<name>.bak`, listed in `backedUp`.
+   */
+  function setEnabled(enabled, { replace = false, backupDir = '' } = {}) {
     if (!supported) {
       throw new Error('Windows autostart is only available on Windows.');
     }
@@ -426,28 +483,43 @@ export function createWindowsAutostartService({
       throw new TypeError('Windows autostart enabled state must be a boolean.');
     }
 
-    const targetPath = entryPath();
-    const existed = fsImpl.existsSync(targetPath);
+    const backedUp = [];
+    if (replace) {
+      if (!String(backupDir || '').trim()) throw new Error('Replacing a hand-made entry needs a folder for its copy.');
+      for (const entry of listEntries().filter((listed) => !listed.generated)) {
+        fsImpl.mkdirSync(backupDir, { recursive: true });
+        const copy = backupPathFor(entry.path, backupDir, fsImpl, pathImpl);
+        fsImpl.copyFileSync(entry.path, copy);
+        fsImpl.unlinkSync(entry.path);
+        backedUp.push({ path: entry.path, backup: copy });
+      }
+    }
+    const entries = listEntries();
+    const kept = entries.filter((entry) => !entry.generated).map((entry) => entry.path);
+    const remove = (entry) => { fsImpl.unlinkSync(entry.path); return true; };
     if (!enabled) {
-      const removedLegacy = removeLegacyEntry();
-      if (existed) fsImpl.unlinkSync(targetPath);
-      return { ...getState(), changed: existed || removedLegacy };
+      const removed = entries.filter((entry) => entry.generated).map(remove);
+      return { ...getState(), changed: removed.length + backedUp.length > 0, kept, backedUp };
     }
+    if (kept.length) return { ...getState(), changed: false, kept, backedUp };
     // Enabling always converges on the one current filename; if only the
     // legacy entry existed, the current-name write below reports the change.
-    removeLegacyEntry();
+    entries.filter((entry) => entry.path === legacyEntryPath()).forEach(remove);
 
+    const targetPath = entryPath();
+    const existed = fsImpl.existsSync(targetPath);
     const current = existed ? String(fsImpl.readFileSync(targetPath, 'utf8')) : '';
     if (existed && launcherScriptsMatch(current, buildScript())) {
-      return { ...getState(), changed: false };
+      return { ...getState(), changed: backedUp.length > 0, kept, backedUp };
     }
 
     writeEntry(targetPath, buildScript({ coverBytes: Buffer.byteLength(current, 'utf8') }));
-    return { ...getState(), changed: true };
+    return { ...getState(), changed: true, kept, backedUp };
   }
 
   return {
     getState,
+    listEntries,
     setEnabled,
     refreshInstalledEntry,
   };