@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/spaces/places/packed.docker.live.test.js

@@ -67,7 +67,7 @@ describe.skipIf(!PACKED_ENABLED)('development build inside a space: docker (live
     const installed = lock.packages['node_modules/@openchamber/sdk'];
     expect(installed.version).toBe(JSON.parse(sdk).version);
     expect(installed.resolved).toMatch(/^file:.*openchamber-sdk\.tgz$/);
-    expect(lock.packages['node_modules/@openchamber/web'].resolved).toMatch(/^file:.*openchamber-web\.tgz$/);
+    expect(lock.packages['node_modules/@vantran-se/openchamber-web'].resolved).toMatch(/^file:.*openchamber-web\.tgz$/);
   });
 
   it('leaves the tarballs out of the volume', async () => {

package/server/lib/spaces/routes.js

@@ -43,6 +43,7 @@ const STATUS_BY_CODE = new Map([
   ['space_preparing', 409],
   ['space_creation_failed', 409],
   ['space_busy', 409],
+  ['image_pulling', 409],
   ['isolated_spaces_off', 404],
   ['space_not_running', 409],
   ['branch_exists', 409],
@@ -205,6 +206,10 @@ export function registerSpaceRoutes(app, { getJourney, getPlaces = () => [], rea
   app.post(`${SPACES_ROUTE}/places/:placeId/clean-up`, withJourney(async (journey, req, res) => {
     res.json(await journey.cleanUpDisk(String(req.params.placeId ?? '')));
   }));
+  // Downloads the image ahead of the first space; answers the disk at once, the download goes on.
+  app.post(`${SPACES_ROUTE}/places/:placeId/image`, withJourney(async (journey, req, res) => {
+    res.status(202).json(await journey.pullImage(String(req.params.placeId ?? '')));
+  }));
 
   app.get(SPACES_ROUTE, withJourney(async (journey, _req, res) => {
     res.json({ spaces: await journey.listSpaces({ access: true }) });

package/server/lib/spaces/routes.test.js

@@ -68,6 +68,7 @@ const journeyOf = (overrides = {}) => {
     readSetup: record('readSetup', { setup: null, output: null }),
     readDisk: record('readDisk', { imageBytes: null, toolsBytes: 0, spacesBytes: 0, freeBytes: 0, freesImage: false }),
     cleanUpDisk: record('cleanUpDisk', { freedBytes: 0, kept: [], disk: null }),
+    pullImage: record('pullImage', { imageBytes: null, imagePulling: true, imageFailure: null, toolsBytes: 0, spacesBytes: 0, freeBytes: 0, freesImage: false }),
     ...overrides,
   };
 };
@@ -75,7 +76,7 @@ const journeyOf = (overrides = {}) => {
 describe('space routes', () => {
   it('answers every journey route with 404 and isolated_spaces_off while the feature is off, and the switch still works', async () => {
     const { call, calls } = await serve({ journey: null, switchState: { enabled: false } });
-    for (const [method, path] of [['GET', ''], ['POST', ''], ['GET', '/places'], ['POST', `/${ID}/start`], ['POST', `/${ID}/stop`], ['POST', `/${ID}/restart`], ['POST', `/${ID}/restart-opencode`], ['POST', `/${ID}/grants`], ['DELETE', `/${ID}`], ['GET', `/${ID}/journal`], ['GET', `/${ID}/apply`], ['POST', `/${ID}/apply`], ['GET', '/idle-stop'], ['PUT', '/idle-stop'], ['POST', `/${ID}/setup`], ['GET', `/${ID}/setup`], ['GET', '/places/docker/disk'], ['POST', '/places/docker/clean-up']]) {
+    for (const [method, path] of [['GET', ''], ['POST', ''], ['GET', '/places'], ['POST', `/${ID}/start`], ['POST', `/${ID}/stop`], ['POST', `/${ID}/restart`], ['POST', `/${ID}/restart-opencode`], ['POST', `/${ID}/grants`], ['DELETE', `/${ID}`], ['GET', `/${ID}/journal`], ['GET', `/${ID}/apply`], ['POST', `/${ID}/apply`], ['GET', '/idle-stop'], ['PUT', '/idle-stop'], ['POST', `/${ID}/setup`], ['GET', `/${ID}/setup`], ['GET', '/places/docker/disk'], ['POST', '/places/docker/clean-up'], ['POST', '/places/docker/image']]) {
       expect(await call(method, `${SPACES_ROUTE}${path}`, method === 'GET' || method === 'DELETE' ? undefined : {}), `${method} ${path}`).toEqual({ status: 404, body: { code: 'isolated_spaces_off', message: 'Isolated spaces are turned off.', details: null } });
     }
     expect(await call('GET', `${SPACES_ROUTE}/switch`)).toEqual({ status: 200, body: { enabled: false, spaces: [] } });
@@ -107,6 +108,7 @@ describe('space routes', () => {
     expect(await call('GET', SPACES_ROUTE)).toEqual({ status: 200, body: { spaces: [{ id: ID, name: 'One', state: 'running' }] } });
     expect(await call('GET', `${SPACES_ROUTE}/places/docker/disk`)).toEqual({ status: 200, body: { imageBytes: null, toolsBytes: 0, spacesBytes: 0, freeBytes: 0, freesImage: false } });
     expect(await call('POST', `${SPACES_ROUTE}/places/docker/clean-up`)).toEqual({ status: 200, body: { freedBytes: 0, kept: [], disk: null } });
+    expect(await call('POST', `${SPACES_ROUTE}/places/docker/image`)).toEqual({ status: 202, body: { imageBytes: null, imagePulling: true, imageFailure: null, toolsBytes: 0, spacesBytes: 0, freeBytes: 0, freesImage: false } });
     const request = { projectDirectory: '/home/me/project', name: 'One', start: 'clean', network: { mode: 'open' } };
     expect(await call('POST', SPACES_ROUTE, request)).toEqual({ status: 202, body: { id: ID, state: 'preparing' } });
     expect(await call('POST', `${SPACES_ROUTE}/${ID}/start`)).toEqual({ status: 200, body: { id: ID, state: 'running' } });
@@ -122,7 +124,7 @@ describe('space routes', () => {
     expect(await call('GET', `${SPACES_ROUTE}/${ID}/setup`)).toEqual({ status: 200, body: { setup: null, output: null } });
     expect(await call('DELETE', `${SPACES_ROUTE}/${ID}`)).toEqual({ status: 200, body: { id: ID, removed: true } });
     expect(journey.calls).toEqual([
-      ['listSpaces', { access: true }], ['readDisk', 'docker'], ['cleanUpDisk', 'docker'], ['createSpace', request], ['startSpace', ID], ['stopSpace', ID], ['restartSpace', ID], ['restartOpenCode', ID], ['grantAccess', ID, { kind: 'domain', upstream: 'https://registry.example.com/' }], ['openDomain', ID, { domain: 'registry.npmjs.org' }], ['readJournal', ID], ['previewApply', ID], ['applySpace', ID, { as: 'branch', branch: 'b' }], ['runSetup', ID, { commands: ['npm ci'] }], ['readSetup', ID], ['removeSpace', ID, { allowUnsaved: false }],
+      ['listSpaces', { access: true }], ['readDisk', 'docker'], ['cleanUpDisk', 'docker'], ['pullImage', 'docker'], ['createSpace', request], ['startSpace', ID], ['stopSpace', ID], ['restartSpace', ID], ['restartOpenCode', ID], ['grantAccess', ID, { kind: 'domain', upstream: 'https://registry.example.com/' }], ['openDomain', ID, { domain: 'registry.npmjs.org' }], ['readJournal', ID], ['previewApply', ID], ['applySpace', ID, { as: 'branch', branch: 'b' }], ['runSetup', ID, { commands: ['npm ci'] }], ['readSetup', ID], ['removeSpace', ID, { allowUnsaved: false }],
     ]);
   });
 

package/server/lib/spaces/run-command.js

@@ -475,12 +475,19 @@ class CommandStream extends Duplex {
     callback(error);
   }
 
-  /** Emits `timeout` after `milliseconds` without a byte in either direction. Zero cancels it. */
+  /**
+   * Emits `timeout` after `milliseconds` without a byte in either direction. Zero cancels it, and
+   * takes the callback off again, as `net.Socket` does: the http client sets a timeout with its
+   * listener on every request a pooled stream carries, and cancels it with the same listener.
+   */
   setTimeout(milliseconds, callback) {
     if (this.#timer) clearTimeout(this.#timer);
     this.#timer = null;
     this.timeout = milliseconds;
-    if (callback) this.once('timeout', callback);
+    if (callback) {
+      if (milliseconds > 0) this.once('timeout', callback);
+      else this.removeListener('timeout', callback);
+    }
     if (milliseconds > 0) {
       this.#timer = setTimeout(() => { this.#timer = null; this.emit('timeout'); }, milliseconds);
       this.#timer.unref?.();

package/server/lib/spaces/tools.js

@@ -15,7 +15,6 @@ import { FILLER_PROGRAM } from './tools-filler.js';
 // Where the filler puts the tarballs of a packed source. It is a tmpfs, so they vanish with the filler.
 export const TOOLS_STAGING_PATH = '/tmp/openchamber-fill';
 
-const WEB_PACKAGE_NAME = '@vantran-se/openchamber-web';
 const WEB_TARBALL_NAME = 'openchamber-web.tgz';
 const SDK_TARBALL_NAME = 'openchamber-sdk.tgz';
 
@@ -57,7 +56,7 @@ const requireRevision = (value) => {
 const openCodePackages = (version) => ({ '@opencode/cli': version, '@opencode/plugin': version });
 
 /**
- * The versions a released host installs: its own web package, and OpenCode at the
+ * The versions a released host installs: its own `@vantran-se/openchamber-web`, and OpenCode at the
  * version of the `@opencode/client` this server was built against.
  */
 export function readHostToolVersions(packageJsonUrl = new URL('../../../package.json', import.meta.url)) {
@@ -68,14 +67,14 @@ export function readHostToolVersions(packageJsonUrl = new URL('../../../package.
     throw new SpaceError('tools_versions_unreadable', `Could not read the package.json of the OpenChamber server: ${error.message}`);
   }
   return {
-    webVersion: requireVersion(manifest.version, WEB_PACKAGE_NAME),
+    webVersion: requireVersion(manifest.version, '@vantran-se/openchamber-web'),
     openCodeVersion: requireVersion(manifest.dependencies?.['@opencode/client'], 'OpenCode'),
   };
 }
 
 export function createRegistryToolsSource({ webVersion, openCodeVersion, revision = '' }) {
   const packages = {
-    [WEB_PACKAGE_NAME]: requireVersion(webVersion, WEB_PACKAGE_NAME),
+    '@vantran-se/openchamber-web': requireVersion(webVersion, '@vantran-se/openchamber-web'),
     ...openCodePackages(requireVersion(openCodeVersion, 'OpenCode')),
   };
   return finishSource({
@@ -111,7 +110,7 @@ export function createPackedToolsSource({ webTarballPath, sdkTarballPath, openCo
     canonical: { kind: 'packed', tarballs: files.map((file) => ({ name: file.name, sha256: sha256(file.bytes) })), packages, revision: requireRevision(revision) },
     packageJson: packageJsonText({
       dependencies: {
-        '@openchamber/web': `file:${TOOLS_STAGING_PATH}/${WEB_TARBALL_NAME}`,
+        '@vantran-se/openchamber-web': `file:${TOOLS_STAGING_PATH}/${WEB_TARBALL_NAME}`,
         '@openchamber/sdk': `file:${TOOLS_STAGING_PATH}/${SDK_TARBALL_NAME}`,
         ...packages,
       },

package/server/lib/spaces/tools.test.js

@@ -44,7 +44,7 @@ describe('readHostToolVersions', () => {
 });
 
 describe('createRegistryToolsSource', () => {
-  it('asks for the fork package at the exact host version', () => {
+  it('asks for exact versions, with the plugin at the OpenCode version', () => {
     const source = createRegistryToolsSource(VERSIONS);
 
     expect(source.description).toBe('web 1.24.2, opencode 1.18.31');
@@ -79,7 +79,7 @@ describe('createPackedToolsSource', () => {
       name: 'openchamber-space-tools',
       private: true,
       dependencies: {
-        '@openchamber/web': 'file:/tmp/openchamber-fill/openchamber-web.tgz',
+        '@vantran-se/openchamber-web': 'file:/tmp/openchamber-fill/openchamber-web.tgz',
         '@openchamber/sdk': 'file:/tmp/openchamber-fill/openchamber-sdk.tgz',
         '@opencode/cli': '1.18.31',
         '@opencode/plugin': '1.18.31',

package/server/lib/terminal/runtime.js

@@ -95,6 +95,7 @@ export function createTerminalRuntime({
   isRequestOriginAllowed, rejectWebSocketUpgrade, TERMINAL_INPUT_WS_HEARTBEAT_INTERVAL_MS,
   loadPtyProvider, terminalTerminationGraceMs = TERMINATION_GRACE_MS, shutdownProcesses = shutdownTerminalProcesses,
   environmentRuntime = null,
+  logger = console,
 }) {
   const sessions = new Map();
   const pendingSessionCreates = new Map();
@@ -407,11 +408,22 @@ export function createTerminalRuntime({
 
   const upgradeHandler = (req, socket, head) => {
     if (parseRequestPathname(req.url) !== TERMINAL_WS_PATH) return;
+    const logUpgradeFailure = (error) => {
+      logger.warn?.(`[terminal] websocket upgrade failed: ${error?.message || error}`);
+    };
     const accept = () => {
       if (!wsServer) { rejectWebSocketUpgrade(socket, 500, 'Terminal WebSocket unavailable'); return; }
       try {
         wsServer.handleUpgrade(req, socket, head, (ws) => wsServer.emit('connection', ws, req));
-      } catch { rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); }
+      } catch (error) {
+        // handleUpgrade only throws once it has taken the socket: either the
+        // handshake already wrote its 101 (a second upgrade of the same socket,
+        // or a throw from the connection callback), so the connection is no
+        // longer HTTP. Writing a status line here would append an HTTP response
+        // to a switched-protocol socket; drop it and log why instead.
+        logUpgradeFailure(error);
+        socket.destroy();
+      }
     };
     const checkOrigin = () => {
       try {
@@ -424,15 +436,15 @@ export function createTerminalRuntime({
         void result.then((allowed) => {
           if (allowed) accept();
           else rejectWebSocketUpgrade(socket, 403, 'Invalid origin');
-        }).catch(() => rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'));
-      } catch { rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); }
+        }).catch((error) => { logUpgradeFailure(error); rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); });
+      } catch (error) { logUpgradeFailure(error); rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); }
     };
     if (isOpaqueOriginRequest(req)) { rejectWebSocketUpgrade(socket, 403, 'Invalid origin'); return; }
     if (!uiAuthController?.enabled) {
       void isPasswordlessSocketOriginAllowed(req, isRequestOriginAllowed).then((allowed) => {
         if (allowed) accept();
         else rejectWebSocketUpgrade(socket, 403, 'Invalid origin');
-      }).catch(() => rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'));
+      }).catch((error) => { logUpgradeFailure(error); rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); });
       return;
     }
     try {
@@ -445,8 +457,8 @@ export function createTerminalRuntime({
       void result.then((sessionToken) => {
         if (sessionToken) checkOrigin();
         else rejectWebSocketUpgrade(socket, 401, 'UI authentication required');
-      }).catch(() => rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'));
-    } catch { rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); }
+      }).catch((error) => { logUpgradeFailure(error); rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); });
+    } catch (error) { logUpgradeFailure(error); rejectWebSocketUpgrade(socket, 500, 'Upgrade failed'); }
   };
   server.on('upgrade', upgradeHandler);
 

package/server/lib/terminal/runtime.test.js

@@ -1,5 +1,7 @@
 import { EventEmitter } from 'node:events';
 import http from 'node:http';
+import net from 'node:net';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
@@ -8,6 +10,24 @@ import { WebSocket } from 'ws';
 import { createTerminalRuntime } from './runtime.js';
 import { createTerminalWsControlFrame, readTerminalWsControlFrame } from './terminal-ws-protocol.js';
 
+// Drives the raw upgrade handler by hand. A `ws` client hides the HTTP response
+// once the 101 lands, and a real client cannot be made to upgrade one socket
+// twice, so the test emits the `upgrade` event directly on a real socket.
+function manualUpgradeRequest(port) {
+  const key = crypto.randomBytes(16).toString('base64');
+  return {
+    url: '/api/terminal/ws',
+    method: 'GET',
+    headers: {
+      host: `127.0.0.1:${port}`,
+      upgrade: 'websocket',
+      connection: 'Upgrade',
+      'sec-websocket-key': key,
+      'sec-websocket-version': '13',
+    },
+  };
+}
+
 function createResponse() {
   return {
     statusCode: 200,
@@ -764,6 +784,52 @@ describe('terminal runtime', () => {
     }
   });
 
+  it('does not write an HTTP rejection onto a socket that already completed its upgrade', async () => {
+    const server = http.createServer();
+    const refused = [];
+    const logged = [];
+    const runtime = createRuntime(server, {
+      logger: { warn: (...args) => logged.push(args.join(' ')) },
+      rejectWebSocketUpgrade(socket, status, reason) {
+        refused.push({ status, reason });
+        if (!socket || socket.destroyed) return;
+        // Mirrors the real helper: it writes an HTTP status line, which is only
+        // valid before the handshake switches protocols.
+        try { socket.write(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\n\r\n`); } catch { /* closed */ }
+        try { socket.destroy(); } catch { /* closed */ }
+      },
+    });
+    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const port = server.address().port;
+    const socket = net.connect(port, '127.0.0.1');
+    await new Promise((resolve, reject) => {
+      socket.once('connect', resolve);
+      socket.once('error', reject);
+    });
+    let bytes = '';
+    socket.on('data', (chunk) => { bytes += chunk.toString('latin1'); });
+    try {
+      // First upgrade completes and writes the 101. The second one hits ws's
+      // "called more than once" throw, which used to land in the bare catch and
+      // append a 500 status line to a connection that is no longer HTTP.
+      const req = manualUpgradeRequest(port);
+      server.emit('upgrade', req, socket, Buffer.alloc(0));
+      server.emit('upgrade', req, socket, Buffer.alloc(0));
+      await new Promise((resolve) => setTimeout(resolve, 150));
+
+      // The socket was destroyed by the failure path, and no HTTP rejection was
+      // written for a connection that had already switched protocols.
+      expect(refused).toEqual([]);
+      expect(bytes).not.toContain('500');
+      // The upgrade error was not swallowed: it reached the logger.
+      expect(logged.some((line) => /terminal/i.test(line) && /upgrade/i.test(line))).toBe(true);
+    } finally {
+      socket.destroy();
+      await runtime.shutdown();
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+
   it('runs snapshot-first attach, scoped I/O, replay, reconnect, and close over a real websocket', async () => {
     const app = createHttpTestApp();
     const server = http.createServer(app);

package/server/lib/tts/index.js

@@ -4,16 +4,19 @@
  * Public export surface for the Text-to-Speech domain module.
  */
 
+/** @public */
 export {
   ttsService,
   TTSService,
   TTS_VOICES,
 } from './service.js';
 
+/** @public */
 export {
   summarizeText,
   sanitizeForTTS,
   sanitizeForNote,
 } from '../text/summarization.js';
 
+/** @public */
 export { transcribeAudio } from './stt.js';

package/server/lib/tts/service.js

@@ -10,6 +10,7 @@ import { loadOpenAI } from './openai-sdk.js';
 import { normalizeCustomOpenAIBaseURL } from './base-url.js';
 
 // Voice options from OpenAI
+/** @public */
 export const TTS_VOICES = [
   'alloy', 'ash', 'ballad', 'coral', 'echo', 'fable',
   'nova', 'onyx', 'sage', 'shimmer', 'verse', 'marin', 'cedar'
@@ -47,7 +48,8 @@ async function getOpenAIApiKey() {
   return null;
 }
 
-class TTSService {
+/** @public */
+export class TTSService {
   constructor() {
     this._client = null;
     this._lastApiKey = null;
@@ -182,5 +184,5 @@ class TTSService {
 }
 
 // Export singleton instance
+/** @public */
 export const ttsService = new TTSService();
-export { TTSService };

package/server/lib/walkthrough/DOCUMENTATION.md

@@ -95,7 +95,9 @@ PR mode uses the same searchable, paginated selector as Changes. Its list loads
 only while PR mode is visible. Selection ownership and handoff rules are in
 `packages/ui/src/stores/DOCUMENTATION.md`.
 
-PR sources may include `sourceRepo: { owner, repo }`. It qualifies the cache/job
+PR sources may include `sourceRepo: { owner, repo }`. `owner` is a single
+segment on GitHub and a namespace path on GitLab (`group/subgroup`), matching
+what each provider's project mapper produces. It qualifies the cache/job
 key as `pr:<owner>/<repo>:<number>`, so equal numbers in different repositories
 stay apart. Number-only sources keep `pr:<number>` and read the repository behind
 the bound primary remote. A named repository is honoured only inside the bound

package/server/lib/walkthrough/index.js

@@ -1,3 +1,4 @@
+import { isString } from '../shared/guards.js';
 import { getRepositoryRoot } from '../git/service.js';
 import { describeSmallModel, generateSmallModelText } from '../small-model/index.js';
 import { buildDigest } from './digest.js';
@@ -101,7 +102,6 @@ const jobs = new Map();
 const schemaRefusedBy = new Set();
 
 const modelKey = (model) => `${model.providerID}/${model.modelID}`;
-const isString = (value) => Object.prototype.toString.call(value) === '[object String]';
 const addReadContext = (result, readContext) => {
   if (readContext) result.readContext = readContext;
   return result;
@@ -166,6 +166,7 @@ export function isGenerating(repoRoot, sourceKeyValue, readContext) {
  * Resolve the pair the job registry is keyed by, for callers that need to look
  * a job up without doing any diff work.
  */
+/** @public */
 export async function getRepositoryRootFor(directory, rawSource, rawReadContext) {
   const source = parseSource(rawSource);
   const readContext = readContextForSource(source, rawReadContext);
@@ -642,5 +643,3 @@ async function runGeneration({ directory, source, repoRoot, key, force, explicit
     ...resolveAgainstCurrent(walkthrough, hunkIndex),
   }, readContext);
 }
-
-export { WalkthroughSourceError };

package/server/lib/walkthrough/pr-source.test.js

@@ -25,3 +25,25 @@ describe('repository-qualified PR sources', () => {
     expect(received).toEqual(['/repo', 42, readContext, { sourceRepo: source.sourceRepo }]);
   });
 });
+
+describe('GitLab namespace owners', () => {
+  it('accepts a subgroup namespace owner so MR walkthrough selection works below the root group', () => {
+    const source = parseSource({ kind: 'pr', number: 12, sourceRepo: { owner: 'group/subgroup', repo: 'repo' } });
+    expect(source.sourceRepo).toEqual({ owner: 'group/subgroup', repo: 'repo' });
+    expect(sourceKey(source)).toBe('pr:group/subgroup/repo:12');
+  });
+
+  it('accepts deeper nesting and dot/underscore segments as GitLab namespaces spell them', () => {
+    for (const owner of ['group/sub/sub', 'group.name/sub_group']) {
+      const source = parseSource({ kind: 'pr', number: 3, sourceRepo: { owner, repo: 'repo' } });
+      expect(source.sourceRepo.owner).toBe(owner);
+    }
+  });
+
+  it('keeps rejecting values that are not owner paths', () => {
+    for (const owner of ['group/../repo', '/group/repo', 'group/repo/', 'group//repo', '.', 'group/./repo']) {
+      expect(() => parseSource({ kind: 'pr', number: 3, sourceRepo: { owner, repo: 'repo' } }))
+        .toThrow('pr sources require a valid repository');
+    }
+  });
+});

package/server/lib/walkthrough/sources.js

@@ -49,7 +49,12 @@ export function parseSource(raw) {
     if (raw.sourceRepo !== undefined) {
       const { owner, repo } = raw.sourceRepo ?? {};
       try {
-        assert.match(owner, /^[a-zA-Z0-9-]+$/);
+        // Owners are a single segment on GitHub and a namespace path on GitLab
+        // (subgroups included). Each segment allows the same characters as a
+        // repo name with dots kept internal, so "." and ".." can never be a
+        // segment. Downstream the owner is only compared against the bound
+        // repository's network, never turned into a filesystem path.
+        assert.match(owner, /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*(?:\/[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)*$/);
         assert.match(repo, /^[a-zA-Z0-9_.-]+$/);
       } catch {
         throw new WalkthroughSourceError('pr sources require a valid repository');

package/server/opencode-proxy.test.js

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { EventEmitter } from 'node:events';
+import net from 'node:net';
 import express from 'express';
 import path from 'path';
 
@@ -26,6 +27,51 @@ const closeServer = (server) => new Promise((resolve, reject) => {
   });
 });
 
+const sendChunkedPost = (port, route, body, contentType) => new Promise((resolve, reject) => {
+  const socket = net.connect(port, '127.0.0.1');
+  const chunks = [];
+  socket.setTimeout(5000, () => socket.destroy(new Error('Timed out waiting for proxy response')));
+  socket.on('connect', () => {
+    const payload = Buffer.from(body);
+    socket.write([
+      `POST ${route} HTTP/1.1`,
+      `Host: 127.0.0.1:${port}`,
+      'Connection: close',
+      'Transfer-Encoding: chunked',
+      ...(contentType ? [`Content-Type: ${contentType}`] : []),
+      '',
+      payload.length > 0 ? `${payload.length.toString(16)}\r\n${body}\r\n0\r\n\r\n` : '0\r\n\r\n',
+    ].join('\r\n'));
+  });
+  socket.on('data', (chunk) => chunks.push(chunk));
+  socket.on('error', reject);
+  socket.on('end', () => {
+    const response = Buffer.concat(chunks).toString('utf8');
+    const headerEnd = response.indexOf('\r\n\r\n');
+    if (headerEnd === -1) {
+      reject(new Error('Proxy sent no response headers'));
+      return;
+    }
+    let body = response.slice(headerEnd + 4);
+    if (/\r\ntransfer-encoding: chunked\r\n/i.test(response.slice(0, headerEnd) + '\r\n')) {
+      const decoded = [];
+      let offset = 0;
+      while (offset < body.length) {
+        const lineEnd = body.indexOf('\r\n', offset);
+        const size = Number.parseInt(body.slice(offset, lineEnd), 16);
+        if (size === 0) break;
+        decoded.push(body.slice(lineEnd + 2, lineEnd + 2 + size));
+        offset = lineEnd + 2 + size + 2;
+      }
+      body = decoded.join('');
+    }
+    resolve({
+      status: Number(response.slice(0, response.indexOf('\r\n')).split(' ')[1]),
+      body,
+    });
+  });
+});
+
 describe('OpenCode proxy SSE forwarding', () => {
   let upstreamServer;
   let replacementUpstreamServer;
@@ -509,6 +555,46 @@ describe('OpenCode proxy SSE forwarding', () => {
     expect(Number(data.contentLength)).toBeGreaterThan(0);
   });
 
+  it('forwards an unparsed chunked prompt body to OpenCode', async () => {
+    const upstream = express();
+    upstream.post('/api/session/abc/prompt', express.json(), (req, res) => {
+      res.json({
+        body: req.body,
+        transferEncoding: req.headers['transfer-encoding'] ?? null,
+        contentLength: req.headers['content-length'] ?? null,
+      });
+    });
+    upstreamServer = await listen(upstream);
+    const upstreamPort = upstreamServer.address().port;
+
+    const app = express();
+    app.use('/api', express.urlencoded({ extended: true }));
+    registerOpenCodeProxy(app, {
+      fs: {},
+      OPEN_CODE_READY_GRACE_MS: 0,
+      getRuntime: () => ({
+        openCodePort: upstreamPort,
+        isOpenCodeReady: true,
+        openCodeNotReadySince: 0,
+        isRestartingOpenCode: false,
+      }),
+      getOpenCodeAuthHeaders: () => ({}),
+      buildOpenCodeUrl: (requestPath) => `http://127.0.0.1:${upstreamPort}${requestPath}`,
+      ensureOpenCodeApiPrefix: () => {},
+    });
+    proxyServer = await listen(app);
+    const proxyPort = proxyServer.address().port;
+
+    const payload = { parts: [{ type: 'text', text: 'hello' }] };
+    const response = await sendChunkedPost(proxyPort, '/api/session/abc/prompt', JSON.stringify(payload), 'application/json');
+
+    expect(response.status).toBe(200);
+    const data = JSON.parse(response.body);
+    expect(data.body).toEqual(payload);
+    expect(data.transferEncoding).toBe('chunked');
+    expect(data.contentLength).toBeNull();
+  });
+
   it('replays parsed chunked JSON bodies with a single framing header', async () => {
     const upstream = express();
     upstream.post('/api/session/abc/model', express.json(), (req, res) => {
@@ -560,6 +646,47 @@ describe('OpenCode proxy SSE forwarding', () => {
     expect(Number(data.contentLength)).toBe(JSON.stringify(payload).length);
   });
 
+  it('forwards an empty chunked request with one framing header', async () => {
+    const upstream = express();
+    upstream.post('/api/session/abc/interrupt', (req, res) => {
+      res.json({
+        transferEncoding: req.headers['transfer-encoding'] ?? null,
+        contentLength: req.headers['content-length'] ?? null,
+      });
+    });
+    upstreamServer = await listen(upstream);
+    const upstreamPort = upstreamServer.address().port;
+    const externalBaseUrl = `http://127.0.0.1:${upstreamPort}`;
+
+    const app = express();
+    registerOpenCodeProxy(app, {
+      fs: {},
+      os: {},
+      path,
+      OPEN_CODE_READY_GRACE_MS: 0,
+      getRuntime: () => ({
+        openCodePort: upstreamPort,
+        openCodeBaseUrl: externalBaseUrl,
+        isOpenCodeReady: true,
+        openCodeNotReadySince: 0,
+        isRestartingOpenCode: false,
+      }),
+      getOpenCodeAuthHeaders: () => ({}),
+      buildOpenCodeUrl: (requestPath) => `${externalBaseUrl}${requestPath}`,
+      ensureOpenCodeApiPrefix: () => {},
+    });
+    proxyServer = await listen(app);
+    const proxyPort = proxyServer.address().port;
+
+    // A tunnel sends the terminal chunk with no content-length or content-type.
+    const response = await sendChunkedPost(proxyPort, '/api/session/abc/interrupt', '');
+
+    expect(response.status).toBe(200);
+    const data = JSON.parse(response.body);
+    const framings = [data.transferEncoding !== null, data.contentLength !== null].filter(Boolean);
+    expect(framings).toHaveLength(1);
+  });
+
   it.each([
     ['win32', ''],
     ['win32', '&directory=%2Flink%2Frepo'],

package/bin/lib/commands-startup.test.js

@@ -1,15 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-import { startupCommand } from './commands-startup.js';
-
-const quiet = { quiet: true };
-
-describe('startup command service controls', () => {
-  for (const action of ['start', 'stop', 'restart']) {
-    it(`${action}s the installed startup service without changing installation`, async () => {
-      const controlStartupService = vi.fn(() => ({ supported: true, enabled: true, active: action !== 'stop', platform: 'linux' }));
-      await startupCommand(quiet, action, { controlStartupService });
-      expect(controlStartupService).toHaveBeenCalledWith(action);
-    });
-  }
-});

package/dist/assets/CodeMirrorCommentWidgets-CVDSjcrP.js

@@ -1 +0,0 @@
-import{j as a}from"./vendor-react-BUCujlKS.js";import{I as l,a as I}from"./useInlineCommentController-CrjSGCpi.js";function E(g){const{drafts:x,editingDraftId:d,commentText:o,onTextChange:r,selection:n,isDragging:u,fileLabel:s,newWidgetId:f,mapDraftToRange:p,onSave:m,onCancel:c,onEdit:C,onDelete:h}=g,t=[];for(const e of x){const i=p(e);if(e.id===d){t.push({afterLine:i.end,id:`edit-${e.id}`,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:i,isEditing:!0,onSave:m,onCancel:c},`edit-${e.id}`)});continue}t.push({afterLine:i.end,id:`card-${e.id}`,content:a.jsx(I,{draft:e,onEdit:()=>C(e),onDelete:()=>h(e)},`card-${e.id}`)})}if(n&&!d&&!u){const e={...n,start:Math.min(n.start,n.end),end:Math.max(n.start,n.end)};t.push({afterLine:e.end,id:f,content:a.jsx(l,{initialText:o,onTextChange:r,fileLabel:s,lineRange:e,isEditing:!1,onSave:m,onCancel:c},f)})}return t}export{E as b};