diffsplain 0.8.2 → 0.9.0

package/scripts/review-chat-provider.mjs

@@ -0,0 +1,352 @@
+import { spawn } from 'node:child_process';
+import {
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  agentCommand,
+  parseAgentResponse,
+} from './coding-agents.mjs';
+
+const maximumProviderOutputBytes = 1024 * 1024;
+const forcedChildKillDelayMs = 250;
+const noChange = () => {};
+
+function removeTemporary(path) {
+  rmSync(path, { force: true, recursive: true });
+}
+
+function cancelledError() {
+  return new Error('The chat request was cancelled.');
+}
+
+function spawnProcess(invocation) {
+  try {
+    return {
+      child: spawn(invocation.command, invocation.args, {
+        cwd: invocation.cwd,
+        env: invocation.env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }),
+    };
+  } catch (error) {
+    return { error };
+  }
+}
+
+function childOutput(chunks) {
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+function childFailure(agent, status, signal, stdout, stderr) {
+  const detail = stderr.trim() || stdout.trim();
+  const suffix = detail ? `: ${detail.slice(-600)}` : '';
+  return new Error(`${agent} exited with status ${status ?? signal}${suffix}`);
+}
+
+function aborted(signal) {
+  return Boolean(signal?.aborted);
+}
+
+function successfulExit(status, signal) {
+  return status === 0 && !signal;
+}
+
+function closeError(execution, status, signal) {
+  if (aborted(execution.signal)) return cancelledError();
+  if (successfulExit(status, signal)) return undefined;
+  return childFailure(
+    execution.agent,
+    status,
+    signal,
+    childOutput(execution.stdout),
+    childOutput(execution.stderr),
+  );
+}
+
+function providerAgent(options) {
+  const agent = options?.agent;
+  if (!agent) throw new Error('Chat provider needs a coding agent');
+  return agent;
+}
+
+function providerBinary(options, agent) {
+  return options.binary || agent;
+}
+
+function providerEnvironment(options) {
+  return options.env || process.env;
+}
+
+function providerOptions(options) {
+  const agent = providerAgent(options);
+  return {
+    agent,
+    binary: providerBinary(options, agent),
+    model: options.model,
+    reasoning: options.reasoning,
+    accessMode: options.accessMode,
+    env: providerEnvironment(options),
+  };
+}
+
+function temporaryRequest() {
+  const temporary = mkdtempSync(join(tmpdir(), 'diffsplain-review-chat-'));
+  return {
+    temporary,
+    inputPath: join(temporary, 'input.json'),
+    schemaPath: join(temporary, 'schema.json'),
+  };
+}
+
+function writeRequest(paths, request) {
+  writeFileSync(paths.inputPath, JSON.stringify(request));
+  writeFileSync(paths.schemaPath, JSON.stringify(request.responseSchema));
+}
+
+function providerInvocation(options, request, paths) {
+  return agentCommand({
+    agent: options.agent,
+    binary: options.binary,
+    model: options.model,
+    reasoning: options.reasoning,
+    prompt: request.prompt,
+    schema: request.responseSchema,
+    schemaPath: paths.schemaPath,
+    inputPath: paths.inputPath,
+    accessMode: options.accessMode,
+    env: options.env,
+  });
+}
+
+function preparedProviderRequest(options, request) {
+  const paths = temporaryRequest();
+  try {
+    writeRequest(paths, request);
+    return { temporary: paths.temporary, invocation: providerInvocation(options, request, paths) };
+  } catch (error) {
+    removeTemporary(paths.temporary);
+    throw error;
+  }
+}
+
+class ChildExecution {
+  constructor({ invocation, input, agent, signal, temporary }) {
+    this.invocation = invocation;
+    this.input = input;
+    this.agent = agent;
+    this.signal = signal;
+    this.temporary = temporary;
+    this.child = undefined;
+    this.settled = false;
+    this.closed = false;
+    this.forceKillTimer = undefined;
+    this.stdout = [];
+    this.stderr = [];
+    this.outputBytes = 0;
+    this.promise = new Promise((resolvePromise, rejectPromise) => {
+      this.resolvePromise = resolvePromise;
+      this.rejectPromise = rejectPromise;
+    });
+    this.finished = new Promise((resolveFinished) => {
+      this.resolveFinished = resolveFinished;
+    });
+  }
+
+  open() {
+    const result = spawnProcess(this.invocation);
+    if (result.error) {
+      this.reject(result.error);
+      this.finishClose();
+    }
+    else this.openChild(result.child);
+    return {
+      promise: this.promise,
+      finished: this.finished,
+      cancel: this.cancel.bind(this),
+    };
+  }
+
+  openChild(child) {
+    this.child = child;
+    this.listen();
+    this.writeInput();
+  }
+
+  listen() {
+    this.child.stdout.on('data', this.receiveStdout.bind(this));
+    this.child.stderr.on('data', this.receiveStderr.bind(this));
+    this.child.stdin.once('error', this.stdinError.bind(this));
+    this.child.once('error', this.childError.bind(this));
+    this.child.once('close', this.closeChild.bind(this));
+    this.signal?.addEventListener('abort', this.terminate.bind(this), { once: true });
+  }
+
+  writeInput() {
+    if (this.invocation.input === 'stdin') this.child.stdin.end(this.input);
+    else this.child.stdin.end();
+  }
+
+  receiveStdout(chunk) {
+    this.receiveOutput(this.stdout, chunk);
+  }
+
+  receiveStderr(chunk) {
+    this.receiveOutput(this.stderr, chunk);
+  }
+
+  receiveOutput(chunks, chunk) {
+    const nextBytes = this.outputBytes + chunk.length;
+    if (nextBytes <= maximumProviderOutputBytes) {
+      this.outputBytes = nextBytes;
+      chunks.push(chunk);
+      return;
+    }
+    this.terminate();
+    this.reject(new Error(`${this.agent} returned too much chat output`));
+  }
+
+  stdinError(error) {
+    if (error.code !== 'EPIPE') this.reject(error);
+  }
+
+  childError(error) {
+    this.reject(error);
+    if (!this.running()) this.finishClose();
+  }
+
+  running() {
+    return Number.isInteger(this.child?.pid) && this.child.exitCode === null;
+  }
+
+  sendSignal(signal) {
+    try {
+      this.child.kill(signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  killChild() {
+    if (!this.running()) return;
+    this.sendSignal('SIGKILL');
+  }
+
+  scheduleForceKill() {
+    if (this.forceKillTimer) return;
+    this.forceKillTimer = setTimeout(() => {
+      this.forceKillTimer = undefined;
+      this.killChild();
+    }, forcedChildKillDelayMs);
+    this.forceKillTimer.unref();
+  }
+
+  terminate() {
+    if (!this.running()) return;
+    if (!this.sendSignal('SIGTERM')) return;
+    this.scheduleForceKill();
+  }
+
+  clearForceKill() {
+    if (!this.forceKillTimer) return;
+    clearTimeout(this.forceKillTimer);
+    this.forceKillTimer = undefined;
+  }
+
+  settle(callback, value) {
+    if (this.settled) return;
+    this.settled = true;
+    callback(value);
+  }
+
+  finishClose() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearForceKill();
+    removeTemporary(this.temporary);
+    this.resolveFinished();
+  }
+
+  resolve(value) {
+    this.settle(this.resolvePromise, value);
+  }
+
+  reject(error) {
+    this.settle(this.rejectPromise, error);
+  }
+
+  parseOutput() {
+    try {
+      this.resolve(parseAgentResponse(this.agent, childOutput(this.stdout)));
+    } catch (error) {
+      this.reject(error);
+    }
+  }
+
+  closeChild(status, signal) {
+    this.clearForceKill();
+    if (!this.settled) {
+      const error = closeError(this, status, signal);
+      if (error) this.reject(error);
+      else this.parseOutput();
+    }
+    this.finishClose();
+  }
+
+  cancel() {
+    if (this.settled) return;
+    this.terminate();
+    this.reject(cancelledError());
+  }
+}
+
+function providerChild(options) {
+  return new ChildExecution(options).open();
+}
+
+function trackExecution(executions, execution) {
+  executions.add(execution);
+  execution.finished.finally(() => executions.delete(execution)).catch(noChange);
+  return execution;
+}
+
+function runRequest(options, executions, request) {
+  const prepared = preparedProviderRequest(options, request);
+  const controller = new AbortController();
+  const execution = providerChild({
+    invocation: prepared.invocation,
+    input: JSON.stringify(request),
+    agent: options.agent,
+    signal: controller.signal,
+    temporary: prepared.temporary,
+  });
+  const tracked = trackExecution(executions, execution);
+  return {
+    promise: tracked.promise,
+    cancel() {
+      controller.abort();
+      tracked.cancel();
+    },
+  };
+}
+
+function closeExecutions(executions) {
+  for (const execution of executions) execution.cancel();
+}
+
+export function createCodingAgentChatProvider(options = {}) {
+  const configured = providerOptions(options);
+  const executions = new Set();
+  return {
+    run(request) {
+      return runRequest(configured, executions, request);
+    },
+    close() {
+      closeExecutions(executions);
+    },
+  };
+}

package/scripts/review-chat.mjs

@@ -0,0 +1,8 @@
+import { ReviewChatController } from './review-chat-controller.mjs';
+
+export { ReviewChatError } from './review-chat-context.mjs';
+export { createCodingAgentChatProvider } from './review-chat-provider.mjs';
+
+export function createReviewChat(options) {
+  return new ReviewChatController(options).api();
+}

package/scripts/serve-built.mjs

@@ -6,6 +6,11 @@ import { readFile, stat } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { dirname, extname, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  ReviewChatError,
+  createCodingAgentChatProvider,
+  createReviewChat,
+} from './review-chat.mjs';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const clientRoot = resolve(root, 'dist');
@@ -27,6 +32,13 @@ const portValue = option('--port', '2299');
 const host = option('--host', 'localhost').replace(/^\[|\]$/g, '');
 const access = option('--access', randomBytes(32).toString('base64url'));
 const previousAccess = option('--previous-access', '');
+const chatSnapshot = resolve(option('--chat-snapshot', output));
+const chatAgent = option('--chat-agent');
+const chatBinary = option('--chat-binary', chatAgent);
+const chatModel = option('--chat-model');
+const chatReasoning = option('--chat-reasoning');
+const chatAccessMode = option('--chat-access-mode', 'snapshot-only');
+const chatAccessRoot = option('--chat-access-root');
 if (!/^\d+$/.test(portValue) || Number(portValue) > 65_535) {
   throw new Error('--port must be a number from 0 to 65535');
 }
@@ -36,6 +48,12 @@ if (!/^[A-Za-z0-9_-]{32,}$/.test(access)) {
 if (previousAccess && !/^[A-Za-z0-9_-]{32,}$/.test(previousAccess)) {
   throw new Error('--previous-access must be an unguessable URL-safe value');
 }
+if (!['checkout-read-only', 'snapshot-only'].includes(chatAccessMode)) {
+  throw new Error('--chat-access-mode must be checkout-read-only or snapshot-only');
+}
+if (chatAccessMode === 'checkout-read-only' && !chatAccessRoot) {
+  throw new Error('--chat-access-root is required for checkout chat access');
+}
 const incrementPort =
   rawArgs.includes('--increment-port') || !rawArgs.includes('--port');
 
@@ -270,6 +288,60 @@ function jsonResponse(value, status = 200) {
   });
 }
 
+const chatBodyLimitBytes = 64 * 1024;
+
+function chatJsonContentType(value) {
+  return typeof value === 'string' &&
+    /^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(value);
+}
+
+function chatRequestBody(request) {
+  if (!chatJsonContentType(request.headers['content-type'])) {
+    throw new ReviewChatError('Chat commands need application/json.', 415);
+  }
+  const contentLength = Number(request.headers['content-length']);
+  if (Number.isFinite(contentLength) && contentLength > chatBodyLimitBytes) {
+    throw new ReviewChatError('Chat command body is too large.', 413);
+  }
+  return new Promise((resolvePromise, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      request.resume();
+      reject(error);
+    };
+    request.on('data', (chunk) => {
+      bytes += chunk.length;
+      if (bytes > chatBodyLimitBytes) {
+        fail(new ReviewChatError('Chat command body is too large.', 413));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request.once('error', fail);
+    request.once('end', () => {
+      if (settled) return;
+      settled = true;
+      try {
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+          throw new ReviewChatError('Chat commands must be JSON objects.');
+        }
+        resolvePromise(value);
+      } catch (error) {
+        reject(
+          error instanceof ReviewChatError
+            ? error
+            : new ReviewChatError('Chat command JSON is not valid.'),
+        );
+      }
+    });
+  });
+}
+
 async function send(nodeResponse, webResponse) {
   nodeResponse.writeHead(
     webResponse.status,
@@ -287,6 +359,32 @@ let selectedPort = Number(portValue);
 let readyState;
 let closing = false;
 
+function broadcastEvent(name, data = {}) {
+  const payload = JSON.stringify(data);
+  for (const client of eventClients) {
+    if (!client.destroyed) client.write(`event: ${name}\ndata: ${payload}\n\n`);
+  }
+}
+
+const chatProviderAccess = chatAccessMode === 'checkout-read-only'
+  ? { mode: chatAccessMode, root: resolve(chatAccessRoot) }
+  : { mode: chatAccessMode, reason: 'target-mismatch' };
+const chatProvider = chatAgent
+  ? createCodingAgentChatProvider({
+      agent: chatAgent,
+      binary: chatBinary,
+      model: chatModel,
+      reasoning: chatReasoning,
+      accessMode: chatProviderAccess,
+    })
+  : undefined;
+const reviewChat = createReviewChat({
+  snapshotPath: chatSnapshot,
+  provider: chatProvider,
+  accessMode: chatProviderAccess,
+  onChange: () => broadcastEvent('chat'),
+});
+
 function requestAuthorityError(request) {
   const localAddress = request.socket.localAddress || '';
   if (!validHost(request.headers.host, localAddress)) {
@@ -298,14 +396,22 @@ function requestAuthorityError(request) {
   return undefined;
 }
 
+function allowedMethods(url) {
+  return url.pathname === '/api/chat' ? ['GET', 'POST'] : ['GET', 'HEAD'];
+}
+
+function methodError(request, url) {
+  if (allowedMethods(url).includes(request.method)) return undefined;
+  return webResponse('Method not allowed', { status: 405 });
+}
+
 function requestContext(request) {
   const url = parseRequestUrl(request);
   if (!url) return { error: clientError() };
   const authorityError = requestAuthorityError(request);
   if (authorityError) return { error: authorityError };
-  if (!['GET', 'HEAD'].includes(request.method)) {
-    return { error: webResponse('Method not allowed', { status: 405 }) };
-  }
+  const error = methodError(request, url);
+  if (error) return { error };
   return { url };
 }
 
@@ -349,20 +455,98 @@ async function routeResponse(url) {
   return fetchAsset(url);
 }
 
+function chatAccessError(url) {
+  if (validAccess(url.searchParams.get('access'))) return undefined;
+  return webResponse('Forbidden', { status: 403 });
+}
+
+function chatCommandError(error) {
+  if (error instanceof ReviewChatError) {
+    return { status: error.status, message: error.message };
+  }
+  return { status: 400, message: 'Chat command failed.' };
+}
+
+async function sendChatCommand(request, response) {
+  try {
+    const result = reviewChat.command(await chatRequestBody(request));
+    const status = result.accepted ? 202 : 200;
+    await send(response, jsonResponse(result.state, status));
+  } catch (error) {
+    const failure = chatCommandError(error);
+    await send(response, jsonResponse({ error: failure.message }, failure.status));
+  }
+}
+
+async function handleChatRequest(request, response, url) {
+  const accessError = chatAccessError(url);
+  if (accessError) {
+    await send(response, accessError);
+    return;
+  }
+  if (request.method === 'GET') {
+    await send(response, jsonResponse(reviewChat.getState()));
+    return;
+  }
+  await sendChatCommand(request, response);
+}
+
+async function handleEventsRequest(_request, response, url) {
+  await sendEvents(response, url);
+}
+
+function handlerFor(url) {
+  return {
+    '/events': handleEventsRequest,
+    '/api/chat': handleChatRequest,
+  }[url.pathname];
+}
+
+function throwForcedHandlerFailure(url) {
+  if (forcedHandlerFailure(url)) throw new Error('forced request handler failure');
+}
+
+async function handleRoutedRequest(request, response, url) {
+  const handler = handlerFor(url);
+  if (handler) {
+    await handler(request, response, url);
+    return;
+  }
+  await send(response, await routeResponse(url));
+}
+
 async function handleRequest(request, response) {
   const context = requestContext(request);
   if (context.error) {
     await send(response, context.error);
     return;
   }
-  if (forcedHandlerFailure(context.url)) {
-    throw new Error('forced request handler failure');
-  }
-  if (context.url.pathname === '/events') {
-    await sendEvents(response, context.url);
-    return;
-  }
-  await send(response, await routeResponse(context.url));
+  throwForcedHandlerFailure(context.url);
+  await handleRoutedRequest(request, response, context.url);
+}
+
+function stopWatchers() {
+  unwatchFile(output);
+  if (chatSnapshot !== output) unwatchFile(chatSnapshot);
+}
+
+function closeEventClients() {
+  for (const client of eventClients) client.end();
+  eventClients.clear();
+}
+
+function closeServer() {
+  if (server.listening) server.close();
+}
+
+function close(exitCode = 0) {
+  if (closing) return;
+  closing = true;
+  process.exitCode = exitCode;
+  stopWatchers();
+  reviewChat.close();
+  closeEventClients();
+  closeServer();
 }
 
 async function containHandlerFailure(response) {
@@ -390,11 +574,19 @@ watchFile(output, { interval: 100 }, (current, previous) => {
   if (current.mtimeMs === previous.mtimeMs && current.size === previous.size) {
     return;
   }
-  for (const client of eventClients) {
-    if (!client.destroyed) client.write('event: update\ndata: {}\n\n');
-  }
+  reviewChat.refresh();
+  broadcastEvent('update');
 });
 
+if (chatSnapshot !== output) {
+  watchFile(chatSnapshot, { interval: 100 }, (current, previous) => {
+    if (current.mtimeMs === previous.mtimeMs && current.size === previous.size) {
+      return;
+    }
+    reviewChat.refresh();
+  });
+}
+
 function urlFor(address, port) {
   const formattedAddress = address.includes(':') ? `[${address}]` : address;
   return `http://${formattedAddress}:${port}`;
@@ -454,15 +646,5 @@ server.on('error', (error) => {
 
 listen();
 
-function close(exitCode = 0) {
-  if (closing) return;
-  closing = true;
-  process.exitCode = exitCode;
-  unwatchFile(output);
-  for (const client of eventClients) client.end();
-  eventClients.clear();
-  if (server.listening) server.close();
-}
-
 process.on('SIGINT', () => close());
 process.on('SIGTERM', () => close());