@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/opencode/skills.js

@@ -7,6 +7,7 @@ import {
   SKILL_SCOPE,
   ensureDirs,
   parseMdFile,
+  parseMdFileAsync,
   writeMdFile,
   readConfigLayers,
   readConfig,
@@ -92,8 +93,8 @@ function getProjectAgentsSkillPath(workingDirectory, skillName) {
   return path.join(getProjectAgentsSkillDir(workingDirectory, skillName), 'SKILL.md');
 }
 
-function getSkillScope(skillName, workingDirectory) {
-  const discovered = discoverSkills(workingDirectory).find((skill) => skill.name === skillName);
+async function getSkillScope(skillName, workingDirectory) {
+  const discovered = (await discoverSkills(workingDirectory)).find((skill) => skill.name === skillName);
   if (discovered?.path) {
     return { scope: discovered.scope || null, path: discovered.path, source: discovered.source || null };
   }
@@ -128,8 +129,8 @@ function getSkillScope(skillName, workingDirectory) {
   return { scope: null, path: null, source: null };
 }
 
-function getSkillWritePath(skillName, workingDirectory, requestedScope) {
-  const existing = getSkillScope(skillName, workingDirectory);
+async function getSkillWritePath(skillName, workingDirectory, requestedScope) {
+  const existing = await getSkillScope(skillName, workingDirectory);
   if (existing.path) {
     return existing;
   }
@@ -150,15 +151,34 @@ function getSkillWritePath(skillName, workingDirectory, requestedScope) {
   };
 }
 
-function discoverSkills(workingDirectory) {
+async function discoverSkills(workingDirectory) {
   const skills = new Map();
 
+  // A root can come up twice in one discovery: a home directory opened as a
+  // project lists `~/.claude/skills` and `~/.agents/skills` once as user
+  // skills and again as project skills. Each root is walked and each SKILL.md
+  // read once; the second pass still re-adds them in the same order, so the
+  // project scope wins as before.
+  const walkedRoots = new Map();
+  const parsedFiles = new Map();
+  const walkRoot = (root) => {
+    const key = path.resolve(root);
+    if (!walkedRoots.has(key)) walkedRoots.set(key, walkSkillMdFiles(root));
+    return walkedRoots.get(key);
+  };
+  const addSkills = async (root, scope, source) => {
+    for (const skillMdPath of await walkRoot(root)) {
+      if (!parsedFiles.has(skillMdPath)) {
+        parsedFiles.set(skillMdPath, await parseMdFileAsync(skillMdPath).catch(() => null));
+      }
+      addSkillFromMdFile(skills, skillMdPath, parsedFiles.get(skillMdPath), scope, source);
+    }
+  };
+
   for (const externalRootName of ['.claude', '.agents']) {
     const homeRoot = path.join(os.homedir(), externalRootName, 'skills');
     const source = externalRootName === '.agents' ? 'agents' : 'claude';
-    for (const skillMdPath of walkSkillMdFiles(homeRoot)) {
-      addSkillFromMdFile(skills, skillMdPath, SKILL_SCOPE.USER, source);
-    }
+    await addSkills(homeRoot, SKILL_SCOPE.USER, source);
   }
 
   if (workingDirectory) {
@@ -168,9 +188,7 @@ function discoverSkills(workingDirectory) {
       for (const externalRootName of ['.claude', '.agents']) {
         const source = externalRootName === '.agents' ? 'agents' : 'claude';
         const externalSkillsRoot = path.join(ancestor, externalRootName, 'skills');
-        for (const skillMdPath of walkSkillMdFiles(externalSkillsRoot)) {
-          addSkillFromMdFile(skills, skillMdPath, SKILL_SCOPE.PROJECT, source);
-        }
+        await addSkills(externalSkillsRoot, SKILL_SCOPE.PROJECT, source);
       }
     }
   }
@@ -183,13 +201,11 @@ function discoverSkills(workingDirectory) {
   for (const dir of configDirectories) {
     for (const subDir of ['skill', 'skills']) {
       const root = path.join(dir, subDir);
-      for (const skillMdPath of walkSkillMdFiles(root)) {
-        const isUserConfigDir = dir === OPENCODE_CONFIG_DIR
-          || dir === homeOpencodeDir
-          || (customConfigDir && dir === customConfigDir);
-        const scope = isUserConfigDir ? SKILL_SCOPE.USER : SKILL_SCOPE.PROJECT;
-        addSkillFromMdFile(skills, skillMdPath, scope, 'opencode');
-      }
+      const isUserConfigDir = dir === OPENCODE_CONFIG_DIR
+        || dir === homeOpencodeDir
+        || (customConfigDir && dir === customConfigDir);
+      const scope = isUserConfigDir ? SKILL_SCOPE.USER : SKILL_SCOPE.PROJECT;
+      await addSkills(root, scope, 'opencode');
     }
   }
 
@@ -214,9 +230,7 @@ function discoverSkills(workingDirectory) {
     const resolved = path.isAbsolute(expanded)
       ? path.resolve(expanded)
       : path.resolve(workingDirectory || process.cwd(), expanded);
-    for (const skillMdPath of walkSkillMdFiles(resolved)) {
-      addSkillFromMdFile(skills, skillMdPath, SKILL_SCOPE.PROJECT, 'opencode');
-    }
+    await addSkills(resolved, SKILL_SCOPE.PROJECT, 'opencode');
   }
 
   const cacheCandidates = [];
@@ -232,9 +246,7 @@ function discoverSkills(workingDirectory) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillRoot = path.join(cacheRoot, entry.name);
-      for (const skillMdPath of walkSkillMdFiles(skillRoot)) {
-        addSkillFromMdFile(skills, skillMdPath, SKILL_SCOPE.USER, 'opencode');
-      }
+      await addSkills(skillRoot, SKILL_SCOPE.USER, 'opencode');
     }
   }
 
@@ -308,7 +320,10 @@ function applyModelInvocation(frontmatter, disabled) {
   }
 }
 
-function getSkillSources(skillName, workingDirectory, discoveredSkill = null) {
+// `includeSupportingFiles: false` leaves `md.supportingFiles` out instead of
+// walking the skill folder: the skills list has no use for it, and a folder
+// with a bundled `.venv` or `node_modules` costs seconds to walk.
+async function getSkillSources(skillName, workingDirectory, discoveredSkill = null, { includeSupportingFiles = true } = {}) {
   const isReadableFile = (filePath) => {
     if (!filePath) return false;
     try {
@@ -339,7 +354,7 @@ function getSkillSources(skillName, workingDirectory, discoveredSkill = null) {
 
   const matchedDiscovered = discoveredSkill && discoveredSkill.name === skillName
     ? discoveredSkill
-    : discoverSkills(workingDirectory).find((skill) => skill.name === skillName);
+    : (await discoverSkills(workingDirectory)).find((skill) => skill.name === skillName);
   const discoveredDescription =
     matchedDiscovered && typeof matchedDiscovered.description === 'string'
       ? matchedDiscovered.description
@@ -410,7 +425,6 @@ function getSkillSources(skillName, workingDirectory, discoveredSkill = null) {
       scope: mdScope,
       source: mdSource,
       fields: isBuiltInDiscovered ? ['description', 'instructions'] : [],
-      supportingFiles: [],
       name: matchedDiscovered?.name || skillName,
       description: discoveredDescription,
       instructions: isBuiltInDiscovered ? discoveredContent : '',
@@ -444,7 +458,7 @@ function getSkillSources(skillName, workingDirectory, discoveredSkill = null) {
   };
 
   if (mdExists && mdDir) {
-    const { frontmatter, body } = parseMdFile(mdPath);
+    const { frontmatter, body } = await parseMdFileAsync(mdPath);
     sources.md.fields = Object.keys(frontmatter);
     sources.md.description = frontmatter.description || '';
     sources.md.name = frontmatter.name || skillName;
@@ -455,7 +469,9 @@ function getSkillSources(skillName, workingDirectory, discoveredSkill = null) {
     } else {
       sources.md.instructions = '';
     }
-    sources.md.supportingFiles = listSkillSupportingFiles(mdDir);
+  }
+  if (includeSupportingFiles) {
+    sources.md.supportingFiles = mdExists && mdDir ? await listSkillSupportingFiles(mdDir) : [];
   }
 
   return sources;
@@ -474,11 +490,25 @@ function assertValidSkillName(skillName) {
   }
 }
 
+// Create, edit and rename check the disk, wait on discovery, then write. Run
+// one at a time per process, the way they did while discovery was
+// synchronous, so a check cannot go stale before its own write.
+let skillWriteQueue = Promise.resolve();
+function serializeSkillWrite(write) {
+  const run = skillWriteQueue.then(write, write);
+  skillWriteQueue = run.catch(() => {});
+  return run;
+}
+
 function createSkill(skillName, config, workingDirectory, scope) {
+  return serializeSkillWrite(() => createSkillNow(skillName, config, workingDirectory, scope));
+}
+
+async function createSkillNow(skillName, config, workingDirectory, scope) {
   ensureDirs();
   assertValidSkillName(skillName);
 
-  const existing = getSkillScope(skillName, workingDirectory);
+  const existing = await getSkillScope(skillName, workingDirectory);
   if (existing.path) {
     throw new Error(`Skill ${skillName} already exists at ${existing.path}`);
   }
@@ -534,7 +564,16 @@ function createSkill(skillName, config, workingDirectory, scope) {
     applyModelInvocation(frontmatter, true);
   }
 
-  writeMdFile(targetPath, frontmatter, instructions || '');
+  // `wx` fails if SKILL.md appeared since the check above, from another
+  // process or a client racing this one, instead of overwriting it.
+  try {
+    writeMdFile(targetPath, frontmatter, instructions || '', { flag: 'wx' });
+  } catch (error) {
+    if (error?.code === 'EEXIST') {
+      throw new Error(`Skill ${skillName} already exists at ${targetPath}`);
+    }
+    throw error;
+  }
   
   if (supportingFiles && Array.isArray(supportingFiles)) {
     for (const file of supportingFiles) {
@@ -548,6 +587,10 @@ function createSkill(skillName, config, workingDirectory, scope) {
 }
 
 function updateSkill(skillName, updates, workingDirectory, targetPath = null) {
+  return serializeSkillWrite(() => updateSkillNow(skillName, updates, workingDirectory, targetPath));
+}
+
+async function updateSkillNow(skillName, updates, workingDirectory, targetPath = null) {
   ensureDirs();
 
   const requestedPath = typeof targetPath === 'string' && targetPath.trim()
@@ -555,7 +598,7 @@ function updateSkill(skillName, updates, workingDirectory, targetPath = null) {
     : null;
   const existing = requestedPath && fs.existsSync(requestedPath)
     ? { scope: null, path: requestedPath, source: null }
-    : getSkillScope(skillName, workingDirectory);
+    : await getSkillScope(skillName, workingDirectory);
   if (!existing.path) {
     throw new Error(`Skill "${skillName}" not found`);
   }
@@ -724,6 +767,10 @@ function isManagedSkillPath(skillMdPath, workingDirectory) {
 }
 
 function renameSkill(oldName, newName, workingDirectory) {
+  return serializeSkillWrite(() => renameSkillNow(oldName, newName, workingDirectory));
+}
+
+async function renameSkillNow(oldName, newName, workingDirectory) {
   ensureDirs();
   assertValidSkillName(newName);
 
@@ -731,7 +778,7 @@ function renameSkill(oldName, newName, workingDirectory) {
     return;
   }
 
-  const existing = getSkillScope(oldName, workingDirectory);
+  const existing = await getSkillScope(oldName, workingDirectory);
   if (!existing.path) {
     throw new Error(`Skill "${oldName}" not found`);
   }
@@ -753,7 +800,7 @@ function renameSkill(oldName, newName, workingDirectory) {
     throw new Error(`Skill "${oldName}" does not match ${existing.path}`);
   }
 
-  const conflict = getSkillScope(newName, workingDirectory);
+  const conflict = await getSkillScope(newName, workingDirectory);
   if (conflict.path) {
     throw new Error(`Skill ${newName} already exists at ${conflict.path}`);
   }

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

@@ -4,7 +4,7 @@ import fsPromises from 'fs/promises';
 import os from 'os';
 import path from 'path';
 import yaml from 'yaml';
-import { discoverSkills, getSkillSources, mergeDiscoveredSkills, renameSkill, updateSkill } from './skills.js';
+import { createSkill, discoverSkills, getSkillSources, mergeDiscoveredSkills, renameSkill, updateSkill } from './skills.js';
 
 describe('skills', () => {
   it('merges locally discovered skills missing from OpenCode live discovery', () => {
@@ -48,7 +48,7 @@ describe('skills', () => {
         'utf8',
       );
 
-      const discovered = discoverSkills(tempRoot);
+      const discovered = await discoverSkills(tempRoot);
       const match = discovered.find((skill) => skill.name === 'repo-local-skill');
 
       expect(match).toEqual({
@@ -63,8 +63,163 @@ describe('skills', () => {
     }
   });
 
-  it('resolves built-in OpenCode skill content without parsing virtual locations as files', () => {
-    const sources = getSkillSources(
+  describe('discovery over a tree with nested skills and links', () => {
+    // Expected values were recorded from the synchronous discovery on main
+    // before it became async; they must not move.
+    const buildTree = async () => {
+      const root = await fsPromises.realpath(await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-skill-equiv-')));
+      const write = async (relative, frontmatter) => {
+        const file = path.join(root, relative);
+        await fsPromises.mkdir(path.dirname(file), { recursive: true });
+        await fsPromises.writeFile(file, `---\n${frontmatter}\n---\nBody\n`, 'utf8');
+      };
+      const skill = (relative, name) => write(relative, `name: ${name}\ndescription: ${name} description`);
+      // A junction needs no elevation on Windows; the type is ignored on POSIX.
+      const link = async (target, relative) => {
+        await fsPromises.mkdir(path.dirname(path.join(root, relative)), { recursive: true });
+        await fsPromises.symlink(path.join(root, target), path.join(root, relative), process.platform === 'win32' ? 'junction' : 'dir');
+      };
+      await skill('home/.agents/skills/alpha/SKILL.md', 'alpha');
+      await skill('home/.agents/skills/alpha/nested/inner/SKILL.md', 'alpha-inner');
+      await skill('home/.agents/skills/group/beta/SKILL.md', 'beta');
+      await write('home/.agents/skills/broken/SKILL.md', 'description: no name');
+      await skill('outside/gamma/SKILL.md', 'gamma');
+      await link('outside/gamma', 'home/.agents/skills/linked-gamma');
+      await link('home/.agents/skills', 'home/.agents/skills/loop/back');
+      await link('home/.agents/skills/alpha', 'home/.claude/skills/alpha');
+      await skill('home/.claude/skills/delta/SKILL.md', 'delta');
+      await skill('home/.claude/skills/delta/.venv/lib/pkg/SKILL.md', 'venv-skill');
+      await fsPromises.mkdir(path.join(root, 'home/work/project/.git'), { recursive: true });
+      await skill('home/work/project/.agents/skills/proj/SKILL.md', 'proj');
+      await skill('home/work/project/.opencode/skills/oc/SKILL.md', 'oc');
+      await skill('home/work/project/.claude/skills/delta/SKILL.md', 'delta');
+      return root;
+    };
+
+    const withHome = async (home, run) => {
+      const previous = { HOME: process.env.HOME, USERPROFILE: process.env.USERPROFILE };
+      process.env.HOME = home;
+      process.env.USERPROFILE = home;
+      try {
+        return await run();
+      } finally {
+        for (const [key, value] of Object.entries(previous)) {
+          if (value === undefined) delete process.env[key];
+          else process.env[key] = value;
+        }
+      }
+    };
+
+    // Skills of the machine running the tests (global config, caches) are
+    // outside the tree and left out.
+    const discoveredIn = async (root, directory) => (await discoverSkills(directory))
+      .filter((skill) => skill.path.startsWith(root))
+      .map((skill) => [skill.name, path.relative(root, skill.path).split(path.sep).join('/'), skill.scope, skill.source])
+      .sort((a, b) => a[0].localeCompare(b[0]));
+
+    const userSkills = (scope) => [
+      ['alpha', 'home/.agents/skills/alpha/SKILL.md', scope, 'agents'],
+      ['alpha-inner', 'home/.agents/skills/alpha/nested/inner/SKILL.md', scope, 'agents'],
+      ['beta', 'home/.agents/skills/group/beta/SKILL.md', scope, 'agents'],
+      ['delta', 'home/.claude/skills/delta/SKILL.md', scope, 'claude'],
+      ['gamma', 'home/.agents/skills/linked-gamma/SKILL.md', scope, 'agents'],
+      ['venv-skill', 'home/.claude/skills/delta/.venv/lib/pkg/SKILL.md', scope, 'claude'],
+    ];
+
+    it('finds the same skills as before for a project, a home-directory project and no project', async () => {
+      const root = await buildTree();
+      const home = path.join(root, 'home');
+      try {
+        await withHome(home, async () => {
+          expect(await discoveredIn(root, path.join(home, 'work', 'project'))).toEqual([
+            ['alpha', 'home/.agents/skills/alpha/SKILL.md', 'user', 'agents'],
+            ['alpha-inner', 'home/.agents/skills/alpha/nested/inner/SKILL.md', 'user', 'agents'],
+            ['beta', 'home/.agents/skills/group/beta/SKILL.md', 'user', 'agents'],
+            ['delta', 'home/work/project/.claude/skills/delta/SKILL.md', 'project', 'claude'],
+            ['gamma', 'home/.agents/skills/linked-gamma/SKILL.md', 'user', 'agents'],
+            ['oc', 'home/work/project/.opencode/skills/oc/SKILL.md', 'project', 'opencode'],
+            ['proj', 'home/work/project/.agents/skills/proj/SKILL.md', 'project', 'agents'],
+            ['venv-skill', 'home/.claude/skills/delta/.venv/lib/pkg/SKILL.md', 'user', 'claude'],
+          ]);
+          // The home directory's own skill roots are read once but still
+          // land as project skills, the way the second pass always left them.
+          expect(await discoveredIn(root, home)).toEqual(userSkills('project'));
+          expect(await discoveredIn(root, null)).toEqual(userSkills('user'));
+        });
+      } finally {
+        await fsPromises.rm(root, { recursive: true, force: true });
+      }
+    });
+
+    it('lets other work run while it reads the tree', async () => {
+      const root = await buildTree();
+      const events = [];
+      try {
+        await withHome(path.join(root, 'home'), async () => {
+          const discovery = discoverSkills(path.join(root, 'home', 'work', 'project')).then(() => events.push('discovered'));
+          setImmediate(() => events.push('other work'));
+          await discovery;
+        });
+        expect(events).toEqual(['other work', 'discovered']);
+      } finally {
+        await fsPromises.rm(root, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('writes that race each other', () => {
+    const makeProject = async () => {
+      const tempRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-skills-race-'));
+      const projectRoot = path.join(tempRoot, 'project');
+      await fsPromises.mkdir(path.join(projectRoot, '.git'), { recursive: true });
+      return { tempRoot, projectRoot };
+    };
+    const skillPath = (projectRoot, name) => path.join(projectRoot, '.opencode', 'skills', name, 'SKILL.md');
+    // `.agents` project skills: the existence check only finds them through
+    // discovery, so two creates both pass it unless the write itself refuses.
+    const agentsSkillPath = (projectRoot, name) => path.join(projectRoot, '.agents', 'skills', name, 'SKILL.md');
+
+    it('lets exactly one of two simultaneous creates of the same name succeed', async () => {
+      const { tempRoot, projectRoot } = await makeProject();
+      try {
+        const results = await Promise.allSettled([
+          createSkill('race-skill', { description: 'First', source: 'agents' }, projectRoot, 'project'),
+          createSkill('race-skill', { description: 'Second', source: 'agents' }, projectRoot, 'project'),
+        ]);
+
+        expect(results.map((result) => result.status).sort()).toEqual(['fulfilled', 'rejected']);
+        expect(results.find((result) => result.status === 'rejected').reason.message).toMatch(/already exists/);
+        const written = await fsPromises.readFile(agentsSkillPath(projectRoot, 'race-skill'), 'utf8');
+        expect(written).toContain(`description: ${results[0].status === 'fulfilled' ? 'First' : 'Second'}`);
+      } finally {
+        await fsPromises.rm(tempRoot, { recursive: true, force: true });
+      }
+    });
+
+    it('does not write an edit into the folder of a skill renamed meanwhile', async () => {
+      const { tempRoot, projectRoot } = await makeProject();
+      const oldDir = path.dirname(skillPath(projectRoot, 'moving-skill'));
+      try {
+        await createSkill('moving-skill', { description: 'Before' }, projectRoot, 'project');
+
+        const [renamed, edited] = await Promise.allSettled([
+          renameSkill('moving-skill', 'moved-skill', projectRoot),
+          updateSkill('moving-skill', { description: 'Edited' }, projectRoot),
+        ]);
+
+        expect(renamed.status).toBe('fulfilled');
+        expect(edited.status).toBe('rejected');
+        expect(edited.reason.message).toMatch(/not found/);
+        expect(fs.existsSync(oldDir)).toBe(false);
+        expect(await fsPromises.readFile(skillPath(projectRoot, 'moved-skill'), 'utf8')).toContain('description: Before');
+      } finally {
+        await fsPromises.rm(tempRoot, { recursive: true, force: true });
+      }
+    });
+  });
+
+  it('resolves built-in OpenCode skill content without parsing virtual locations as files', async () => {
+    const sources = await getSkillSources(
       'customize-opencode',
       '/tmp/openchamber-skills-test-missing-project',
       {
@@ -87,9 +242,9 @@ describe('skills', () => {
     expect(sources.md.fields).toEqual(['description', 'instructions']);
   });
 
-  it('clears file metadata when a discovered skill path is unreadable', () => {
+  it('clears file metadata when a discovered skill path is unreadable', async () => {
     const missingPath = path.join(os.tmpdir(), 'openchamber-skills-test-missing-file', 'SKILL.md');
-    const sources = getSkillSources(
+    const sources = await getSkillSources(
       'missing-agent-skill',
       '/tmp/openchamber-skills-test-missing-project',
       {
@@ -131,7 +286,7 @@ describe('skills', () => {
         'utf8',
       );
 
-      const sources = getSkillSources('example-skill', tempRoot, {
+      const sources = await getSkillSources('example-skill', tempRoot, {
         name: 'example-skill',
         path: skillPath,
         scope: 'user',
@@ -167,24 +322,24 @@ describe('skills', () => {
         ['---', 'name: manual-skill', 'description: Manual', 'metadata:', '  team: core', '---', '', 'Body.', ''].join('\n'),
         'utf8',
       );
-      expect(getSkillSources('manual-skill', tempRoot, discovered).md.disableModelInvocation).toBe(false);
+      expect((await getSkillSources('manual-skill', tempRoot, discovered)).md.disableModelInvocation).toBe(false);
 
-      updateSkill('manual-skill', { disableModelInvocation: true }, tempRoot, skillPath);
+      await updateSkill('manual-skill', { disableModelInvocation: true }, tempRoot, skillPath);
       expect(await readFrontmatter()).toEqual({
         name: 'manual-skill',
         description: 'Manual',
         metadata: { team: 'core', 'opencode/autoinvoke': false },
         'disable-model-invocation': true,
       });
-      expect(getSkillSources('manual-skill', tempRoot, discovered).md.disableModelInvocation).toBe(true);
+      expect((await getSkillSources('manual-skill', tempRoot, discovered)).md.disableModelInvocation).toBe(true);
 
-      updateSkill('manual-skill', { disableModelInvocation: false }, tempRoot, skillPath);
+      await updateSkill('manual-skill', { disableModelInvocation: false }, tempRoot, skillPath);
       expect(await readFrontmatter()).toEqual({
         name: 'manual-skill',
         description: 'Manual',
         metadata: { team: 'core' },
       });
-      expect(getSkillSources('manual-skill', tempRoot, discovered).md.disableModelInvocation).toBe(false);
+      expect((await getSkillSources('manual-skill', tempRoot, discovered)).md.disableModelInvocation).toBe(false);
     } finally {
       await fsPromises.rm(tempRoot, { recursive: true, force: true });
     }
@@ -201,7 +356,7 @@ describe('skills', () => {
         ['---', 'name: read-skill', 'description: Read', ...frontmatterLines, '---', '', 'Body.', ''].join('\n'),
         'utf8',
       );
-      return getSkillSources('read-skill', tempRoot, discovered).md.disableModelInvocation;
+      return (await getSkillSources('read-skill', tempRoot, discovered)).md.disableModelInvocation;
     };
 
     try {
@@ -249,7 +404,7 @@ describe('skills', () => {
       );
       await fsPromises.writeFile(supportPath, 'supporting file contents\n', 'utf8');
 
-      renameSkill('original-skill', 'renamed-skill', projectRoot);
+      await renameSkill('original-skill', 'renamed-skill', projectRoot);
 
       const renamedDir = path.join(projectRoot, '.opencode', 'skills', 'renamed-skill');
       const renamedPath = path.join(renamedDir, 'SKILL.md');
@@ -259,7 +414,7 @@ describe('skills', () => {
       expect(fs.existsSync(renamedPath)).toBe(true);
       expect(fs.existsSync(renamedSupportPath)).toBe(true);
 
-      const sources = getSkillSources('renamed-skill', projectRoot, {
+      const sources = await getSkillSources('renamed-skill', projectRoot, {
         name: 'renamed-skill',
         path: renamedPath,
         scope: 'project',
@@ -305,7 +460,7 @@ describe('skills', () => {
       );
       await fsPromises.chmod(skillPath, 0o444);
 
-      expect(() => renameSkill('rollback-skill', 'rollback-skill-renamed', projectRoot)).toThrow();
+      await expect(renameSkill('rollback-skill', 'rollback-skill-renamed', projectRoot)).rejects.toThrow();
 
       expect(fs.existsSync(skillDir)).toBe(true);
       expect(fs.existsSync(path.join(projectRoot, '.opencode', 'skills', 'rollback-skill-renamed'))).toBe(false);
@@ -390,11 +545,11 @@ describe('skills', () => {
         'utf8',
       );
 
-      expect(() => renameSkill('managed-skill', 'Invalid_Name', projectRoot)).toThrow(/Invalid skill name/);
-      expect(() => renameSkill('missing-skill', 'new-skill', projectRoot)).toThrow(/not found/);
-      expect(() => renameSkill('managed-skill', 'taken-name', projectRoot)).toThrow(/already exists/);
-      expect(() => renameSkill('folder-name', 'renamed-mismatch', projectRoot)).toThrow(/does not match/);
-      expect(() => renameSkill('cache-skill', 'cache-skill-renamed', projectRoot)).toThrow(/managed skill directories/);
+      await expect(renameSkill('managed-skill', 'Invalid_Name', projectRoot)).rejects.toThrow(/Invalid skill name/);
+      await expect(renameSkill('missing-skill', 'new-skill', projectRoot)).rejects.toThrow(/not found/);
+      await expect(renameSkill('managed-skill', 'taken-name', projectRoot)).rejects.toThrow(/already exists/);
+      await expect(renameSkill('folder-name', 'renamed-mismatch', projectRoot)).rejects.toThrow(/does not match/);
+      await expect(renameSkill('cache-skill', 'cache-skill-renamed', projectRoot)).rejects.toThrow(/managed skill directories/);
 
       expect(fs.existsSync(managedDir)).toBe(true);
       expect(fs.existsSync(cacheDir)).toBe(true);

package/server/lib/opencode/startup-pipeline-runtime.js

@@ -33,8 +33,11 @@ export const createStartupPipelineRuntime = (dependencies) => {
       terminalHeartbeatIntervalMs,
       terminalRebindWindowMs,
       terminalMaxRebindsPerWindow,
+      environmentRuntime = null,
       setupProxy,
+      scheduleOpenCodeApiDetection,
       bootstrapOpenCodeAtStartup,
+      onListenerReady = null,
       staticRoutesRuntime,
       process,
       crypto,
@@ -53,7 +56,6 @@ export const createStartupPipelineRuntime = (dependencies) => {
       port,
       startupTunnelRequest,
       onTunnelReady,
-      onListenerReady,
       tunnelRuntimeContext,
       attachSignals,
       apiOnly,
@@ -75,6 +77,7 @@ export const createStartupPipelineRuntime = (dependencies) => {
       TERMINAL_INPUT_WS_HEARTBEAT_INTERVAL_MS: terminalHeartbeatIntervalMs,
       TERMINAL_INPUT_WS_REBIND_WINDOW_MS: terminalRebindWindowMs,
       TERMINAL_INPUT_WS_MAX_REBINDS_PER_WINDOW: terminalMaxRebindsPerWindow,
+      environmentRuntime,
     });
 
     const dictationRuntime = createDictationRuntime({
@@ -134,7 +137,8 @@ export const createStartupPipelineRuntime = (dependencies) => {
       onTunnelReady,
       afterListening: async ({ activePort }) => {
         tunnelRuntimeContext.setActivePort(activePort);
-        if (onListenerReady) await onListenerReady();
+        await onListenerReady?.({ activePort });
+        scheduleOpenCodeApiDetection();
         await bootstrapOpenCodeAtStartup();
       },
     });
@@ -142,7 +146,6 @@ export const createStartupPipelineRuntime = (dependencies) => {
       durationMs: performance.now() - pipelineStartedAt,
     });
 
-
     serverStartupRuntime.attachProcessHandlers({ attachSignals });
 
     return {

package/server/lib/opencode/startup-pipeline-runtime.test.js

@@ -31,6 +31,7 @@ describe('startup pipeline runtime', () => {
       tunnelRuntimeContext: {
         setActivePort: (port) => order.push(`port:${port}`),
       },
+      scheduleOpenCodeApiDetection: vi.fn(),
       bootstrapOpenCodeAtStartup: async () => {
         order.push('bootstrap');
         await bootstrapGate;
@@ -41,7 +42,7 @@ describe('startup pipeline runtime', () => {
       attachSignals: false,
     });
 
-    await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
     expect(order).toEqual(['listen', 'port:3901', 'bootstrap']);
     releaseBootstrap();
     await run;