@yuriai/web 0.1.5 → 0.1.7

package/server/lib/opencode/config-entity-routes.test.js

@@ -495,6 +495,29 @@ describe('config entity agent metadata route', () => {
 describe('global raw configuration routes', () => {
   beforeEach(() => vi.stubEnv('OPENCODE_CONFIG', ''));
   afterEach(() => vi.unstubAllEnvs());
+  it('offers an editable JSONC template on a fresh machine and creates it only on save', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'yuri-global-config-'));
+    const configDirectory = path.join(root, 'opencode');
+    const app = express();
+    app.use(express.json());
+    registerConfigEntityRoutes(app, createDependencies(vi.fn(), configDirectory));
+    try {
+      const available = await request(app).get('/api/config/global').expect(200);
+      expect(available.body.targets).toEqual([{ target: 'opencode', fileName: 'opencode.jsonc' }]);
+      const template = await request(app).get('/api/config/global/opencode').expect(200);
+      expect(JSON.parse(template.body.content)).toEqual({ $schema: 'https://opencode.ai/config.json' });
+      await expect(fs.stat(configDirectory)).rejects.toMatchObject({ code: 'ENOENT' });
+      const content = '{\n  // first configuration\n  "model": "provider/model"\n}\n';
+      await request(app).put('/api/config/global/opencode').send({ content }).expect(200);
+      expect(await fs.readFile(path.join(configDirectory, 'opencode.jsonc'), 'utf8')).toBe(content);
+      const loaded = await request(app).get('/api/config/global/opencode').expect(200);
+      expect(loaded.body.content).toBe(content);
+      await request(app).get('/api/config/global/oh-my-openagent').expect(404);
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
   it('reads and validates the configured OpenCode and oh-my-opencode files', async () => {
     const app = express();
     app.use(express.json());

package/server/lib/opencode/ensure-cli.js

@@ -2,8 +2,11 @@ import { execFile, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { createOpenCodeUpdateDiscovery } from './update-discovery.js';
+import { configureOpenCodeTerminalPath } from './terminal-path.js';
 import {
   PINNED_OPENCODE2_VERSION,
+  compareOpenCode2Versions,
   isAcceptableOpenCode2HealthVersion,
   isOpenCode2VersionAtLeast,
   npmPackageForOpenCode2,
@@ -12,6 +15,7 @@ import {
 } from './opencode2-pin.js';
 
 const INSTALL_FETCH_TIMEOUT_MS = 30_000;
+const discoverLatestVersion = createOpenCodeUpdateDiscovery();
 
 export async function upgradeSelectedOpenCodeCli({ binaryPath, version, launchSpec, env = process.env, execFileImpl = execFile }) {
   if (launchSpec?.wrapperType === 'cmd-wrapper') {
@@ -55,6 +59,15 @@ export function installedOpenCode2BinaryPath(version = PINNED_OPENCODE2_VERSION,
   return path.join(dataDir, 'opencode-cli', version, openCodeBinaryName(options.platform));
 }
 
+export function installedOpenCode2BinaryCandidates(options = {}) {
+  const root = path.dirname(path.dirname(installedOpenCode2BinaryPath(undefined, options)));
+  let versions;
+  try { versions = fs.readdirSync(root).filter((name) => /^2\.\d+\.\d+$/.test(name)); }
+  catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  return versions.sort((a, b) => compareOpenCode2Versions(b, a))
+    .map((version) => installedOpenCode2BinaryPath(version, options));
+}
+
 export function readOpenCode2BinaryVersion(binaryPath, options = {}) {
   if (typeof binaryPath !== 'string' || !binaryPath.trim()) return '';
   const run = typeof options.spawnSync === 'function' ? options.spawnSync : spawnSync;
@@ -217,12 +230,16 @@ export async function installPinnedOpenCode2Cli(options = {}) {
   if (preparedVersion !== version) {
     throw new Error(`Installed opencode2 version mismatch: expected ${version}, got ${preparedVersion || 'unknown'}`);
   }
+  if (['opencode-path.sh', 'opencode-path.fish', 'opencode-path.windows'].some((name) => fs.existsSync(path.join(dataDir, name)))) {
+    try { configureOpenCodeTerminalPath(outputBinary, { ...options, dataDir }); }
+    catch (error) { console.warn('[OpenCode] Terminal PATH refresh failed:', error.message); }
+  }
   return outputBinary;
 }
 
 /**
- * Reuse any discovered acceptable 2.x CLI. Install the pin only when nothing
- * usable is already installed (global PATH, explicit override, or cache).
+ * Reuse any discovered acceptable 2.x CLI. Fresh installs resolve stable 2.x;
+ * an explicit pin or an unavailable registry uses the tested version instead.
  */
 export async function ensurePinnedOpenCode2Cli(input = {}) {
   const pin = input.pin || PINNED_OPENCODE2_VERSION;
@@ -232,18 +249,29 @@ export async function ensurePinnedOpenCode2Cli(input = {}) {
     ? input.readVersion
     : (binaryPath) => readOpenCode2BinaryVersion(binaryPath, input);
   const install = typeof input.install === 'function' ? input.install : installPinnedOpenCode2Cli;
+  const finish = (result) => {
+    const root = path.dirname(path.dirname(installedOpenCode2BinaryPath(pin, input)));
+    const relative = path.relative(root, result.path);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      try { configureOpenCodeTerminalPath(result.path, input); }
+      catch (error) { console.warn('[OpenCode] CLI is available in Yuri, but terminal PATH setup failed:', error.message); }
+    }
+    return result;
+  };
 
   if (discoveredPath) {
     const version = readVersion(discoveredPath);
     if (isAcceptableOpenCode2HealthVersion(version)) {
-      return { path: discoveredPath, version, source: 'discovered', installed: false };
+      return finish({ path: discoveredPath, version, source: 'discovered', installed: false });
     }
   }
 
-  const cached = installedOpenCode2BinaryPath(pin, input);
-  const cachedVersion = readVersion(cached);
-  if (cachedVersion === pin || isOpenCode2VersionAtLeast(cachedVersion, pin)) {
-    return { path: cached, version: cachedVersion, source: 'installed', installed: false };
+  const candidates = [...new Set([...installedOpenCode2BinaryCandidates(input), installedOpenCode2BinaryPath(pin, input)])];
+  for (const cached of candidates) {
+    const cachedVersion = readVersion(cached);
+    if (isOpenCode2VersionAtLeast(cachedVersion, pin)) {
+      return finish({ path: cached, version: cachedVersion, source: 'installed', installed: false });
+    }
   }
 
   if (!autoInstall) {
@@ -254,10 +282,19 @@ export async function ensurePinnedOpenCode2Cli(input = {}) {
     throw error;
   }
 
-  const installedPath = await install({ ...input, version: pin });
+  let target = pin;
+  if (!input.pin) {
+    try {
+      const latest = await (input.resolveLatestVersion || discoverLatestVersion)();
+      if (/^2\.\d+\.\d+$/.test(latest) && isOpenCode2VersionAtLeast(latest, pin)) target = latest;
+    } catch {
+      console.warn('[OpenCode] Latest version lookup failed; using the tested fallback version.');
+    }
+  }
+  const installedPath = await install({ ...input, version: target });
   const version = readVersion(installedPath);
-  if (version !== pin) {
-    throw new Error(`Installed OpenCode version mismatch: expected ${pin}, got ${version || 'unknown'}`);
+  if (version !== target) {
+    throw new Error(`Installed OpenCode version mismatch: expected ${target}, got ${version || 'unknown'}`);
   }
-  return { path: installedPath, version, source: 'installed', installed: true };
+  return finish({ path: installedPath, version, source: 'installed', installed: true });
 }

package/server/lib/opencode/ensure-cli.test.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import { PINNED_OPENCODE2_VERSION } from './opencode2-pin.js';
+import { configureOpenCodeTerminalPath } from './terminal-path.js';
 import {
   ensurePinnedOpenCode2Cli,
   installedOpenCode2BinaryPath,
@@ -11,6 +12,8 @@ import {
   upgradeSelectedOpenCodeCli,
 } from './ensure-cli.js';
 
+vi.mock('./terminal-path.js', () => ({ configureOpenCodeTerminalPath: vi.fn() }));
+
 const tempDirs = [];
 
 const createTempDir = (prefix) => {
@@ -20,12 +23,60 @@ const createTempDir = (prefix) => {
 };
 
 afterEach(() => {
+  vi.clearAllMocks();
   for (const dir of tempDirs.splice(0)) {
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
 
 describe('ensurePinnedOpenCode2Cli', () => {
+  it('resolves the latest stable 2.x for a fresh installation', async () => {
+    const dataDir = createTempDir('yuri-latest-cli-');
+    const installed = path.join(dataDir, 'opencode-cli', '2.9.1', 'opencode');
+    const install = vi.fn(async () => installed);
+    const result = await ensurePinnedOpenCode2Cli({ dataDir,
+      resolveLatestVersion: async () => '2.9.1', install,
+      readVersion: (file) => file === installed ? '2.9.1' : '',
+    });
+    expect(install).toHaveBeenCalledWith(expect.objectContaining({ version: '2.9.1' }));
+    expect(result.version).toBe('2.9.1');
+    expect(configureOpenCodeTerminalPath).toHaveBeenCalledWith(installed, expect.objectContaining({ dataDir }));
+  });
+
+  it.each(['1.18.4', '3.0.0', '2.9.1-beta.1', '2.0.1'])('never chooses an unsuitable fresh-install target %s', async (latest) => {
+    const install = vi.fn(async () => '/installed/opencode');
+    await ensurePinnedOpenCode2Cli({ dataDir: createTempDir('yuri-invalid-cli-'), install,
+      resolveLatestVersion: async () => latest,
+      readVersion: (file) => file === '/installed/opencode' ? PINNED_OPENCODE2_VERSION : '',
+    });
+    expect(install).toHaveBeenCalledWith(expect.objectContaining({ version: PINNED_OPENCODE2_VERSION }));
+  });
+
+  it('reuses the newest verified cache offline instead of reinstalling the pin', async () => {
+    const dataDir = createTempDir('yuri-new-cache-');
+    for (const version of [PINNED_OPENCODE2_VERSION, '2.9.1', '2.10.0']) {
+      fs.mkdirSync(path.join(dataDir, 'opencode-cli', version), { recursive: true });
+    }
+    const latest = installedOpenCode2BinaryPath('2.10.0', { dataDir });
+    const resolveLatestVersion = vi.fn();
+    const result = await ensurePinnedOpenCode2Cli({ dataDir, resolveLatestVersion,
+      readVersion: (file) => path.basename(path.dirname(file)),
+      install: async () => { throw new Error('must not install'); },
+    });
+    expect(result).toMatchObject({ path: latest, version: '2.10.0', installed: false });
+    expect(resolveLatestVersion).not.toHaveBeenCalled();
+  });
+
+  it('uses the tested pin when the registry is unavailable', async () => {
+    const dataDir = createTempDir('yuri-offline-cli-');
+    const install = vi.fn(async () => '/installed/opencode');
+    await ensurePinnedOpenCode2Cli({ dataDir, install,
+      resolveLatestVersion: async () => { throw new Error('offline'); },
+      readVersion: (file) => file === '/installed/opencode' ? PINNED_OPENCODE2_VERSION : '',
+    });
+    expect(install).toHaveBeenCalledWith(expect.objectContaining({ version: PINNED_OPENCODE2_VERSION }));
+  });
+
   it('runs upgrade through the selected launch target and preserves its CLI entry path', async () => {
     const dir = createTempDir('yuri-upgrade-cli-');
     const script = path.join(dir, 'cli.cjs');
@@ -86,6 +137,7 @@ describe('ensurePinnedOpenCode2Cli', () => {
     });
     expect(result.source).toBe('discovered');
     expect(result.path).toBe('/opt/old-opencode');
+    expect(configureOpenCodeTerminalPath).not.toHaveBeenCalled();
   });
 
   it('installs the pin only when no usable 2.x binary is present', async () => {

package/server/lib/opencode/env-runtime.js

@@ -3,8 +3,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { mergePathValues } from './path-utils.js';
-import { PINNED_OPENCODE2_VERSION, isAcceptableOpenCode2HealthVersion, isOpenCode1xVersion } from './opencode2-pin.js';
-import { ensurePinnedOpenCode2Cli, installedOpenCode2BinaryPath, readOpenCode2BinaryVersion, upgradeSelectedOpenCodeCli } from './ensure-cli.js';
+import { isAcceptableOpenCode2HealthVersion, isOpenCode1xVersion } from './opencode2-pin.js';
+import { ensurePinnedOpenCode2Cli, installedOpenCode2BinaryCandidates, readOpenCode2BinaryVersion, upgradeSelectedOpenCodeCli } from './ensure-cli.js';
 
 export const createOpenCodeEnvRuntime = (deps) => {
   const {
@@ -280,12 +280,12 @@ export const createOpenCodeEnvRuntime = (deps) => {
   };
 
   const resolveInstalledOpenCodeCliPath = () => {
-    const installed = installedOpenCode2BinaryPath(PINNED_OPENCODE2_VERSION, {
+    const installed = installedOpenCode2BinaryCandidates({
       env: process.env,
       homedir: resolveHomeDir,
       platform: process.platform,
-    });
-    if (isExecutable(installed) && !isWindowsOpenCodeDesktopAppPath(installed)) {
+    }).find((binary) => isExecutable(binary) && !isWindowsOpenCodeDesktopAppPath(binary));
+    if (installed) {
       clearWslOpencodeResolution();
       state.resolvedOpencodeBinarySource = 'installed';
       return installed;

package/server/lib/opencode/feature-routes-runtime.js

@@ -319,7 +319,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       },
       readModelPreferences: async () => {
         const settings = await readSettingsFromDiskStrict();
-        return { favoriteModels: settings.favoriteModels, recentModels: settings.recentModels };
+        return { defaultModel: settings.defaultModel, defaultVariant: settings.defaultVariant, favoriteModels: settings.favoriteModels, recentModels: settings.recentModels };
       },
       listScheduledTasks: (projectID) => projectConfigRuntime.listScheduledTasks(projectID),
       sessionIndexService,

package/server/lib/opencode/terminal-path.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export function configureOpenCodeTerminalPath(binaryPath, options = {}) {
+  const env = options.env || process.env;
+  const home = typeof options.homedir === 'function' ? options.homedir() : options.homedir || os.homedir();
+  const platform = options.platform || process.platform;
+  const dataDir = options.dataDir || env.YURI_DATA_DIR || path.join(home, '.config', 'yuri');
+  const directory = path.dirname(binaryPath);
+  if (platform === 'win32') {
+    const run = options.spawnSync || spawnSync;
+    const result = run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `
+$ErrorActionPreference = 'Stop'
+$root = $env:YURI_CLI_CACHE_ROOT.TrimEnd('\\') + '\\'
+$entries = @([Environment]::GetEnvironmentVariable('Path', 'User') -split ';' | Where-Object { $_ -and -not $_.StartsWith($root, [StringComparison]::OrdinalIgnoreCase) })
+$value = (@($env:YURI_CLI_BIN_DIR) + $entries) -join ';'
+[Environment]::SetEnvironmentVariable('Path', $value, 'User')
+Add-Type -TypeDefinition 'using System; using System.Runtime.InteropServices; public static class YuriEnvironment { [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)] public static extern IntPtr SendMessageTimeout(IntPtr hWnd, uint msg, UIntPtr wParam, string lParam, uint flags, uint timeout, out UIntPtr result); }'
+$result = [UIntPtr]::Zero
+[void][YuriEnvironment]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$result)
+`], { env: { ...env, YURI_CLI_CACHE_ROOT: path.join(dataDir, 'opencode-cli'), YURI_CLI_BIN_DIR: directory },
+      encoding: 'utf8', timeout: 15_000, windowsHide: true });
+    if (result.status !== 0) throw new Error('Cannot add OpenCode to the Windows user PATH');
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(path.join(dataDir, 'opencode-path.windows'), directory);
+    return;
+  }
+
+  const shell = env.SHELL || (platform === 'darwin' ? '/bin/zsh' : '/bin/sh');
+  const kind = path.basename(shell);
+  const files = [];
+  if (kind === 'zsh') {
+    const run = options.spawnSync || spawnSync;
+    const probe = run(shell, ['-c', 'printf "%s" "${ZDOTDIR:-$HOME}"'], { env: { ...env, HOME: home }, encoding: 'utf8', timeout: 5000 });
+    if (probe.status !== 0 || !path.isAbsolute(probe.stdout || '')) throw new Error('Cannot resolve zsh startup directory');
+    files.push(path.join(probe.stdout, '.zprofile'), path.join(probe.stdout, '.zshrc'));
+  } else if (kind === 'bash') {
+    files.push(path.join(home, '.bashrc'));
+    files.push(['.bash_profile', '.bash_login', '.profile'].map((name) => path.join(home, name)).find((file) => fs.existsSync(file)) || path.join(home, '.profile'));
+  } else if (['sh', 'dash', 'ksh'].includes(kind)) {
+    files.push(path.join(home, '.profile'));
+  } else if (kind === 'fish') {
+    files.push(path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'fish', 'config.fish'));
+  } else {
+    throw new Error(`Cannot configure OpenCode PATH for shell ${kind}`);
+  }
+
+  const quote = kind === 'fish'
+    ? (value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+    : (value) => `'${value.replace(/'/g, "'\\''")}'`;
+  const envFile = path.join(dataDir, kind === 'fish' ? 'opencode-path.fish' : 'opencode-path.sh');
+  const content = kind === 'fish'
+    ? `contains -- ${quote(directory)} $PATH; or set -gx PATH ${quote(directory)} $PATH\n`
+    : `case ":$PATH:" in *${quote(`:${directory}:`)}*) ;; *) export PATH=${quote(directory)}:"$PATH" ;; esac\n`;
+  fs.mkdirSync(path.dirname(envFile), { recursive: true });
+  fs.writeFileSync(`${envFile}.tmp`, content, { mode: 0o600 });
+  fs.renameSync(`${envFile}.tmp`, envFile);
+  const line = `${kind === 'fish' ? 'source' : '.'} ${quote(envFile)} # Yuri OpenCode CLI PATH`;
+  for (const file of files) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    let existing = '';
+    try { existing = fs.readFileSync(file, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (!existing.split('\n').includes(line)) fs.appendFileSync(file, `\n${line}\n`);
+  }
+}

package/server/lib/opencode/terminal-path.test.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { afterEach, expect, test, vi } from 'vitest';
+import { ensurePinnedOpenCode2Cli, installPinnedOpenCode2Cli } from './ensure-cli.js';
+import { configureOpenCodeTerminalPath } from './terminal-path.js';
+
+const roots = [];
+afterEach(() => { for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true }); });
+
+test.each(['/bin/bash', '/bin/zsh'].filter((shell) => fs.existsSync(shell)))('fresh installation is available in %s, preserves rc content and is idempotent', async (shell) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "yuri cli's "));
+  roots.push(home);
+  const dataDir = path.join(home, '.config', 'yuri');
+  const binary = path.join(dataDir, 'opencode-cli', '2.9.1', 'opencode');
+  const zdotdir = path.join(home, 'zsh');
+  fs.mkdirSync(zdotdir);
+  const rc = shell.endsWith('zsh') ? path.join(zdotdir, '.zshrc') : path.join(home, '.bashrc');
+  fs.writeFileSync(rc, '# user configuration\n');
+  const options = { pin: '2.9.1', dataDir, homedir: () => home,
+    env: { HOME: home, ZDOTDIR: zdotdir, SHELL: shell, PATH: '/usr/bin:/bin' },
+    install: vi.fn(async () => {
+      fs.mkdirSync(path.dirname(binary), { recursive: true });
+      fs.writeFileSync(binary, '#!/bin/sh\nprintf "2.9.1\\n"\n', { mode: 0o755 });
+      return binary;
+    }),
+  };
+  await ensurePinnedOpenCode2Cli(options);
+  const first = fs.readFileSync(rc, 'utf8');
+  expect(first).toContain('# user configuration\n');
+  const result = spawnSync(shell, ['-ic', 'opencode --version'], {
+    env: options.env, encoding: 'utf8', timeout: 5000,
+  });
+  expect(result.status, result.stderr).toBe(0);
+  expect(result.stdout.trim()).toBe('2.9.1');
+  await ensurePinnedOpenCode2Cli(options);
+  expect(fs.readFileSync(rc, 'utf8')).toBe(first);
+  expect(options.install).toHaveBeenCalledTimes(1);
+
+  await installPinnedOpenCode2Cli({ ...options, version: '2.10.0',
+    fetch: async (url) => String(url).endsWith('/2.10.0')
+      ? Response.json({ dist: { tarball: 'https://example.com/cli.tgz' } }) : new Response('fixture'),
+    extract: async (_archive, target) => {
+      fs.mkdirSync(target, { recursive: true });
+      fs.writeFileSync(path.join(target, 'opencode'), '#!/bin/sh\nprintf "2.10.0\\n"\n');
+    },
+  });
+  const upgraded = spawnSync(shell, ['-ic', 'opencode --version'], { env: options.env, encoding: 'utf8', timeout: 5000 });
+  expect(upgraded.status, upgraded.stderr).toBe(0);
+  expect(upgraded.stdout.trim()).toBe('2.10.0');
+  expect(fs.readFileSync(rc, 'utf8')).toBe(first);
+});
+
+test('Windows updates only user PATH using a hidden first-level process and reports failure', () => {
+  const spawn = vi.fn(() => ({ status: 0 }));
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'yuri-win-path-'));
+  roots.push(dataDir);
+  const binary = path.join(dataDir, 'opencode-cli', '2.9.1', 'opencode.exe');
+  const options = { platform: 'win32', dataDir, homedir: dataDir, spawnSync: spawn, env: {} };
+  configureOpenCodeTerminalPath(binary, options);
+  expect(spawn).toHaveBeenCalledWith('powershell.exe', expect.arrayContaining(['-NoProfile', '-NonInteractive']), expect.objectContaining({
+    windowsHide: true, env: expect.objectContaining({ YURI_CLI_BIN_DIR: path.dirname(binary) }),
+  }));
+  expect(spawn.mock.calls[0][1].at(-1)).toContain("GetEnvironmentVariable('Path', 'User')");
+  spawn.mockReturnValue({ status: 1 });
+  expect(() => configureOpenCodeTerminalPath(binary, options)).toThrow('Windows user PATH');
+});

package/server/lib/relay/DOCUMENTATION.md

@@ -18,6 +18,8 @@ Traffic is modeled as three stacked layers. The relay understands only Layer 1;
 
 ## Entrypoints and structure
 
+The Host and pairing UI default to `wss://relay.openchamber.dev/ws`. Host endpoint precedence is `YURI_RELAY_URL`, saved `privateRelay.relayUrl`, then the product default. Existing saved pairing endpoints remain authoritative for reconnects.
+
 Host side (`packages/web/server/lib/relay/`):
 - `service.js` — thin entrypoint: relay config (enabled flag + endpoints), the management routes (`GET/POST /api/yuri/relay/{status,enable,disable}`, `POST /api/yuri/relay/endpoints`), a `getPairingCandidate()` accessor (the relay transport candidate folded into pairing-v2 links when enabled, consumed by the pairing-session route in `core-routes.js`), and lifecycle wiring. **Multi-relay:** `settings.privateRelay = { enabled, relayUrl, extraRelayUrls }` — the host dials EVERY configured endpoint simultaneously with one identity (same serverId); clients treat `serverId + relayUrl` as the instance identity, so the same machine exposed via two domains appears as two separately named instances. The primary (`relayUrl`) owns push registration and stays the default pairing candidate. A pairing link created for an endpoint the host does not have yet APPENDS it as an extra endpoint instead of replacing the primary, so devices paired over the old domain keep working. `POST /relay/endpoints` (owner session / `desktop-local` only) replaces the extra-endpoint list wholesale and starts/stops host connections incrementally. Paired desktop operators may also add an endpoint through pairing creation. Host lifecycle is gated by `isRelayHostRuntime()` (`desktop` or `ssh-remote`): other runtimes (`bun run dev`, `dev:web:hmr`, ordinary CLI `serve`, VS Code, plain `node server`) report `state: 'unavailable'`, refuse `/relay/enable`, `/relay/disable`, `/relay/endpoints`, and relay pairing with 403, never mint a relay identity, never advertise `relayAvailable`, and never call `startRelayHost`. Direct `node server/index.js` forces `YURI_RUNTIME=web` unless it is already `ssh-remote`, so a leftover desktop env cannot open the host-control socket. On host runtimes, started from `packages/web/server/index.js` when demand/opt-in enables the relay. Desktop auto-clears `privateRelay.enabled` when demand drops; `ssh-remote` keeps an explicit opt-in (e.g. `yuri serve --relay-host`) sticky until disabled. The relay endpoint has no hosted default and must be configured in settings or pinned via the `YURI_RELAY_URL` env var; when set it overrides the stored setting for the host connection, the pairing candidate, and status, so paired clients inherit the endpoint automatically. Endpoint identity is scheme/host/path only: accepted schemes are `ws://` and `wss://`; URLs with userinfo are rejected (no silent default fallback); query and fragment are stripped before persistence and pairing candidates. Custom endpoint persistence and Host control-connection switching are explicit authenticated management actions. Pairing creation with `relayUrl` requires an owner UI session, local `desktop-local` shell client, or paired `desktop` operator; `/relay/enable` follows its API auth gate. `derivePushSendUrlFromRelayUrl` maps a canonical Relay `wss://`/`ws://` URL to the same host's `https://`/`http://` `/v1/push/send` path (register is `/v1/push/register-token`); `YURI_PUSH_RELAY_URL` on the Host overrides that derivation. The isolated Push process lives in `packages/relay-server/src/push/` and does not share Layer 1 credentials or tunnel state.
 - `identity.js` — the host's stable identity: the long-lived signing keypair (shared with the push relay, defines the routing id) plus a long-lived encryption keypair (the E2EE trust anchor). Reused across restarts; never rotated implicitly.

package/server/lib/relay/service.js

@@ -23,7 +23,7 @@ import express from 'express';
 import { createRelayIdentityRuntime } from './identity.js';
 import { startRelayHost } from './host-client.js';
 
-export const DEFAULT_RELAY_URL = '';
+export const DEFAULT_RELAY_URL = 'wss://relay.openchamber.dev/ws';
 
 export const RELAY_HOST_DESKTOP_ONLY_MESSAGE =
   'Relay host is only available in the Yuri desktop app or an SSH-managed remote server';

package/server/lib/relay/service.test.js

@@ -33,7 +33,7 @@ vi.mock('./host-client.js', () => ({
 
 import {
   createRelayService,
-  DEFAULT_RELAY_URL as UNCONFIGURED_RELAY_URL,
+  DEFAULT_RELAY_URL as PRODUCT_RELAY_URL,
   derivePushSendUrlFromRelayUrl,
   isRelayHostRuntime,
   RELAY_HOST_DESKTOP_ONLY_MESSAGE,
@@ -91,8 +91,8 @@ describe('resolveEffectiveRelayUrl', () => {
   });
 
   it('prefers a valid env URL, then settings, then the default', () => {
-    expect(resolveEffectiveRelayUrl()).toBe(UNCONFIGURED_RELAY_URL);
-    expect(UNCONFIGURED_RELAY_URL).toBe('');
+    expect(resolveEffectiveRelayUrl()).toBe(PRODUCT_RELAY_URL);
+    expect(PRODUCT_RELAY_URL).toBe('wss://relay.openchamber.dev/ws');
     expect(
       resolveEffectiveRelayUrl({
         settings: { privateRelay: { relayUrl: 'wss://settings.example/ws' } },