@vantran-se/openchamber-web 2.1.1 → 2.2.0

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

@@ -9,11 +9,7 @@ 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(),
+  auth: z.object({ type: z.literal('basic'), username: z.string(), password: z.string() }).optional(),
 });
 
 const createConnectionError = (code, message, details = {}, cause) => {
@@ -22,134 +18,57 @@ const createConnectionError = (code, message, details = {}, cause) => {
   Object.assign(error, details);
   return error;
 };
-
-const unavailableError = (message, cause) => createConnectionError(
-  'OPENCODE_SERVICE_UNAVAILABLE',
-  message,
-  {},
-  cause,
-);
-
+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');
-  }
-
+  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');
-  }
-
+  try { url = new URL(parsed.data.url); } catch (cause) { throw unavailableError('OpenCode shared service returned an invalid URL', cause); }
+  if (!['http:', 'https:'].includes(url.protocol) || !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 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;
-  }
+  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,
+  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);
-    }
+    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',
-        );
-      }
+      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) {
+    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);
-    }
+    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,
-    };
+    try { info = await readInfo(await fetchImpl(new URL('/api/info', endpoint.url), { headers: { Accept: 'application/json', ...headers } })); }
+    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;
-  };
-
+  const establishConnection = async () => { const replacement = await probe(await resolveEndpoint()); activeConnection = replacement; return replacement; };
   return {
-    connect: establishConnection,
-    recover: establishConnection,
-    getConnection: () => activeConnection,
+    connect: establishConnection, recover: establishConnection, getConnection: () => activeConnection,
     getBaseUrl: () => activeConnection?.endpoint.url ?? null,
     getHeaders: () => activeConnection ? { ...(service.headers(activeConnection.endpoint) ?? {}) } : {},
-    dispose: async () => {
-      activeConnection = null;
-    },
+    dispose: async () => { activeConnection = null; },
   };
 };

package/server/lib/opencode/shared.js

@@ -87,7 +87,14 @@ function sanitizeFrontmatter(frontmatter) {
 }
 
 function parseMdFile(filePath) {
-  const rawContent = fs.readFileSync(filePath, 'utf8');
+  return parseMdContent(fs.readFileSync(filePath, 'utf8'), filePath);
+}
+
+async function parseMdFileAsync(filePath) {
+  return parseMdContent(await fs.promises.readFile(filePath, 'utf8'), filePath);
+}
+
+function parseMdContent(rawContent, filePath) {
   // Strip a UTF-8 BOM so frontmatter is recognized regardless of the editor
   // that saved the file.
   const content = rawContent.charCodeAt(0) === 0xfeff ? rawContent.slice(1) : rawContent;
@@ -119,16 +126,19 @@ function parseMdFile(filePath) {
   return { frontmatter, body };
 }
 
-function writeMdFile(filePath, frontmatter, body) {
+// `flag: 'wx'` creates the file and fails with EEXIST when it is already
+// there; that error is passed on as is so a caller can tell it apart.
+function writeMdFile(filePath, frontmatter, body, { flag = 'w' } = {}) {
   try {
     const cleanedFrontmatter = Object.fromEntries(
       Object.entries(frontmatter).filter(([, value]) => value != null)
     );
     const yamlStr = yaml.stringify(cleanedFrontmatter);
     const content = `---\n${yamlStr}---\n\n${body}`;
-    fs.writeFileSync(filePath, content, 'utf8');
+    fs.writeFileSync(filePath, content, { encoding: 'utf8', flag });
     console.log(`Successfully wrote markdown file: ${filePath}`);
   } catch (error) {
+    if (error?.code === 'EEXIST') throw error;
     console.error(`Failed to write markdown file ${filePath}:`, error);
     throw new Error('Failed to write agent markdown file');
   }
@@ -703,34 +713,62 @@ function writePromptFile(filePath, content) {
 
 // ============== SKILL FILE OPERATIONS ==============
 
-function walkSkillMdFiles(rootDir) {
-  if (!rootDir || !fs.existsSync(rootDir)) return [];
+async function pathExists(target) {
+  try {
+    await fs.promises.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// At most this many file-system calls of one walk are in flight at once.
+const SKILL_WALK_CONCURRENCY = 8;
+
+// Async so a skills tree with tens of thousands of entries (a bundled `.venv`
+// or `node_modules`) does not hold the server's event loop for seconds.
+// Sibling directories are read in parallel, a few calls at a time, and their
+// results are joined in readdir order, so the order matches the old
+// synchronous depth-first walk exactly.
+async function walkSkillMdFiles(rootDir) {
+  if (!rootDir || !(await pathExists(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 active = 0;
+  const waiting = [];
+  const limited = async (call) => {
+    if (active >= SKILL_WALK_CONCURRENCY) await new Promise((resolve) => waiting.push(resolve));
+    active += 1;
+    try {
+      return await call();
+    } finally {
+      active -= 1;
+      waiting.shift()?.();
+    }
+  };
+
+  // `ancestors` holds the real paths of the directories on the path to `dir`.
+  // 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 walk = async (dir, ancestors) => {
     let realDir;
     try {
-      realDir = fs.realpathSync(dir);
+      realDir = await limited(() => fs.promises.realpath(dir));
     } catch {
-      return;
+      return [];
     }
-    if (ancestors.has(realDir)) return;
+    if (ancestors.has(realDir)) return [];
 
     let entries = [];
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = await limited(() => fs.promises.readdir(dir, { withFileTypes: true }));
     } catch {
-      return;
+      return [];
     }
 
-    ancestors.add(realDir);
-
-    for (const entry of entries) {
+    const childAncestors = new Set(ancestors).add(realDir);
+    const found = await Promise.all(entries.map(async (entry) => {
       const fullPath = path.join(dir, entry.name);
       // 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
@@ -739,33 +777,26 @@ function walkSkillMdFiles(rootDir) {
       let isFileEntry = entry.isFile();
       if (entry.isSymbolicLink()) {
         try {
-          const target = fs.statSync(fullPath);
+          const target = await limited(() => fs.promises.stat(fullPath));
           isDirectoryEntry = target.isDirectory();
           isFileEntry = target.isFile();
         } catch {
-          continue;
+          return [];
         }
       }
-      if (isDirectoryEntry) {
-        walk(fullPath);
-        continue;
-      }
-      if (isFileEntry && entry.name === 'SKILL.md') {
-        results.push(fullPath);
-      }
-    }
-    ancestors.delete(realDir);
+      if (isDirectoryEntry) return walk(fullPath, childAncestors);
+      return isFileEntry && entry.name === 'SKILL.md' ? [fullPath] : [];
+    }));
+    return found.flat();
   };
 
-  walk(rootDir);
-  return results;
+  return walk(rootDir, new Set());
 }
 
-function addSkillFromMdFile(skillsMap, skillMdPath, scope, source) {
-  let parsed;
-  try {
-    parsed = parseMdFile(skillMdPath);
-  } catch {
+// `parsed` is what `parseMdFileAsync(skillMdPath)` resolved to, or null when
+// the file could not be read; an unreadable file adds nothing.
+function addSkillFromMdFile(skillsMap, skillMdPath, parsed, scope, source) {
+  if (!parsed) {
     return;
   }
 
@@ -818,21 +849,21 @@ function resolveSkillSearchDirectories(workingDirectory) {
   return directories;
 }
 
-function listSkillSupportingFiles(skillDir) {
-  if (!fs.existsSync(skillDir)) {
+async function listSkillSupportingFiles(skillDir) {
+  if (!(await pathExists(skillDir))) {
     return [];
   }
 
   const files = [];
 
-  function walkDir(dir, relativePath = '') {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+  async function walkDir(dir, relativePath = '') {
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
 
       if (entry.isDirectory()) {
-        walkDir(fullPath, relPath);
+        await walkDir(fullPath, relPath);
       } else if (entry.name !== 'SKILL.md') {
         files.push({
           name: entry.name,
@@ -843,7 +874,7 @@ function listSkillSupportingFiles(skillDir) {
     }
   }
 
-  walkDir(skillDir);
+  await walkDir(skillDir);
   return files;
 }
 
@@ -910,6 +941,7 @@ export {
   SKILL_SCOPE,
   ensureDirs,
   parseMdFile,
+  parseMdFileAsync,
   writeMdFile,
   readConfigFile,
   readConfigLayer,
@@ -919,7 +951,6 @@ export {
   readWorktreeDirectorySetting,
   getConfigForPath,
   writeConfig,
-  lookupSectionEntry,
   getJsonEntrySource,
   getJsonWriteTarget,
   getAncestors,
@@ -933,5 +964,5 @@ export {
   listSkillSupportingFiles,
   readSkillSupportingFile,
   writeSkillSupportingFile,
-  deleteSkillSupportingFile,
+  deleteSkillSupportingFile
 };

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

@@ -404,19 +404,19 @@ describe('walkSkillMdFiles', () => {
   // 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)
+  const foundRelative = async () =>
+    (await 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', () => {
+  it('walks a skill deployed as a link inside the scanned root', async () => {
     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([
+    expect(await foundRelative()).toEqual([
       'collection-link/nested-skill/SKILL.md',
       'collection/nested-skill/SKILL.md',
       'linked-skill/SKILL.md',
@@ -424,24 +424,24 @@ describe('walkSkillMdFiles', () => {
     ]);
   });
 
-  it('ends on a link that points back into the scanned tree', () => {
+  it('ends on a link that points back into the scanned tree', async () => {
     fs.mkdirSync(path.join(FIXTURE_DIR, 'loopdir'), { recursive: true });
     writeSkill('loopdir');
     linkDirectory(FIXTURE_DIR, path.join('loopdir', 'back'));
 
-    expect(foundRelative()).toEqual(['loopdir/SKILL.md']);
+    expect(await foundRelative()).toEqual(['loopdir/SKILL.md']);
   });
 
-  it('skips a link whose target is gone and keeps the rest of the scan', () => {
+  it('skips a link whose target is gone and keeps the rest of the scan', async () => {
     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']);
+    expect(await foundRelative()).toEqual(['real-skill/SKILL.md']);
   });
 
-  it('follows a link nested below the top level of the scanned root', () => {
+  it('follows a link nested below the top level of the scanned root', async () => {
     const outside = `${FIXTURE_DIR}-outside`;
     fs.rmSync(outside, { recursive: true, force: true });
     fs.mkdirSync(path.join(outside, 'deep-skill'), { recursive: true });
@@ -449,20 +449,20 @@ describe('walkSkillMdFiles', () => {
     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']);
+      expect(await foundRelative()).toEqual(['group/linked/SKILL.md']);
     } finally {
       fs.rmSync(outside, { recursive: true, force: true });
     }
   });
 
-  it('ends on a nested link loop between two directories', () => {
+  it('ends on a nested link loop between two directories', async () => {
     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']);
+    expect(await foundRelative()).toEqual(['a/SKILL.md', 'b/to-a/SKILL.md']);
   });
 });
 

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

@@ -67,8 +67,7 @@ describe('graceful shutdown runtime', () => {
     const runtime = createRuntime(server);
     await runtime.gracefulShutdown({ exitProcess: false });
 
-    vi.advanceTimersByTime(1000);
-    await Promise.resolve();
+    await vi.advanceTimersByTime(1000);
 
     expect(warnSpy).not.toHaveBeenCalledWith('Server close timeout reached, forcing shutdown');
     expect(vi.getTimerCount()).toBe(0);
@@ -317,7 +316,7 @@ describe('graceful shutdown runtime', () => {
     await first;
     await runtime.gracefulShutdown();
     expect(order).toEqual(['gate', 'viewers', 'proxy', 'relay', 'dictation', 'guests']);
-    await vi.advanceTimersByTimeAsync(200);
+    await vi.advanceTimersByTime(200);
     expect(reconcile).not.toHaveBeenCalled();
     expect(vi.getTimerCount()).toBe(0);
   });