@vantran-se/openchamber-web 2.1.1 → 2.2.0

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

@@ -36,6 +36,37 @@ describe('projectCredentialEntries', () => {
       custom: { type: 'api', key: 'k', metadata: { region: 'eu' } },
     });
   });
+
+  it('keeps only the Console server and organization from OpenCode Console metadata', () => {
+    const projected = projectCredentialEntries([
+      entry('opencode', true, {
+        type: 'oauth',
+        methodID: 'console',
+        access: 'console-access',
+        refresh: 'console-refresh',
+        expires: 42,
+        metadata: {
+          server: 'https://opencode.ai/console',
+          orgID: 'org_TESTORG123',
+          accountID: 'acc_console',
+          email: 'person@example.com',
+          orgName: 'Example',
+        },
+      }),
+    ]);
+
+    expect(projected).toEqual({
+      opencode: {
+        type: 'oauth',
+        access: 'console-access',
+        refresh: 'console-refresh',
+        expires: 42,
+        accountId: 'acc_console',
+        server: 'https://opencode.ai/console',
+        orgID: 'org_TESTORG123',
+      },
+    });
+  });
 });
 
 describe('projectEnvironmentKeys', () => {

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

@@ -19,6 +19,7 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     getAgentSources,
     getAgentConfig,
     getAgentPermissions,
+    listDisabledAgents,
     createAgent,
     updateAgent,
     deleteAgent,
@@ -58,6 +59,21 @@ export const registerConfigEntityRoutes = (app, dependencies) => {
     return next();
   });
 
+  // Its own path: under /api/config/agents/ it would shadow an agent named
+  // "disabled".
+  app.get('/api/config/disabled-agents', async (req, res) => {
+    try {
+      const { directory, error } = await resolveProjectDirectory(req);
+      if (!directory) {
+        return res.status(400).json({ error });
+      }
+      res.json({ agents: listDisabledAgents(directory) });
+    } catch (error) {
+      console.error('Failed to list disabled agents:', error);
+      res.status(500).json({ error: 'Failed to list disabled agents' });
+    }
+  });
+
   app.get('/api/config/agents/:name', async (req, res) => {
     try {
       const agentName = req.params.name;

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

@@ -11,7 +11,7 @@ process.env.XDG_CONFIG_HOME = path.join(root, 'xdg');
 delete process.env.OPENCODE_CONFIG;
 
 const { parseMdFile } = await import('./shared.js');
-const { getAgentConfig, getAgentPermissions, updateAgent, createAgent } = await import('./agents.js');
+const { getAgentConfig, getAgentPermissions, updateAgent, createAgent, listDisabledAgents } = await import('./agents.js');
 const { getCommandConfig, updateCommand } = await import('./commands.js');
 const { getMcpConfig, listMcpConfigs, updateMcpConfig } = await import('./mcp.js');
 
@@ -314,4 +314,19 @@ describe('entity modules speak OpenCode 2 shapes', () => {
       timeout: { catalog: 30000, execution: 30000 },
     });
   });
+
+  it('lists agents switched off in files and config sections, and forgets them once enabled', () => {
+    write('.opencode/agents/incident.md', ['---', 'description: Incident response', 'disabled: true', '---', '', 'Handle incidents.'].join('\n'));
+    write('.opencode/agents/ops/oncall.md', ['---', 'disable: true', '---', '', 'On call.'].join('\n'));
+    write('.opencode/agents/reviewer.md', ['---', 'description: Reviewer', '---', '', 'Review.'].join('\n'));
+    write('opencode.json', JSON.stringify({ agents: { plan: { disabled: true }, build: { color: '#112233' } } }));
+
+    expect(listDisabledAgents(projectDir).map((agent) => agent.name)).toEqual(['incident', 'ops/oncall', 'plan']);
+    expect(listDisabledAgents(projectDir)[0]).toMatchObject({ name: 'incident', scope: 'project', description: 'Incident response' });
+
+    updateAgent('incident', { disabled: null }, projectDir);
+    updateAgent('plan', { disabled: null }, projectDir);
+    expect(listDisabledAgents(projectDir).map((agent) => agent.name)).toEqual(['ops/oncall']);
+    expect(getAgentConfig('incident', projectDir).config.description).toBe('Incident response');
+  });
 });

package/server/lib/opencode/config-paths.test.js

@@ -61,7 +61,7 @@ describe('OpenCode global config paths', () => {
     const [, agents, commands, skills, snippets, plugins] = await loadOpenCodeModules();
     agents.createAgent('global-agent', { description: 'Global', prompt: 'Global prompt' }, projectDir, 'user');
     commands.createCommand('global-command', { description: 'Global', template: 'Global template' }, projectDir, 'user');
-    skills.createSkill('global-skill', { description: 'Global', instructions: 'Global instructions' }, projectDir, 'user');
+    await skills.createSkill('global-skill', { description: 'Global', instructions: 'Global instructions' }, projectDir, 'user');
     snippets.createSnippet('global-snippet', { content: 'Global snippet' }, projectDir, 'global');
     plugins.createPluginEntry({ spec: 'global-plugin', scope: 'user' }, projectDir);
 
@@ -74,7 +74,7 @@ describe('OpenCode global config paths', () => {
 
     agents.createAgent('project-agent', { description: 'Project', prompt: 'Project prompt' }, projectDir, 'project');
     commands.createCommand('project-command', { description: 'Project', template: 'Project template' }, projectDir, 'project');
-    skills.createSkill('project-skill', { description: 'Project', instructions: 'Project instructions' }, projectDir, 'project');
+    await skills.createSkill('project-skill', { description: 'Project', instructions: 'Project instructions' }, projectDir, 'project');
 
     expect(fs.existsSync(path.join(projectDir, '.opencode', 'agents', 'project-agent.md'))).toBe(true);
     expect(fs.existsSync(path.join(projectDir, '.opencode', 'commands', 'project-command.md'))).toBe(true);

package/server/lib/opencode/config-v2.js

@@ -11,6 +11,7 @@
  * Reference: OpenCode `packages/core/src/config/normalize.ts`,
  * `packages/core/src/v1/config/migrate.ts`, and `services/www` migrate-v1 docs.
  */
+import { isRecord } from '../shared/guards.js';
 
 // ============== SECTIONS ==============
 
@@ -18,16 +19,13 @@
  * Config section keys per entity. `v2` is what OpenChamber writes; `v1` is the
  * legacy key OpenCode still decodes and OpenChamber still reads.
  */
+
 const SECTIONS = {
   agents: { v2: 'agents', v1: 'agent' },
   commands: { v2: 'commands', v1: 'command' },
   providers: { v2: 'providers', v1: 'provider' },
 };
 
-function isRecord(value) {
-  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-
 function sectionKeys(kind) {
   const section = SECTIONS[kind];
   if (!section) throw new Error(`Unknown config section: ${kind}`);

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

@@ -39,7 +39,7 @@ import { getNpmInfo, clearCache as clearNpmCache } from './npm-registry.js';
 import { parseNpmSpec, parsePathSpec, isExactSemver } from './plugin-spec.js';
 import { registerOpenCodeRoutes } from './routes.js';
 import { getProviderSources, removeProviderConfig, upsertProviderConfig } from './providers.js';
-import { getAgentSources, getAgentConfig, getAgentPermissions, createAgent, updateAgent, deleteAgent } from './agents.js';
+import { getAgentSources, getAgentConfig, getAgentPermissions, createAgent, updateAgent, deleteAgent, listDisabledAgents } from './agents.js';
 import { getCommandSources, getCommandConfig, createCommand, updateCommand, deleteCommand } from './commands.js';
 import { listMcpConfigs, getMcpConfig, createMcpConfig, updateMcpConfig, deleteMcpConfig } from './mcp.js';
 import { listSnippets, getSnippet, createSnippet, updateSnippet, deleteSnippet, expandSnippets } from './snippets.js';
@@ -66,6 +66,7 @@ import { installSkillsFromRepository } from '../skills-catalog/install.js';
 import { fetchGitHubRepoMetas } from '../skills-catalog/github-meta.js';
 import crypto from 'node:crypto';
 import { getGitHubAuthByAccountId } from '../github/auth.js';
+import { getGitHubCliCredential } from '../github/octokit.js';
 import { createSourceControlAuthStore } from '../gitlab/auth-storage.js';
 import { refreshGitLabAccessToken, resolveGitLabClientId } from '../gitlab/device-flow.js';
 import { createGitCredentialResolver, createHttpsCredentialReference, parseGitCredentialReference } from '../git/credential-resolver.js';
@@ -110,6 +111,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
   let walkthroughBindingService = null;
   let gitRepositoryCredentialRuntime = null;
   let networkOperations = null;
+  let gitWorktreeCreation = null;
   const getWalkthroughService = async () => {
     if (!walkthroughService) {
       const [service, pullRequest] = await Promise.all([
@@ -171,6 +173,30 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     });
   };
 
+  /**
+   * A worktree from a pull or merge request given by number, the same kind
+   * the New worktree dialog makes: the server reads the change request with
+   * the project's own account and creates the worktree through the Git
+   * routes' contributor pipeline. `name` and `branchName` default to the
+   * change request's head branch.
+   */
+  const createChangeRequestWorktree = async ({ directory, number, name, branchName }) => {
+    if (!(gitWorktreeCreation?.createWorktree instanceof Function)
+      || !(walkthroughBindingService?.resolveChangeRequestWorktreeSource instanceof Function)) {
+      throw Object.assign(new Error('Worktrees from pull requests are unavailable'), {
+        code: 'RUNTIME_UNSUPPORTED', status: 501,
+      });
+    }
+    const { headBranch, sourceRequest } = await walkthroughBindingService.resolveChangeRequestWorktreeSource({ directory, number });
+    const branch = branchName || headBranch;
+    return gitWorktreeCreation.createWorktree(directory, {
+      mode: 'existing',
+      branchName: branch,
+      worktreeName: name || branch,
+      changeRequestSource: sourceRequest,
+    });
+  };
+
   const registerRoutes = async (app, routeDependencies) => {
     const {
       messageSearchRuntime,
@@ -326,6 +352,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       getAgentSources,
       getAgentConfig,
       getAgentPermissions,
+      listDisabledAgents,
       createAgent,
       updateAgent,
       deleteAgent,
@@ -370,44 +397,6 @@ export const createFeatureRoutesRuntime = (dependencies) => {
 
     const { getProfiles, getProfile, getGlobalIdentity, resolveRepositoryGitPaths } = await import('../git/index.js');
 
-    registerSkillRoutes(app, {
-      fs,
-      path,
-      os,
-      resolveProjectDirectory,
-      resolveOptionalProjectDirectory,
-      readSettingsFromDisk,
-      sanitizeSkillCatalogs,
-      isUnsafeSkillRelativePath,
-      refreshOpenCodeAfterConfigChange,
-      clientReloadDelayMs,
-      buildOpenCodeUrl,
-      getOpenCodeAuthHeaders,
-      getOpenCodePort,
-      getSkillSources,
-      discoverSkills,
-      mergeDiscoveredSkills,
-      createSkill,
-      updateSkill,
-      deleteSkill,
-      renameSkill,
-      isManagedSkillPath,
-      readSkillSupportingFile,
-      writeSkillSupportingFile,
-      deleteSkillSupportingFile,
-      SKILL_SCOPE,
-      SKILL_DIR,
-      getCuratedSkillsSources,
-      getCacheKey,
-      scanWithCache,
-      parseSkillRepoSource,
-      scanSkillsRepository,
-      installSkillsFromRepository,
-      fetchGitHubRepoMetas,
-      getProfiles,
-      getProfile,
-    });
-
     registerQuotaRoutes(app, { getQuotaProviders });
     registerSmallModelRoutes(app, { getSmallModelService });
     registerSessionGoalRoutes(app);
@@ -419,12 +408,23 @@ export const createFeatureRoutesRuntime = (dependencies) => {
         origin, refreshToken, clientId: await resolveGitLabClientId(origin, readSettingsFromDisk),
       }),
     });
-    const resolveSourceControlAccount = ({ provider, instance, accountId, credentialRevision }) => provider === 'github'
-      ? getGitHubAuthByAccountId(accountId, credentialRevision)
-      : gitlabAuthStore.readAccount(instance, accountId, credentialRevision);
+    // A GitHub account is either one OpenChamber stores or the gh CLI login
+    // the user switched to; reads already accept both, so Git transport
+    // (fork PR worktrees, clones) must too.
+    const resolveSourceControlAccount = async ({ provider, instance, accountId, credentialRevision }) => {
+      if (provider !== 'github') return gitlabAuthStore.readAccount(instance, accountId, credentialRevision);
+      return await getGitHubAuthByAccountId(accountId, credentialRevision)
+        ?? getGitHubCliCredential(accountId, credentialRevision);
+    };
     const resolveTransportRepository = createPrivateRepositoryIdentityResolver({
       getTransportRevision: (directory) => readEffectiveGitTransportRevision(directory, { gitBinary }),
     });
+    const contributorProvenance = createContributorProvenanceStore({
+      filePath: path.join(openchamberDataDir, 'git-contributor-provenance.json'),
+      resolveRepositoryIdentity: resolveTransportRepository,
+      resolveGitPaths: resolveRepositoryGitPaths,
+      fsImpl: fsPromises,
+    });
     const sourceControlAuditStore = createSourceControlAuditStore({
       filePath: path.join(openchamberDataDir, 'source-control-audit.json'),
       fsImpl: fsPromises,
@@ -479,6 +479,11 @@ export const createFeatureRoutesRuntime = (dependencies) => {
         });
         return inspection.requirements.find((entry) => entry.kind === kind && entry.path === checkoutPath) ?? null;
       },
+      github: {
+        // A worktree made from a fork PR has no upstream; its provenance says
+        // which remote the branch came from, so PR status can find the PR.
+        readContributorProvenance: contributorProvenance.read,
+      },
       gitlab: {
         configRoot: openchamberDataDir,
         store: gitlabAuthStore,
@@ -558,12 +563,6 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       if (!profile) throw new Error('Git identity profile is unavailable');
       return profile;
     };
-    const contributorProvenance = createContributorProvenanceStore({
-      filePath: path.join(openchamberDataDir, 'git-contributor-provenance.json'),
-      resolveRepositoryIdentity: resolveTransportRepository,
-      resolveGitPaths: resolveRepositoryGitPaths,
-      fsImpl: fsPromises,
-    });
     const networkOperationStore = createGitNetworkOperationStore({
       filePath: path.join(openchamberDataDir, 'git-network-operations.json'),
       fsImpl: fsPromises,
@@ -579,6 +578,46 @@ export const createFeatureRoutesRuntime = (dependencies) => {
       fsImpl: fsPromises,
       snapshotRoot: path.join(openchamberDataDir, 'git-ssh-operation-keys'),
     });
+    registerSkillRoutes(app, {
+      fs,
+      path,
+      os,
+      resolveProjectDirectory,
+      resolveOptionalProjectDirectory,
+      readSettingsFromDisk,
+      sanitizeSkillCatalogs,
+      isUnsafeSkillRelativePath,
+      refreshOpenCodeAfterConfigChange,
+      clientReloadDelayMs,
+      buildOpenCodeUrl,
+      getOpenCodeAuthHeaders,
+      getOpenCodePort,
+      getSkillSources,
+      discoverSkills,
+      mergeDiscoveredSkills,
+      createSkill,
+      updateSkill,
+      deleteSkill,
+      renameSkill,
+      isManagedSkillPath,
+      readSkillSupportingFile,
+      writeSkillSupportingFile,
+      deleteSkillSupportingFile,
+      SKILL_SCOPE,
+      SKILL_DIR,
+      getCuratedSkillsSources,
+      getCacheKey,
+      scanWithCache,
+      parseSkillRepoSource,
+      scanSkillsRepository,
+      installSkillsFromRepository,
+      fetchGitHubRepoMetas,
+      getProfiles,
+      getProfile,
+      createHttpsCredentialReference,
+      resolveSourceControlAccount,
+      credentialResolver: gitCredentialResolver,
+    });
     gitRepositoryCredentialRuntime = createGitRepositoryCredentialRuntime({
       readBinding: (directory) => walkthroughBindingService.get(directory),
       credentialResolver: gitCredentialResolver,
@@ -612,7 +651,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
     });
     await registerBuiltInGuests({ persistPath: extensionsPersistPath(openchamberDataDir), root: routeDependencies.builtInExtensionsDir });
     registerGuestRoutes(app, { openchamberDataDir, openchamberVersion, resolveGitBinaryForSpawn, resolveOptionalProjectDirectory, getSmallModelService, onGuestDeactivated, surfaceViewerHeaders });
-    registerGitRoutes(app, {
+    gitWorktreeCreation = registerGitRoutes(app, {
       // Identities for accounts connected before identities carried one are
       // made the first time identities are listed: a moment someone asked for,
       // not startup, where a development restart can kill a process holding a
@@ -689,6 +728,7 @@ export const createFeatureRoutesRuntime = (dependencies) => {
   return {
     registerRoutes,
     hydrateBoundCheckout,
+    createChangeRequestWorktree,
     /** Writes the Git credential helper's endpoint file; a no-op until the Git routes are registered. */
     publishRepositoryCredentialEndpoint: async () => { await gitRepositoryCredentialRuntime?.publish(); },
   };

package/server/lib/opencode/lifecycle.js

@@ -3,6 +3,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { accessSync, constants as fsConstants, statSync } from 'node:fs';
 import net from 'node:net';
 import { stripAppImageArgv0Leak, stripAppImageLauncherEnv } from '../inherited-env.js';
+import { assignInjectedEnv } from '../injected-env.js';
 import { registerManagedProcess, unregisterManagedProcess, reapOrphanedProcesses } from './managed-process-registry.js';
 import { applyProviderEnvAliases } from './provider-env-aliases.js';
 import { overlayEnvironment } from '../environment/variables.js';
@@ -137,12 +138,21 @@ export const createOpenCodeLifecycleControls = ({
       return Promise.reject(new Error('Shared OpenCode recovery is not configured'));
     }
     if (!sharedRecoveryPromise) {
-      sharedRecoveryPromise = Promise.resolve()
-        .then(() => recoverShared())
-        .then(() => onSharedRecovered())
-        .finally(() => {
-          sharedRecoveryPromise = null;
-        });
+      const recovery = Promise.resolve(recoverShared())
+        .then(() => onSharedRecovered());
+      sharedRecoveryPromise = recovery;
+      void recovery.then(
+        () => {
+          if (sharedRecoveryPromise === recovery) {
+            sharedRecoveryPromise = null;
+          }
+        },
+        () => {
+          if (sharedRecoveryPromise === recovery) {
+            sharedRecoveryPromise = null;
+          }
+        },
+      );
     }
     return sharedRecoveryPromise;
   };
@@ -269,6 +279,10 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     getActiveSessionCount = () => 0,
     reapManagedOrphanedProcesses = reapOrphanedProcesses,
     getWarmupDirectories = async () => [],
+    // Scopes server-side reads while no project directory is usable (the
+    // managed chats root). Without it they name no directory, and OpenCode
+    // starts a location over its own working directory, the whole home.
+    noProjectDirectory = null,
     onOpenCodeRestarted = null,
     managedStartupTimeoutMs = 30_000,
     now = Date.now,
@@ -899,16 +913,20 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
     // in front of the managed PATH) and under everything OpenChamber itself
     // sets for OpenCode.
     const inheritedEnv = overlayEnvironment({ ...shellEnv, ...process.env, PATH: envPath }, getUserEnvironment());
-    const processEnv = stripAppImageLauncherEnv(stripAppImageArgv0Leak(applyProviderEnvAliases({
-      ...inheritedEnv,
-      ...managedOpenCodeEnv,
-      PATH: inheritedEnv.PATH,
-      // OpenCode 2 reads OPENCODE_PASSWORD before the legacy name, so a
-      // user's own OPENCODE_PASSWORD would otherwise win and every request
-      // we send with openCodePassword would get 401.
-      OPENCODE_PASSWORD: openCodePassword,
-      OPENCODE_SERVER_PASSWORD: openCodePassword,
-    })));
+    // What OpenChamber sets for OpenCode is recorded as injected, so a shell
+    // the agent opens can tell it from the user's own variables.
+    const processEnv = stripAppImageLauncherEnv(stripAppImageArgv0Leak(applyProviderEnvAliases(assignInjectedEnv(
+      { ...inheritedEnv },
+      {
+        ...managedOpenCodeEnv,
+        PATH: inheritedEnv.PATH,
+        // OpenCode 2 reads OPENCODE_PASSWORD before the legacy name, so a
+        // user's own OPENCODE_PASSWORD would otherwise win and every request
+        // we send with openCodePassword would get 401.
+        OPENCODE_PASSWORD: openCodePassword,
+        OPENCODE_SERVER_PASSWORD: openCodePassword,
+      },
+    ))));
     managedProcessEnv = processEnv;
 
     let serverInstance;
@@ -1416,8 +1434,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
         const usable = selectUsableDirectory(warmedOpenCodeDirectories);
         if (usable) defaultOpenCodeDirectory = usable;
       } catch {
-        // Best-effort: the caller falls back to OpenCode's working directory
-        // for this read and the refresh can succeed next time.
+        // Best-effort: the caller falls back to the no-project directory or
+        // OpenCode's working directory for this read, and the refresh can
+        // succeed next time.
       } finally {
         defaultDirectoryRefresh = null;
       }
@@ -1426,8 +1445,9 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
   };
 
   // The warmed directory only while it is still usable; otherwise another
-  // usable directory (from this or a refreshed pass), or null so the caller
-  // sends no directory and OpenCode uses its own working directory.
+  // usable directory (from this or a refreshed pass), else the no-project
+  // directory, else null so the caller sends no directory and OpenCode uses
+  // its own working directory.
   const getValidatedDefaultDirectory = () => {
     if (isUsableDirectory(defaultOpenCodeDirectory)) return defaultOpenCodeDirectory;
     const alternate = selectUsableDirectory(warmedOpenCodeDirectories);
@@ -1440,7 +1460,7 @@ export const createOpenCodeLifecycleRuntime = (deps) => {
       defaultDirectoryRefreshAt = checkedAt;
       void refreshDefaultDirectories();
     }
-    return null;
+    return isUsableDirectory(noProjectDirectory) ? noProjectDirectory : null;
   };
 
   // OpenCode initializes each project directory lazily on its first

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

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
+import { injectedEnvKeys } from '../injected-env.js';
+
 const spawnMock = vi.fn();
 const spawnSyncMock = vi.fn();
 const recordStartupPerformanceMock = vi.fn();
@@ -581,6 +583,45 @@ describe('OpenCode lifecycle', () => {
     await fs.rm(root, { recursive: true, force: true });
   });
 
+  it('scopes default reads to the chats root while no project directory is usable', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-no-project-'));
+    const chats = path.join(root, 'chats');
+    const project = path.join(root, 'project');
+    await fs.mkdir(chats);
+    await fs.mkdir(project);
+    let warmup = [];
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      json: async () => ({ version: '2.0.20', pid: 1, urls: [], paths: { tmp: '/tmp' } }),
+    }));
+    const runtime = createRuntime({
+      env: {
+        ENV_CONFIGURED_OPENCODE_PORT: 45678,
+        ENV_CONFIGURED_OPENCODE_HOST: null,
+        ENV_EFFECTIVE_PORT: 45678,
+        ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1',
+        ENV_SKIP_OPENCODE_START: true,
+      },
+      reapManagedOrphanedProcesses: vi.fn(async () => ({ reaped: 0 })),
+      getWarmupDirectories: vi.fn(async () => warmup),
+      noProjectDirectory: chats,
+    });
+
+    await runtime.bootstrapOpenCodeAtStartup();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    // No project: a read without a directory would start OpenCode over the
+    // whole home, its working directory.
+    expect(runtime.getDefaultOpenCodeDirectory()).toBe(chats);
+    expect(globalThis.fetch.mock.calls.filter(([url]) => String(url).endsWith('/api/location'))).toEqual([]);
+
+    // A project opened later takes over once the warmup source names it.
+    warmup = [project];
+    await runtime.bootstrapOpenCodeAtStartup();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(runtime.getDefaultOpenCodeDirectory()).toBe(project);
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
   it('advances to a currently-valid warmup directory when the cached default goes stale', async () => {
     const root = await fs.mkdtemp(path.join(os.tmpdir(), 'oc-replace-'));
     const stale = path.join(root, 'gone');
@@ -776,12 +817,12 @@ describe('OpenCode lifecycle', () => {
     }
 
     expect(close).not.toHaveBeenCalled();
-    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledTimes(4);
 
     now += 15_000;
     await runtime.triggerHealthCheck();
 
-    expect(warn).toHaveBeenCalledTimes(2);
+    expect(warn).toHaveBeenCalledTimes(5);
     expect(warn).toHaveBeenLastCalledWith(expect.stringContaining('(2/20)'));
     warn.mockRestore();
   });
@@ -1212,6 +1253,13 @@ describe('OpenCode lifecycle', () => {
     expect(options.env.OPENCODE_PASSWORD).toBe('password');
     expect(options.env.OPENCHAMBER_AGENT_TOOL_TOKEN).toBe('ephemeral');
     expect(runtime.getManagedOpenCodeProcessEnv().DATABASE_URL).toBe('postgres://db');
+    // The replaced values are recorded as OpenChamber's; the user's are not.
+    const injected = injectedEnvKeys(options.env);
+    for (const key of ['OPENCODE_PASSWORD', 'OPENCODE_SERVER_PASSWORD', 'OPENCHAMBER_AGENT_TOOL_TOKEN']) {
+      expect(injected.has(key)).toBe(true);
+    }
+    expect(injected.has('DATABASE_URL')).toBe(false);
+    expect(injected.has('PATH')).toBe(false);
 
     await server.close();
   });

package/server/lib/opencode/model-discovery.js

@@ -319,7 +319,7 @@ export async function discoverProviderModels(input, options = {}) {
   const storedApiKey = isSameEndpoint(options.storedBaseURL, body.baseURL)
     ? optionalString(options.storedApiKey)
     : null;
-  const apiKey = requestedApiKey ?? storedApiKey;
+  const apiKey = requestedApiKey ?? resolveApiKey(storedApiKey, env);
   const response = await (options.fetch ?? fetch)(endpoint, {
     method: 'GET',
     headers: buildHeaders(body.headers, apiKey, env),

package/server/lib/opencode/model-discovery.test.js

@@ -89,6 +89,23 @@ describe('provider model discovery', () => {
     expect(requests).toEqual(['Bearer stored-key', 'Bearer replacement-key']);
   });
 
+  test('resolves environment variables in stored keys', async () => {
+    const requests = [];
+    const fetchMock = async (_url, init) => {
+      requests.push(init.headers.Authorization);
+      return new Response(JSON.stringify({ data: [{ id: 'local' }] }), { status: 200 });
+    };
+
+    await discoverProviderModels({ baseURL: 'https://provider.test', enrich: false }, {
+      fetch: fetchMock,
+      storedApiKey: '{env:STORED_KEY}',
+      storedBaseURL: 'https://provider.test',
+      env: { STORED_KEY: 'resolved-secret' },
+    });
+
+    expect(requests).toEqual(['Bearer resolved-secret']);
+  });
+
   test('never sends the stored key to a base URL other than the saved one', async () => {
     const requests = [];
     const fetchMock = async (_url, init) => {

package/server/lib/opencode/models-metadata.js

@@ -57,5 +57,3 @@ export async function getModelsMetadata({
     throw error;
   }
 }
-
-export { MODELS_DEV_API_URL };

package/server/lib/opencode/openchamber-routes.test.js

@@ -83,7 +83,7 @@ beforeEach(() => {
   packageManager.detectPackageManagerDetails.mockReturnValue({
     packageManager: 'npm',
   });
-  packageManager.getUpdateCommand.mockReturnValue('npm install -g @openchamber/web@latest');
+  packageManager.getUpdateCommand.mockReturnValue('npm install -g @vantran-se/openchamber-web@latest');
 });
 
 afterEach(() => {
@@ -308,7 +308,7 @@ describe('OpenChamber foreground update route', () => {
       '--setenv=PATH=/home/syu/.npm-global/bin:/usr/bin:/bin',
       '/bin/sh',
       '-c',
-      "set -eu\nnpm install -g @openchamber/web@latest\nsystemctl --user restart 'openchamber@wsl.service'",
+      "set -eu\nnpm install -g @vantran-se/openchamber-web@latest\nsystemctl --user restart 'openchamber@wsl.service'",
     ], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -480,7 +480,7 @@ describe('OpenChamber web update route on Windows', () => {
     // The UI password is never part of the script or its log.
     expect(script).not.toContain('pa%');
     // A .cmd shim (npm, pnpm, yarn) must be `call`ed or the script ends there.
-    expect(lines).toContain('call npm install -g @openchamber/web@latest');
+    expect(lines).toContain('call npm install -g @vantran-se/openchamber-web@latest');
     expect(lines).toContain('ping -n 3 127.0.0.1 >nul');
     expect(lines.some((line) => line.startsWith('timeout '))).toBe(false);
     expect(lines).toContain('if %ERRORLEVEL% EQU 0 (');