@openchambery/web 2.0.0-beta.1 → 2.0.0-beta.4

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

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'node:events';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+
+import {
+  buildSharedServiceStartEnv,
+  isSharedServiceEnabled,
+  parseSharedServiceRegistration,
+  readSharedServiceRegistration,
+  resolveSharedServiceRegistrationPath,
+  startSharedOpenCodeService,
+} from './shared-service.js';
+
+const fakeChild = () => {
+  const child = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.kill = vi.fn();
+  return child;
+};
+
+describe('shared OpenCode service registration', () => {
+  it('resolves the stable-channel registration under the XDG state root', () => {
+    expect(resolveSharedServiceRegistrationPath({}, '/home/u')).toBe(path.join('/home/u', '.local', 'state', 'opencode', 'service.json'));
+    expect(resolveSharedServiceRegistrationPath({ XDG_STATE_HOME: '/xdg' }, '/home/u')).toBe(path.join('/xdg', 'opencode', 'service.json'));
+  });
+
+  it('parses a registration and rejects malformed ones', () => {
+    expect(parseSharedServiceRegistration(JSON.stringify({
+      id: 'a', version: '2.0.12', url: 'http://127.0.0.1:49374', pid: 42, password: 'pw',
+    }))).toEqual({ origin: 'http://127.0.0.1:49374', port: 49374, pid: 42, password: 'pw', version: '2.0.12' });
+    expect(parseSharedServiceRegistration(JSON.stringify({ url: 'http://127.0.0.1:49374' }))?.password).toBeNull();
+    expect(parseSharedServiceRegistration('not json')).toBeNull();
+    expect(parseSharedServiceRegistration(JSON.stringify({ url: 'ftp://x:1' }))).toBeNull();
+    expect(parseSharedServiceRegistration(JSON.stringify({ url: 'http://127.0.0.1' }))).toBeNull();
+  });
+
+  it('treats a missing registration file as absent, not as a service', async () => {
+    const fsLike = { readFile: vi.fn(async () => { throw Object.assign(new Error('nope'), { code: 'ENOENT' }); }) };
+    await expect(readSharedServiceRegistration({ file: '/x/service.json', fsLike })).resolves.toBeNull();
+  });
+
+  it('is enabled by default and can be opted out', () => {
+    expect(isSharedServiceEnabled({})).toBe(true);
+    expect(isSharedServiceEnabled({ OPENCHAMBER_OPENCODE_SHARED_SERVICE: '0' })).toBe(false);
+    expect(isSharedServiceEnabled({ OPENCHAMBER_OPENCODE_SHARED_SERVICE: 'false' })).toBe(false);
+  });
+});
+
+describe('shared OpenCode service start', () => {
+  it('never hands OpenChamber credentials to the long-lived service', () => {
+    expect(buildSharedServiceStartEnv({
+      PATH: '/bin',
+      HOME: '/home/u',
+      OPENCODE_SERVER_PASSWORD: 'managed',
+      OPENCODE_PASSWORD: 'managed',
+      OPENCHAMBER_UI_PASSWORD: 'ui',
+      OPENCHAMBER_DATA_DIR: '/data',
+    })).toEqual({ PATH: '/bin', HOME: '/home/u' });
+  });
+
+  it('runs `service start` and resolves on a clean exit', async () => {
+    const child = fakeChild();
+    const spawnImpl = vi.fn(() => {
+      queueMicrotask(() => child.emit('exit', 0));
+      return child;
+    });
+    await startSharedOpenCodeService({ binary: '/bin/opencode', args: ['--x'], env: { PATH: '/bin' }, spawnImpl });
+    expect(spawnImpl).toHaveBeenCalledWith('/bin/opencode', ['--x', 'service', 'start'], expect.objectContaining({ env: { PATH: '/bin' } }));
+  });
+
+  it('surfaces the CLI error when `service start` fails', async () => {
+    const child = fakeChild();
+    const spawnImpl = vi.fn(() => {
+      queueMicrotask(() => {
+        child.stderr.emit('data', 'Background service failed to start');
+        child.emit('exit', 1);
+      });
+      return child;
+    });
+    await expect(startSharedOpenCodeService({ binary: 'opencode', env: {}, spawnImpl }))
+      .rejects.toThrow(/exited with code 1: Background service failed to start/);
+  });
+
+  it('replaces the registered service only for an explicit upgrade', async () => {
+    const child = fakeChild();
+    const spawnImpl = vi.fn(() => {
+      queueMicrotask(() => child.emit('exit', 0));
+      return child;
+    });
+    await startSharedOpenCodeService({ binary: '/cache/opencode', env: {}, replace: true, spawnImpl });
+    expect(spawnImpl).toHaveBeenCalledWith('/cache/opencode', ['service', 'restart'], expect.objectContaining({ windowsHide: true }));
+  });
+});

package/server/lib/opencode/shared.js

@@ -371,9 +371,9 @@ function addSkillFromMdFile(skillsMap, skillMdPath, scope, source) {
     return;
   }
 
-  const name = typeof parsed.frontmatter?.name === 'string'
-    ? parsed.frontmatter.name.trim()
-    : '';
+  const name = path.basename(skillMdPath) === 'SKILL.md'
+    ? path.basename(path.dirname(skillMdPath))
+    : path.basename(skillMdPath, '.md');
   const description = typeof parsed.frontmatter?.description === 'string'
     ? parsed.frontmatter.description
     : '';

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

@@ -1,3 +1,5 @@
+import { forceCloseHttpServerConnections } from './http-server-connections.js';
+
 export const createGracefulShutdownRuntime = (dependencies) => {
   const {
     process,
@@ -22,7 +24,6 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     getOpenCodePort,
     getOpenCodeProcess,
     setOpenCodeProcess,
-    killProcessOnPort,
     waitForPortRelease,
     getServer,
     getUiAuthController,
@@ -78,12 +79,14 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     }
 
     if (!shouldSkipOpenCodeStop()) {
-      const portToKill = getOpenCodePort();
+      const portToRelease = getOpenCodePort();
       const openCodeProcess = getOpenCodeProcess();
 
       if (openCodeProcess) {
         console.log('Stopping OpenCode process...');
         try {
+          // close() owns SIGTERM→SIGKILL on this child handle. Never re-kill a
+          // numeric pid captured before close — it may already be recycled.
           await openCodeProcess.close();
         } catch (error) {
           console.warn('Error closing OpenCode process:', error);
@@ -91,9 +94,9 @@ export const createGracefulShutdownRuntime = (dependencies) => {
         setOpenCodeProcess(null);
       }
 
-      killProcessOnPort(portToKill);
-      if (!(await waitForPortRelease(portToKill, 5000))) {
-        console.warn(`Timed out waiting for OpenCode port ${portToKill} to be released during shutdown`);
+      // Probe only after owned close. Do not mass-kill by port (clients / external).
+      if (!(await waitForPortRelease(portToRelease, 5000))) {
+        console.warn(`Timed out waiting for OpenCode port ${portToRelease} to be released during shutdown`);
       }
     } else {
       console.log('Skipping OpenCode shutdown (external server)');
@@ -105,12 +108,18 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       try {
         await Promise.race([
           new Promise((resolve) => {
+            // Stop accepting first. closeAllConnections drops plain HTTP sockets
+            // but leaves upgraded WS/SSE; destroy tracked server-owned leftovers
+            // so the close callback can fire without waiting SHUTDOWN_TIMEOUT.
             server.close(() => {
               console.log('HTTP server closed');
               resolve();
             });
             if (options.forceCloseConnections === true) {
-              server.closeAllConnections?.();
+              const { destroyedTracked } = forceCloseHttpServerConnections(server);
+              if (destroyedTracked > 0) {
+                console.log(`Forced close of ${destroyedTracked} remaining server socket(s)`);
+              }
             }
           }),
           new Promise((resolve) => {

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

@@ -22,7 +22,6 @@ const createRuntime = (server, shutdownTimeoutMs = 1000, overrides = {}) => crea
   getOpenCodePort: () => null,
   getOpenCodeProcess: () => null,
   setOpenCodeProcess: vi.fn(),
-  killProcessOnPort: vi.fn(),
   waitForPortRelease: vi.fn(async () => true),
   getServer: () => server,
   getUiAuthController: () => null,
@@ -96,4 +95,53 @@ describe('graceful shutdown runtime', () => {
     expect(scheduledTasksRuntime.stop).toHaveBeenCalledOnce();
     expect(runHistoryStore.close).not.toHaveBeenCalled();
   });
+
+  it('awaits managed OpenCode close with zero extra kill, then probes port release for 5s', async () => {
+    const close = vi.fn(async () => undefined);
+    const waitForPortRelease = vi.fn(async (_port, timeoutMs) => {
+      expect(timeoutMs).toBe(5000);
+      return true;
+    });
+    const setOpenCodeProcess = vi.fn();
+    const server = {
+      close: vi.fn((callback) => {
+        callback();
+      }),
+    };
+
+    const runtime = createRuntime(server, 1000, {
+      shouldSkipOpenCodeStop: () => false,
+      getOpenCodePort: () => 45678,
+      getOpenCodeProcess: () => ({ close, pid: 99 }),
+      setOpenCodeProcess,
+      waitForPortRelease,
+    });
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(close).toHaveBeenCalledOnce();
+    expect(setOpenCodeProcess).toHaveBeenCalledWith(null);
+    expect(waitForPortRelease).toHaveBeenCalledWith(45678, 5000);
+  });
+
+  it('does not kill anything when OpenCode close already finished and a later server stage fails', async () => {
+    const close = vi.fn(async () => undefined);
+    const waitForPortRelease = vi.fn(async () => true);
+    const server = {
+      close: vi.fn(() => {
+        throw new Error('server close blew up after opencode stop');
+      }),
+    };
+
+    const runtime = createRuntime(server, 1000, {
+      shouldSkipOpenCodeStop: () => false,
+      getOpenCodePort: () => 45678,
+      getOpenCodeProcess: () => ({ close, pid: 99 }),
+      setOpenCodeProcess: vi.fn(),
+      waitForPortRelease,
+    });
+
+    await expect(runtime.gracefulShutdown({ exitProcess: false })).rejects.toThrow(/server close blew up/);
+    expect(close).toHaveBeenCalledOnce();
+    expect(waitForPortRelease).toHaveBeenCalledWith(45678, 5000);
+  });
 });

package/server/lib/opencode/skill-routes.js

@@ -16,8 +16,6 @@ export const registerSkillRoutes = (app, dependencies) => {
     readSettingsFromDisk,
     sanitizeSkillCatalogs,
     isUnsafeSkillRelativePath,
-    refreshOpenCodeAfterConfigChange,
-    clientReloadDelayMs,
     buildOpenCodeUrl,
     getOpenCodeAuthHeaders,
     getOpenCodePort,
@@ -130,11 +128,12 @@ export const registerSkillRoutes = (app, dependencies) => {
       const client = OpenCode.make({
         baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
         headers: getOpenCodeAuthHeaders(),
-        fetch: (request) => fetch(request, { signal: AbortSignal.timeout(8_000) }),
+        fetch: globalThis.fetch,
       });
 
       const response = await client.skill.list(
         workingDirectory ? { location: { directory: workingDirectory } } : undefined,
+        { signal: AbortSignal.timeout(8_000) },
       );
       const payload = response?.data;
       if (!Array.isArray(payload)) {
@@ -143,8 +142,9 @@ export const registerSkillRoutes = (app, dependencies) => {
 
       return payload
         .map((item) => {
-          const name = typeof item?.name === 'string' ? item.name.trim() : '';
-          const location = typeof item?.location === 'string' ? item.location : '';
+          // OpenChamber's name is the invocation key, not the V2 display label.
+          const name = typeof item?.id === 'string' ? item.id : '';
+          const location = typeof item?.path === 'string' ? item.path : '';
           const description = typeof item?.description === 'string' ? item.description : '';
           const content = typeof item?.content === 'string' ? item.content : '';
           if (!name || !location) {
@@ -461,19 +461,14 @@ export const registerSkillRoutes = (app, dependencies) => {
 
         const installed = result.installed || [];
         const skipped = result.skipped || [];
-        const requiresReload = installed.length > 0;
-
-        if (requiresReload) {
-          await refreshOpenCodeAfterConfigChange('skills install');
-        }
 
         return res.json({
           ok: true,
           installed,
           skipped,
-          requiresReload,
-          message: requiresReload ? 'Skills installed successfully. Reloading interface…' : 'No skills were installed',
-          reloadDelayMs: requiresReload ? clientReloadDelayMs : undefined,
+          requiresReload: false,
+          application: 'watch',
+          message: installed.length > 0 ? 'Skills installed successfully.' : 'No skills were installed',
         });
       }
 
@@ -512,19 +507,14 @@ export const registerSkillRoutes = (app, dependencies) => {
 
       const installed = result.installed || [];
       const skipped = result.skipped || [];
-      const requiresReload = installed.length > 0;
-
-      if (requiresReload) {
-        await refreshOpenCodeAfterConfigChange('skills install');
-      }
 
       res.json({
         ok: true,
         installed,
         skipped,
-        requiresReload,
-        message: requiresReload ? 'Skills installed successfully. Reloading interface…' : 'No skills were installed',
-        reloadDelayMs: requiresReload ? clientReloadDelayMs : undefined,
+        requiresReload: false,
+        application: 'watch',
+        message: installed.length > 0 ? 'Skills installed successfully.' : 'No skills were installed',
       });
     } catch (error) {
       console.error('Failed to install skills:', error);
@@ -605,13 +595,12 @@ export const registerSkillRoutes = (app, dependencies) => {
       console.log('[Server] Scope:', scope, 'Working directory:', directory);
 
       createSkill(skillName, { ...config, source: skillSource }, directory, scope);
-      await refreshOpenCodeAfterConfigChange('skill creation');
 
       res.json({
         success: true,
-        requiresReload: true,
-        message: `Skill ${skillName} created successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
+        requiresReload: false,
+        application: 'watch',
+        message: `Skill ${skillName} created successfully.`,
       });
     } catch (error) {
       console.error('Failed to create skill:', error);
@@ -632,13 +621,12 @@ export const registerSkillRoutes = (app, dependencies) => {
       console.log('[Server] Working directory:', directory);
 
       updateSkill(skillName, updates, directory, updates?.targetPath);
-      await refreshOpenCodeAfterConfigChange('skill update');
 
       res.json({
         success: true,
-        requiresReload: true,
-        message: `Skill ${skillName} updated successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
+        requiresReload: false,
+        application: 'watch',
+        message: `Skill ${skillName} updated successfully.`,
       });
     } catch (error) {
       console.error('[Server] Failed to update skill:', error);
@@ -724,13 +712,12 @@ export const registerSkillRoutes = (app, dependencies) => {
       }
 
       deleteSkill(skillName, directory);
-      await refreshOpenCodeAfterConfigChange('skill deletion');
 
       res.json({
         success: true,
-        requiresReload: true,
-        message: `Skill ${skillName} deleted successfully. Reloading interface…`,
-        reloadDelayMs: clientReloadDelayMs,
+        requiresReload: false,
+        application: 'watch',
+        message: `Skill ${skillName} deleted successfully.`,
       });
     } catch (error) {
       console.error('Failed to delete skill:', error);

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

@@ -8,12 +8,45 @@ const { OpenCode } = await import('@opencode/client');
 const { registerSkillRoutes } = await import('./skill-routes.js');
 
 describe('skill summary route', () => {
+  it('preserves authentication and directory through the real V2 SDK transport', async () => {
+    const { OpenCode: RealOpenCode } = await vi.importActual('@opencode/client');
+    const upstreamRequests = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async (url, init) => {
+      upstreamRequests.push(new Request(url, init));
+      return Response.json({ location: { directory: '/repo' }, data: [{
+        id: 'agent-tracker-api', name: 'Runmark', path: '/skills/agent-tracker-api/SKILL.md',
+        description: 'Query Runmark API', content: 'Instructions',
+      }] });
+    };
+    OpenCode.make.mockImplementation(RealOpenCode.make);
+    try {
+      const app = express();
+      registerSkillRoutes(app, {
+        fs: { existsSync: () => false }, path: await import('node:path'), os: await import('node:os'),
+        resolveOptionalProjectDirectory: async () => ({ directory: '/repo' }),
+        buildOpenCodeUrl: () => 'http://opencode-upstream:4096/',
+        getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic example' }), getOpenCodePort: () => 4096,
+        SKILL_SCOPE: { PROJECT: 'project', USER: 'user' }, discoverSkills: () => [], mergeDiscoveredSkills: (skills) => skills,
+      });
+      const response = await request(app).get('/api/config/skills?summary=true').expect(200);
+      expect(response.body.skills[0].name).toBe('agent-tracker-api');
+      expect(upstreamRequests).toHaveLength(1);
+      expect(upstreamRequests[0].headers.get('authorization')).toBe('Basic example');
+      expect(upstreamRequests[0].url).toContain(encodeURIComponent('/repo'));
+    } finally {
+      globalThis.fetch = originalFetch;
+      OpenCode.make.mockReset();
+    }
+  });
+
   it('returns compact normalized skill data without content or sources', async () => {
     OpenCode.make.mockReturnValue({
       skill: {
         list: vi.fn(async () => ({ data: [{
-          name: 'skill',
-          location: '/repo/.opencode/skills/skill/SKILL.md',
+          id: 'skill',
+          name: 'Skill Display Name',
+          path: '/repo/.opencode/skills/skill/SKILL.md',
           description: ` ${'😀'.repeat(161)}\nnext `,
           content: 'secret skill content',
         }] })),

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

@@ -3,8 +3,23 @@ import fsPromises from 'fs/promises';
 import os from 'os';
 import path from 'path';
 import { getSkillSources, mergeDiscoveredSkills } from './skills.js';
+import { addSkillFromMdFile } from './shared.js';
 
 describe('skills', () => {
+  it('uses the path-derived id even when frontmatter has a different display name', async () => {
+    const root = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'oc-skill-id-'));
+    try {
+      const dir = path.join(root, 'release');
+      await fsPromises.mkdir(dir);
+      const file = path.join(dir, 'SKILL.md');
+      await fsPromises.writeFile(file, '---\nname: Git Release\ndescription: Release notes\n---\nInstructions');
+      const skills = new Map();
+      addSkillFromMdFile(skills, file, 'project', 'opencode');
+      expect([...skills.keys()]).toEqual(['release']);
+    } finally {
+      await fsPromises.rm(root, { recursive: true, force: true });
+    }
+  });
   it('merges locally discovered skills missing from OpenCode live discovery', () => {
     const merged = mergeDiscoveredSkills(
       [

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

@@ -23,6 +23,8 @@ export const createStartupPipelineRuntime = (dependencies) => {
       getOpenCodeAuthHeaders,
       globalEventHub,
       processForwardedEventPayload,
+      projectOutboundSessionPayload = null,
+      ensureSessionMetadataReady = null,
       messageStreamWsClients,
       triggerHealthCheck,
       upstreamStallTimeoutMs,
@@ -83,6 +85,8 @@ export const createStartupPipelineRuntime = (dependencies) => {
       getOpenCodeAuthHeaders,
       globalEventHub,
       processForwardedEventPayload,
+      projectOutboundSessionPayload,
+      ensureSessionMetadataReady,
       wsClients: messageStreamWsClients,
       triggerHealthCheck,
       upstreamStallTimeoutMs,

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

@@ -47,8 +47,10 @@ export const createStaticRoutesRuntime = (dependencies) => {
         normalizePwaOrientation,
       });
 
+      // `root` limits send's dotfile check to `index.html`; an absolute path
+      // would 404 whenever the install lives under a dot directory (~/.bun, ~/.local).
       app.get(/^(?!\/api|.*\.(js|css|svg|png|jpg|jpeg|gif|ico|woff|woff2|ttf|eot|map)).*$/, (_req, res) => {
-        res.sendFile(path.join(distPath, 'index.html'));
+        res.sendFile('index.html', { root: distPath });
       });
       return;
     }

package/server/lib/opencode/static-routes-runtime.test.js

@@ -1,4 +1,7 @@
 import { describe, expect, it } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import express from 'express';
 import request from 'supertest';
 import { createStaticRoutesRuntime } from './static-routes-runtime.js';
@@ -57,4 +60,34 @@ describe('static routes runtime', () => {
     expect(auth.body).not.toEqual({ ok: true, mode: 'api-only', message: 'OpenChamber is running in API-only mode' });
     expect(health.body).not.toEqual({ ok: true, mode: 'api-only', message: 'OpenChamber is running in API-only mode' });
   });
+
+  it('serves index.html for deep links when dist lives under a dot directory', async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'openchamber-static-'));
+    const distPath = path.join(root, '.bun', 'install', 'dist');
+    fs.mkdirSync(distPath, { recursive: true });
+    fs.writeFileSync(path.join(distPath, 'index.html'), '<!doctype html><title>OpenChamber</title>');
+    try {
+      const app = express();
+      createStaticRoutesRuntime({
+        fs,
+        path,
+        process: { env: { OPENCHAMBER_DIST_DIR: distPath } },
+        __dirname: '/server',
+        express,
+        resolveProjectDirectory: () => '',
+        buildOpenCodeUrl: () => '',
+        getOpenCodeAuthHeaders: () => ({}),
+        readSettingsFromDiskMigrated: async () => ({}),
+        normalizePwaAppName: (value) => value,
+        normalizePwaOrientation: (value) => value,
+      }).registerStaticRoutes(app);
+
+      const response = await request(app).get('/session/ses_abc');
+
+      expect(response.status).toBe(200);
+      expect(response.text).toContain('<title>OpenChamber</title>');
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -1,4 +1,5 @@
 import { OpenCode } from '@opencode/client';
+import { wrapFetchWithRuntimeContractGate } from './server-opencode-fetch.js';
 
 /**
  * @typedef {import('@opencode/client').OpenCodeClient} OpenCodeV2ClientRaw
@@ -19,15 +20,25 @@ import { OpenCode } from '@opencode/client';
 
 /**
  * Create the single server-side client for official OpenCode v2 APIs.
+ * Fetch is always wrapped with runtime-contract write admission so Host
+ * background clients (queue / scheduled / assistants) cannot bypass the proxy gate.
  *
- * @param {{ baseUrl: string, authHeaders?: Record<string, string>, fetchImpl?: typeof fetch }} input
+ * @param {{
+ *   baseUrl: string,
+ *   authHeaders?: Record<string, string>,
+ *   fetchImpl?: typeof fetch,
+ *   getRuntimeContract?: () => (object | null | undefined),
+ * }} input
  * @returns {OpenCodeV2Client}
  */
-export function makeOpenCodeV2Client({ baseUrl, authHeaders, fetchImpl }) {
+export function makeOpenCodeV2Client({ baseUrl, authHeaders, fetchImpl, getRuntimeContract }) {
+  const gatedFetch = wrapFetchWithRuntimeContractGate(fetchImpl || fetch, {
+    ...(typeof getRuntimeContract === 'function' ? { getRuntimeContract } : {}),
+  });
   const client = OpenCode.make({
     baseUrl: baseUrl.replace(/\/$/, ''),
     ...(authHeaders ? { headers: authHeaders } : {}),
-    ...(fetchImpl ? { fetch: fetchImpl } : {}),
+    fetch: gatedFetch,
   });
 
   const messageGet = client.session.message?.get?.bind(client.session.message);