@vantran-se/openchamber-web 2.0.3 → 2.0.5

package/server/lib/opencode/shared-service-runtime.js

@@ -0,0 +1,155 @@
+import { access } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { Service } from '@opencode/client/service';
+import { z } from 'zod';
+
+import { isSupportedOpenCodeVersion, readOpenCodeInfo } from './compatibility.js';
+
+const endpointSchema = z.object({
+  url: z.string(),
+  auth: z.object({
+    type: z.literal('basic'),
+    username: z.string(),
+    password: z.string(),
+  }).optional(),
+});
+
+const createConnectionError = (code, message, details = {}, cause) => {
+  const error = new Error(message, cause === undefined ? undefined : { cause });
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+};
+
+const unavailableError = (message, cause) => createConnectionError(
+  'OPENCODE_SERVICE_UNAVAILABLE',
+  message,
+  {},
+  cause,
+);
+
+const normalizeEndpoint = (endpoint) => {
+  const parsed = endpointSchema.safeParse(endpoint);
+  if (!parsed.success) {
+    throw unavailableError('OpenCode shared service did not return an endpoint');
+  }
+
+  let url;
+  try {
+    url = new URL(parsed.data.url);
+  } catch (cause) {
+    throw unavailableError('OpenCode shared service returned an invalid URL', cause);
+  }
+  if ((url.protocol !== 'http:' && url.protocol !== 'https:') || !url.hostname) {
+    throw unavailableError('OpenCode shared service returned an unsupported URL');
+  }
+
+  return { ...parsed.data, url: url.origin };
+};
+
+const defaultRegistrationFile = () => join(
+  process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'),
+  'opencode',
+  'service.json',
+);
+
+const registrationExists = async (options = {}) => {
+  try {
+    await access(options.file ?? defaultRegistrationFile());
+    return true;
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false;
+    throw error;
+  }
+};
+
+export const createSharedOpenCodeServiceRuntime = ({
+  service = Service,
+  fetchImpl = fetch,
+  ensureOptions,
+  readInfo = readOpenCodeInfo,
+  isSupportedVersion = isSupportedOpenCodeVersion,
+  hasRegistration = registrationExists,
+}) => {
+  let activeConnection = null;
+
+  const resolveEndpoint = async () => {
+    let discovered;
+    try {
+      discovered = await service.discover(ensureOptions);
+    } catch (cause) {
+      throw unavailableError('Could not discover the OpenCode shared service', cause);
+    }
+    if (discovered) return normalizeEndpoint(discovered);
+
+    try {
+      if (await hasRegistration(ensureOptions)) {
+        throw unavailableError(
+          'An incompatible or unhealthy OpenCode shared service is already registered',
+        );
+      }
+    } catch (cause) {
+      if (cause?.code === 'OPENCODE_SERVICE_UNAVAILABLE') throw cause;
+      throw unavailableError('Could not inspect the OpenCode shared service registration', cause);
+    }
+    try {
+      return normalizeEndpoint(await service.ensure(ensureOptions));
+    } catch (cause) {
+      if (cause?.code === 'OPENCODE_SERVICE_UNAVAILABLE') throw cause;
+      throw unavailableError('Could not start the OpenCode shared service', cause);
+    }
+  };
+
+  const probe = async (endpoint) => {
+    let headers;
+    try {
+      headers = { ...(service.headers(endpoint) ?? {}) };
+    } catch (cause) {
+      throw unavailableError('Could not authenticate with the OpenCode shared service', cause);
+    }
+    let info;
+    try {
+      const response = await fetchImpl(new URL('/api/info', endpoint.url), {
+        headers: { Accept: 'application/json', ...headers },
+      });
+      info = await readInfo(response);
+    } catch (cause) {
+      throw unavailableError('Could not reach the OpenCode shared service', cause);
+    }
+    if (!info) {
+      throw unavailableError('OpenCode shared service did not return valid service information');
+    }
+    if (!isSupportedVersion(info.version)) {
+      throw createConnectionError(
+        'OPENCODE_INCOMPATIBLE',
+        `OpenCode shared service version ${info.version} is incompatible`,
+        { foundVersion: info.version },
+      );
+    }
+
+    return {
+      kind: 'shared-local',
+      endpoint,
+      version: info.version,
+    };
+  };
+
+  const establishConnection = async () => {
+    const replacement = await probe(await resolveEndpoint());
+    activeConnection = replacement;
+    return replacement;
+  };
+
+  return {
+    connect: establishConnection,
+    recover: establishConnection,
+    getConnection: () => activeConnection,
+    getBaseUrl: () => activeConnection?.endpoint.url ?? null,
+    getHeaders: () => activeConnection ? { ...(service.headers(activeConnection.endpoint) ?? {}) } : {},
+    dispose: async () => {
+      activeConnection = null;
+    },
+  };
+};

package/server/lib/opencode/shared-service-runtime.test.js

@@ -0,0 +1,180 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSharedOpenCodeServiceRuntime } from './shared-service-runtime.js';
+
+const endpointA = {
+  url: 'http://127.0.0.1:4096',
+  auth: { type: 'basic', username: 'opencode', password: 'original' },
+};
+const endpointB = {
+  url: 'http://127.0.0.1:5096',
+  auth: { type: 'basic', username: 'opencode', password: 'replacement' },
+};
+
+const createRuntime = ({
+  discover = vi.fn().mockResolvedValue(endpointA),
+  ensure = vi.fn(),
+  stop = vi.fn(),
+  headers = vi.fn((endpoint) => endpoint.auth
+    ? { authorization: `Basic ${endpoint.auth.password}` }
+    : undefined),
+  fetchImpl = vi.fn().mockResolvedValue(Response.json({ version: '2.0.15' })),
+  infoVersion,
+  readInfo = async (response) => infoVersion === undefined
+    ? response.json()
+    : { version: infoVersion },
+  isSupportedVersion = (version) => version === '2.0.15',
+  ensureOptions = { command: ['opencode', 'serve', '--service'] },
+  hasRegistration = vi.fn().mockResolvedValue(false),
+} = {}) => createSharedOpenCodeServiceRuntime({
+  service: { discover, ensure, stop, headers },
+  fetchImpl,
+  ensureOptions,
+  readInfo,
+  isSupportedVersion,
+  hasRegistration,
+});
+
+describe('shared OpenCode service runtime', () => {
+  it('uses a compatible discovered service without ensuring another one', async () => {
+    const discover = vi.fn().mockResolvedValue(endpointA);
+    const ensure = vi.fn();
+    const runtime = createRuntime({ discover, ensure, infoVersion: '2.0.15' });
+
+    await expect(runtime.connect()).resolves.toMatchObject({
+      kind: 'shared-local',
+      endpoint: endpointA,
+      version: '2.0.15',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('rejects an incompatible discovered service without replacing it', async () => {
+    const discover = vi.fn().mockResolvedValue(endpointA);
+    const ensure = vi.fn();
+    const runtime = createRuntime({ discover, ensure, infoVersion: '1.99.0' });
+
+    await expect(runtime.connect()).rejects.toMatchObject({
+      code: 'OPENCODE_INCOMPATIBLE',
+      foundVersion: '1.99.0',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('refuses to ensure when discovery hides an existing incompatible or unhealthy registration', async () => {
+    const discover = vi.fn().mockResolvedValue(undefined);
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      discover,
+      ensure,
+      hasRegistration: vi.fn().mockResolvedValue(true),
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({
+      code: 'OPENCODE_SERVICE_UNAVAILABLE',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('ensures a service only when discovery returns no endpoint', async () => {
+    const discover = vi.fn().mockResolvedValue(undefined);
+    const ensure = vi.fn().mockResolvedValue(endpointA);
+    const runtime = createRuntime({ discover, ensure, infoVersion: '2.0.15' });
+
+    await expect(runtime.connect()).resolves.toMatchObject({ endpoint: endpointA });
+    expect(ensure).toHaveBeenCalledTimes(1);
+  });
+
+  it('refreshes URL and auth when recovery discovers a replacement endpoint', async () => {
+    const discover = vi.fn()
+      .mockResolvedValueOnce(endpointA)
+      .mockResolvedValueOnce(endpointB);
+    const runtime = createRuntime({ discover, infoVersion: '2.0.15' });
+
+    await runtime.connect();
+    await runtime.recover();
+
+    expect(runtime.getBaseUrl()).toBe(endpointB.url);
+    expect(runtime.getHeaders()).toEqual({ authorization: 'Basic replacement' });
+  });
+
+  it('keeps the active connection when a replacement is incompatible', async () => {
+    const discover = vi.fn()
+      .mockResolvedValueOnce(endpointA)
+      .mockResolvedValueOnce(endpointB);
+    const readInfo = vi.fn()
+      .mockResolvedValueOnce({ version: '2.0.15' })
+      .mockResolvedValueOnce({ version: '1.99.0' });
+    const runtime = createRuntime({ discover, readInfo });
+
+    await runtime.connect();
+    await expect(runtime.recover()).rejects.toMatchObject({ code: 'OPENCODE_INCOMPATIBLE' });
+
+    expect(runtime.getBaseUrl()).toBe(endpointA.url);
+    expect(runtime.getHeaders()).toEqual({ authorization: 'Basic original' });
+  });
+
+  it('dispose does not stop the shared service', async () => {
+    const stop = vi.fn();
+    const runtime = createRuntime({ stop, infoVersion: '2.0.15' });
+    await runtime.connect();
+    await runtime.dispose();
+    expect(stop).not.toHaveBeenCalled();
+    expect(runtime.getConnection()).toBeNull();
+  });
+
+  it.each([
+    [undefined],
+    [{}],
+    [{ url: '' }],
+    [{ url: 'file:///tmp/opencode.sock' }],
+    [{ url: 'not a url' }],
+  ])('rejects a malformed endpoint (%j)', async (endpoint) => {
+    const runtime = createRuntime({ discover: vi.fn().mockResolvedValue(endpoint) });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+  });
+
+  it('reports an authenticated service as unavailable when /api/info returns 401', async () => {
+    const runtime = createRuntime({
+      fetchImpl: vi.fn().mockResolvedValue(new Response(null, { status: 401 })),
+      readInfo: async () => null,
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+  });
+
+  it('reports discovery failures as unavailable without ensuring a replacement', async () => {
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      discover: vi.fn().mockRejectedValue(new Error('registration unavailable')),
+      ensure,
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('reports an unreachable discovered endpoint as unavailable without ensuring a replacement', async () => {
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      ensure,
+      fetchImpl: vi.fn().mockRejectedValue(new Error('connection refused')),
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('uses empty headers when Service.headers returns undefined', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(Response.json({ version: '2.0.15' }));
+    const runtime = createRuntime({ headers: vi.fn().mockReturnValue(undefined), fetchImpl });
+
+    await runtime.connect();
+
+    expect(runtime.getHeaders()).toEqual({});
+    expect(fetchImpl).toHaveBeenCalledWith(new URL(`${endpointA.url}/api/info`), {
+      headers: { Accept: 'application/json' },
+    });
+  });
+});

package/server/lib/opencode/shared.js

@@ -280,11 +280,16 @@ function readConfigLayer(filePath) {
 function readConfigLayers(workingDirectory) {
   const { userPaths, projectPath, customPath } = getConfigPaths(workingDirectory);
   const userPath = getPrimaryUserConfigPath(userPaths);
+  // OpenCode loads every global config file in order, so an `opencode.jsonc`
+  // next to `opencode.json` overrides it. New entries still go to the primary
+  // file; entries found in the override are edited where they live.
+  const userOverridePath = userPaths.find((candidate) => candidate !== userPath && fs.existsSync(candidate)) ?? null;
   const userLayer = readConfigLayer(userPath);
+  const userOverrideLayer = readConfigLayer(userOverridePath);
   const projectLayer = readConfigLayer(projectPath);
   const customLayer = readConfigLayer(customPath);
   const mergedConfig = mergeConfigs(
-    mergeConfigs(userLayer.config, projectLayer.config),
+    mergeConfigs(mergeConfigs(userLayer.config, userOverrideLayer.config), projectLayer.config),
     customLayer.config,
   );
 
@@ -292,6 +297,9 @@ function readConfigLayers(workingDirectory) {
   if (userLayer.error) {
     layerErrors.push({ path: userPath, code: userLayer.error.code, message: userLayer.error.message });
   }
+  if (userOverrideLayer.error && userOverridePath) {
+    layerErrors.push({ path: userOverridePath, code: userOverrideLayer.error.code, message: userOverrideLayer.error.message });
+  }
   if (projectLayer.error && projectPath) {
     layerErrors.push({ path: projectPath, code: projectLayer.error.code, message: projectLayer.error.message });
   }
@@ -301,10 +309,11 @@ function readConfigLayers(workingDirectory) {
 
   return {
     userConfig: userLayer.config,
+    userOverrideConfig: userOverrideLayer.config,
     projectConfig: projectLayer.config,
     customConfig: customLayer.config,
     mergedConfig,
-    paths: { userPath, projectPath, customPath },
+    paths: { userPath, userOverridePath, projectPath, customPath },
     layerErrors,
   };
 }
@@ -407,6 +416,12 @@ function getJsonEntrySource(layers, sectionKind, entryName) {
     if (project) return project;
   }
 
+  if (paths.userOverridePath) {
+    throwIfLayerError(layers, paths.userOverridePath);
+    const userOverride = found(layers.userOverrideConfig, paths.userOverridePath);
+    if (userOverride) return userOverride;
+  }
+
   throwIfLayerError(layers, paths.userPath);
   const user = found(userConfig, paths.userPath);
   if (user) return user;
@@ -509,7 +524,20 @@ function walkSkillMdFiles(rootDir) {
   if (!rootDir || !fs.existsSync(rootDir)) return [];
 
   const results = [];
+  // Real paths of the directories on the current walk path. Links (symlinks and
+  // Windows junctions) are followed at any depth; a link back to one of its own
+  // ancestors is skipped instead of recursing forever. Two links to the same
+  // target elsewhere in the tree are both walked, as the top level always did.
+  const ancestors = new Set();
   const walk = (dir) => {
+    let realDir;
+    try {
+      realDir = fs.realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (ancestors.has(realDir)) return;
+
     let entries = [];
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -517,16 +545,33 @@ function walkSkillMdFiles(rootDir) {
       return;
     }
 
+    ancestors.add(realDir);
+
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
+      // Junctions report as links, not directories. A link whose target cannot be
+      // stat'ed is skipped, the way an unreadable directory is, instead of failing
+      // the whole scan.
+      let isDirectoryEntry = entry.isDirectory();
+      let isFileEntry = entry.isFile();
+      if (entry.isSymbolicLink()) {
+        try {
+          const target = fs.statSync(fullPath);
+          isDirectoryEntry = target.isDirectory();
+          isFileEntry = target.isFile();
+        } catch {
+          continue;
+        }
+      }
+      if (isDirectoryEntry) {
         walk(fullPath);
         continue;
       }
-      if (entry.isFile() && entry.name === 'SKILL.md') {
+      if (isFileEntry && entry.name === 'SKILL.md') {
         results.push(fullPath);
       }
     }
+    ancestors.delete(realDir);
   };
 
   walk(rootDir);

package/server/lib/opencode/shared.test.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 
-import { parseMdFile, writeMdFile, readConfigFile, readConfigLayers, writeConfig } from './shared.js';
+import { parseMdFile, writeMdFile, readConfigFile, readConfigLayers, writeConfig, walkSkillMdFiles } from './shared.js';
 import { updateAgent } from './agents.js';
 import { updateMcpConfig } from './mcp.js';
 
@@ -388,3 +388,80 @@ describe('readConfigFile / writeConfig JSONC safety (issue #2923)', () => {
     }
   });
 });
+
+describe('walkSkillMdFiles', () => {
+  beforeEach(() => {
+    fs.rmSync(FIXTURE_DIR, { recursive: true, force: true });
+    fs.mkdirSync(FIXTURE_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(FIXTURE_DIR, { recursive: true, force: true });
+  });
+
+  const writeSkill = (relativeDir) => writeFixture(path.join(relativeDir, 'SKILL.md'), STANDARD_MD);
+  // A junction needs no elevation on Windows, which is what Skills Manager deploys;
+  // the type argument is ignored on POSIX.
+  const linkDirectory = (target, relativeLink) =>
+    fs.symlinkSync(target, path.join(FIXTURE_DIR, relativeLink), process.platform === 'win32' ? 'junction' : 'dir');
+  const foundRelative = () =>
+    walkSkillMdFiles(FIXTURE_DIR)
+      .map((found) => path.relative(FIXTURE_DIR, found).split(path.sep).join('/'))
+      .sort();
+
+  it('walks a skill deployed as a link inside the scanned root', () => {
+    writeSkill('real-skill');
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'collection'), { recursive: true });
+    writeSkill(path.join('collection', 'nested-skill'));
+    linkDirectory(path.join(FIXTURE_DIR, 'real-skill'), 'linked-skill');
+    linkDirectory(path.join(FIXTURE_DIR, 'collection'), 'collection-link');
+
+    expect(foundRelative()).toEqual([
+      'collection-link/nested-skill/SKILL.md',
+      'collection/nested-skill/SKILL.md',
+      'linked-skill/SKILL.md',
+      'real-skill/SKILL.md',
+    ]);
+  });
+
+  it('ends on a link that points back into the scanned tree', () => {
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'loopdir'), { recursive: true });
+    writeSkill('loopdir');
+    linkDirectory(FIXTURE_DIR, path.join('loopdir', 'back'));
+
+    expect(foundRelative()).toEqual(['loopdir/SKILL.md']);
+  });
+
+  it('skips a link whose target is gone and keeps the rest of the scan', () => {
+    writeSkill('real-skill');
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'gone-skill'), { recursive: true });
+    linkDirectory(path.join(FIXTURE_DIR, 'gone-skill'), 'dangling-link');
+    fs.rmSync(path.join(FIXTURE_DIR, 'gone-skill'), { recursive: true, force: true });
+
+    expect(foundRelative()).toEqual(['real-skill/SKILL.md']);
+  });
+
+  it('follows a link nested below the top level of the scanned root', () => {
+    const outside = `${FIXTURE_DIR}-outside`;
+    fs.rmSync(outside, { recursive: true, force: true });
+    fs.mkdirSync(path.join(outside, 'deep-skill'), { recursive: true });
+    fs.writeFileSync(path.join(outside, 'deep-skill', 'SKILL.md'), STANDARD_MD);
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'group'), { recursive: true });
+    try {
+      linkDirectory(path.join(outside, 'deep-skill'), path.join('group', 'linked'));
+      expect(foundRelative()).toEqual(['group/linked/SKILL.md']);
+    } finally {
+      fs.rmSync(outside, { recursive: true, force: true });
+    }
+  });
+
+  it('ends on a nested link loop between two directories', () => {
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'a'), { recursive: true });
+    fs.mkdirSync(path.join(FIXTURE_DIR, 'b'), { recursive: true });
+    writeSkill('a');
+    linkDirectory(path.join(FIXTURE_DIR, 'b'), path.join('a', 'to-b'));
+    linkDirectory(path.join(FIXTURE_DIR, 'a'), path.join('b', 'to-a'));
+
+    expect(foundRelative()).toEqual(['a/SKILL.md', 'b/to-a/SKILL.md']);
+  });
+});

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

@@ -13,18 +13,20 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     contextObligatoryRuntime,
     messageQueueRuntime,
     scheduledTasksRuntime,
+    globalEventHub,
     getHealthCheckInterval,
     clearHealthCheckInterval,
     getTerminalRuntime,
     setTerminalRuntime,
     getMessageStreamRuntime,
     setMessageStreamRuntime,
-    shouldSkipOpenCodeStop,
+    getOpenCodeConnectionKind,
     getOpenCodePort,
     getOpenCodeProcess,
     setOpenCodeProcess,
     killProcessOnPort,
     waitForPortRelease,
+    disposeSharedOpenCodeService,
     getServer,
     getUiAuthController,
     setUiAuthController,
@@ -38,6 +40,7 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     getDictationRuntime,
     getRelayService,
     getRelayReconcileTimer,
+    getSpacesHost = () => null,
   } = dependencies;
 
   let shutdownPromise = null;
@@ -66,7 +69,9 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     beginGuestServiceShutdown();
     syncToHmrState();
     console.log('Starting graceful shutdown...');
-    const exitProcess = typeof options.exitProcess === 'boolean' ? options.exitProcess : getExitOnShutdown();
+    const exitProcess = options.exitProcess === true || options.exitProcess === false
+      ? options.exitProcess
+      : getExitOnShutdown();
 
     // Both embedded stop() and daemon exits use this sequence. Close admission
     // synchronously above, then stop viewers before draining their services.
@@ -74,9 +79,12 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       () => clearInterval(getRelayReconcileTimer()),
       () => getGuestSurfaceRuntime()?.stop(),
       () => getRealtimeProxyRuntime()?.stop(),
+      // The isolated-spaces host, when the switch is on: its connections into spaces end here.
+      () => getSpacesHost()?.close(),
       () => getRelayService()?.stop(),
       () => getDictationRuntime()?.stop(),
       () => openCodeWatcherRuntime.stop(),
+      () => globalEventHub.stop(),
       () => sessionRuntime.dispose(),
       () => sessionAssistRuntime?.stop?.(),
       () => sessionGoalRuntime?.stop?.(),
@@ -118,7 +126,8 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       }
     }
 
-    if (!shouldSkipOpenCodeStop()) {
+    const connectionKind = getOpenCodeConnectionKind();
+    if (connectionKind === 'managed-owned') {
       const portToKill = getOpenCodePort();
       const openCodeProcess = getOpenCodeProcess();
 
@@ -136,8 +145,8 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       if (!(await waitForPortRelease(portToKill, 5000))) {
         console.warn(`Timed out waiting for OpenCode port ${portToKill} to be released during shutdown`);
       }
-    } else {
-      console.log('Skipping OpenCode shutdown (external server)');
+    } else if (connectionKind === 'shared-local') {
+      await disposeSharedOpenCodeService();
     }
 
     const server = getServer();