@comty.io/core 0.1.2 → 0.1.3

package/src/companion.mjs

@@ -1,207 +0,0 @@
-import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
-import { mkdirSync, openSync, closeSync, readFileSync, writeFileSync, renameSync, unlinkSync, fsyncSync, realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { runCodex } from './codex.mjs';
-import { runClaude } from './claude.mjs';
-import { runCursor } from './cursor.mjs';
-
-const statuses = new Set(['todo', 'in_progress', 'in_review', 'done', 'cancel']);
-export const isLoopback = hostname => ['localhost', '127.0.0.1', '[::1]'].includes(hostname);
-
-function httpError(status, message) { return Object.assign(new Error(message), { status }); }
-async function body(request) {
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of request) {
-    size += chunk.length;
-    if (size > 65536) throw httpError(413, 'Request exceeds 64 KiB');
-    chunks.push(chunk);
-  }
-  try { return JSON.parse(Buffer.concat(chunks).toString('utf8')); }
-  catch { throw httpError(400, 'Invalid JSON'); }
-}
-
-function newTask(input, host) {
-  if (!input || typeof input !== 'object' || Array.isArray(input)) throw httpError(400, 'Invalid task');
-  const fields = { content: 10000, selector: 4000, pagePath: 4000 };
-  for (const [key, limit] of Object.entries(fields)) {
-    if (typeof input[key] !== 'string' || !input[key].trim() || input[key].length > limit) throw httpError(400, `Invalid ${key}`);
-  }
-  if (!input.pagePath.startsWith('/')) throw httpError(400, 'Invalid pagePath');
-  for (const key of ['relX', 'relY']) {
-    if (typeof input[key] !== 'number' || !Number.isFinite(input[key]) || input[key] < 0 || input[key] > 1) throw httpError(400, `Invalid ${key}`);
-  }
-  for (const [key, limit] of Object.entries({ domElement: 8000, viewport: 100, anchorContext: 24000 })) {
-    if (input[key] != null && (typeof input[key] !== 'string' || input[key].length > limit)) throw httpError(400, `Invalid ${key}`);
-  }
-  if (input.anchorContext) {
-    try { JSON.parse(input.anchorContext); } catch { throw httpError(400, 'Invalid anchorContext JSON'); }
-  }
-  return {
-    id: randomUUID(), kind: 'agent', local_agent: true, status: 'todo',
-    domain: host, page_path: input.pagePath, selector: input.selector,
-    rel_x: input.relX, rel_y: input.relY, content: input.content.trim(),
-    dom_element: input.domElement || null, viewport: input.viewport || null,
-    anchor_context: input.anchorContext || null, author_name: 'You',
-    created_at: new Date().toISOString(), replies: [],
-  };
-}
-
-/** Internal local server shared by the Vite integration and the dev command. */
-export function createCompanion({ cwd, origin, provider = 'codex', model, runAgent }) {
-  if (!['codex', 'claude', 'cursor'].includes(provider)) throw new Error('Supported agents: codex, claude, cursor');
-  if (model !== undefined && (provider !== 'codex' || typeof model !== 'string' || !model.trim() || model.length > 100)) throw new Error('model must be a Codex model ID');
-  runAgent ||= { codex: runCodex, claude: runClaude, cursor: runCursor }[provider];
-  const site = new URL(origin);
-  if (!isLoopback(site.hostname) || !['http:', 'https:'].includes(site.protocol)) throw new Error('Comty agent requires a loopback origin');
-  cwd = realpathSync(cwd);
-  const directory = resolve(cwd, '.comty');
-  const file = resolve(directory, 'tasks.json');
-  const lock = resolve(directory, 'companion.lock');
-  mkdirSync(directory, { recursive: true, mode: 0o700 });
-  let descriptor;
-  try { descriptor = openSync(lock, 'wx', 0o600); }
-  catch (error) {
-    if (error.code !== 'EEXIST') throw error;
-    throw new Error(`Comty workspace is locked: ${lock}. Stop its companion first. After a crash, verify the recorded PID is no longer running before removing this lock.`);
-  }
-  writeFileSync(descriptor, JSON.stringify({ pid: process.pid, origin }));
-  closeSync(descriptor);
-  let tasks;
-  function persist() {
-    const temporary = `${file}.tmp`;
-    const fd = openSync(temporary, 'w', 0o600);
-    try { writeFileSync(fd, `${JSON.stringify(tasks, null, 2)}\n`); fsyncSync(fd); }
-    finally { closeSync(fd); }
-    renameSync(temporary, file);
-  }
-  try {
-    try { tasks = JSON.parse(readFileSync(file, 'utf8')); }
-    catch (error) { if (error.code === 'ENOENT') tasks = []; else throw error; }
-    if (!Array.isArray(tasks) || tasks.some(task => !task?.id || !statuses.has(task.status))) throw new Error('Invalid Comty task history; refusing to overwrite it');
-    for (const task of tasks) {
-      if (['todo', 'in_progress'].includes(task.status)) {
-        task.status = 'in_review'; task.error = 'Development server stopped. Review any changes before retrying.';
-      }
-    }
-    persist();
-  } catch (error) { unlinkSync(lock); throw error; }
-  const releaseLock = () => {
-    try { unlinkSync(lock); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-  };
-  const onInterrupt = () => { releaseLock(); process.exit(130); };
-  const onTerminate = () => { releaseLock(); process.exit(143); };
-  process.once('exit', releaseLock);
-  process.once('SIGINT', onInterrupt);
-  process.once('SIGTERM', onTerminate);
-  const token = randomBytes(32).toString('hex');
-  const approvals = new Map();
-  const active = new Map();
-  let closing = false, closed;
-  function update(task, values) {
-    Object.assign(task, values, { updated_at: new Date().toISOString() });
-    persist();
-  }
-  function start(task) {
-    if (closing || active.has(task.id) || task.status !== 'todo') return;
-    const controller = new AbortController();
-    const running = (async () => {
-      const timeout = setTimeout(() => controller.abort(new Error('Agent exceeded 30 minutes; review changes before retrying.')), 30 * 60 * 1000);
-      try {
-        update(task, { status: 'in_progress', error: null });
-        const receipt = await runAgent({
-          cwd, task, signal: controller.signal, model,
-          progress: message => { task.progress = String(message).slice(-4000); },
-          approve: request => new Promise(resolve => {
-            if (controller.signal.aborted) return resolve(false);
-            const id = randomUUID();
-            const abort = () => { approvals.delete(id); resolve(false); };
-            controller.signal.addEventListener('abort', abort, { once: true });
-            approvals.set(id, { id, taskId: task.id, ...request, resolve: accepted => {
-              controller.signal.removeEventListener('abort', abort); approvals.delete(id); resolve(accepted);
-            } });
-          }),
-        });
-        controller.signal.throwIfAborted();
-        if (!receipt || !['done', 'blocked'].includes(receipt.status) || !receipt.summary || !receipt.verification) throw new Error('Agent completion was not verified');
-        update(task, { status: receipt.status === 'done' ? 'done' : 'in_review', result: receipt });
-      } catch (error) {
-        update(task, { status: task.status === 'cancel' ? 'cancel' : 'in_review', error: error.message || String(error) });
-      } finally {
-        clearTimeout(timeout);
-        for (const approval of [...approvals.values()]) if (approval.taskId === task.id) approval.resolve(false);
-        active.delete(task.id);
-      }
-    })();
-    active.set(task.id, { controller, running });
-    // A storage failure must stop new work rather than silently lose history.
-    void running.catch(error => { closing = true; console.error('Comty stopped local agents:', error); });
-  }
-  function snapshot() {
-    return { provider, tasks, approvals: [...approvals.values()].map(({ resolve: _, ...approval }) => approval) };
-  }
-  async function handle(request, response) {
-    const json = (status, value) => {
-      response.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' });
-      response.end(JSON.stringify(value));
-    };
-    try {
-      if (closing) throw httpError(503, 'Companion is shutting down');
-      const supplied = Buffer.from(String(request.headers['x-comty-token'] || ''));
-      const expected = Buffer.from(token);
-      if (request.headers.host !== site.host || (request.headers.origin && request.headers.origin !== site.origin) ||
-        supplied.length !== expected.length || !timingSafeEqual(supplied, expected)) throw httpError(403, 'Invalid local session');
-      const url = new URL(request.url, site);
-      if (request.method === 'GET' && url.pathname === '/__comty/tasks') return json(200, snapshot());
-      if (request.method === 'POST' && url.pathname === '/__comty/tasks') {
-        const task = newTask(await body(request), site.host);
-        tasks.push(task);
-        try { persist(); } catch (error) { tasks.pop(); throw error; }
-        json(201, { task }); start(task); return;
-      }
-      const action = url.pathname.match(/^\/__comty\/tasks\/([a-f0-9-]+)\/(retry|cancel)$/);
-      if (request.method === 'POST' && action) {
-        const task = tasks.find(item => item.id === action[1]);
-        if (!task) throw httpError(404, 'Unknown task');
-        if (action[2] === 'retry') {
-          if (!['in_review', 'cancel'].includes(task.status)) throw httpError(409, 'Task cannot be retried in this state');
-          if (active.has(task.id)) throw httpError(409, 'Agent is still stopping');
-          update(task, { status: 'todo', error: null, progress: null, result: null }); start(task);
-        } else {
-          if (task.status === 'done') throw httpError(409, 'Task is already done');
-          update(task, { status: 'cancel' });
-          active.get(task.id)?.controller.abort(new Error('Cancelled by user; review any partial changes.'));
-        }
-        return json(200, { task });
-      }
-      const approvalPath = url.pathname.match(/^\/__comty\/approvals\/([a-f0-9-]+)$/);
-      if (request.method === 'POST' && approvalPath) {
-        const approval = approvals.get(approvalPath[1]);
-        if (!approval) throw httpError(409, 'Approval expired');
-        const input = await body(request);
-        if (typeof input?.allow !== 'boolean') throw httpError(400, 'Expected allow: boolean');
-        approval.resolve(input.allow);
-        return json(200, { ok: true });
-      }
-      throw httpError(404, 'Not found');
-    } catch (error) {
-      json(error.status || 500, { error: error.status ? error.message : 'Local task storage failed. Check the terminal.' });
-      if (!error.status) console.error(error);
-    }
-  }
-  return {
-    token, handle,
-    close() {
-      if (closed) return closed;
-      closing = true;
-      for (const entry of active.values()) entry.controller.abort(new Error('Development server stopped'));
-      closed = Promise.allSettled([...active.values()].map(entry => entry.running)).then(() => {
-        process.removeListener('exit', releaseLock);
-        process.removeListener('SIGINT', onInterrupt);
-        process.removeListener('SIGTERM', onTerminate);
-        releaseLock();
-      });
-      return closed;
-    },
-  };
-}

package/src/cursor.mjs

@@ -1,49 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { openAgentProcess } from './agent-process.mjs';
-import { parseReceipt, receiptSchema, taskPrompt } from './codex.mjs';
-
-export async function runCursor({ cwd, task, signal, approve, progress, executable = 'agent', args = [] }) {
-  cwd = realpathSync(cwd);
-  let output = '';
-  const rpc = openAgentProcess({
-    executable, args: [...args, 'acp'], cwd, signal, label: 'Cursor',
-    async onRequest(method, params) {
-      if (method === 'session/request_permission') {
-        const allow = await approve({ type: method, details: params.toolCall });
-        const option = params.options?.find(option => option.kind === (allow ? 'allow_once' : 'reject_once'));
-        return { outcome: option ? { outcome: 'selected', optionId: option.optionId } : { outcome: 'cancelled' } };
-      }
-      if (method === 'cursor/create_plan') {
-        return { outcome: { outcome: await approve({ type: method, details: params }) ? 'accepted' : 'rejected' } };
-      }
-      throw new Error(`Cursor needs an unsupported interaction: ${method}. Create a new task with the missing details.`);
-    },
-    onNotification(method, params) {
-      if (method !== 'session/update' || params?.update?.sessionUpdate !== 'agent_message_chunk') return;
-      if (params.update.content?.type === 'text') {
-        output += params.update.content.text;
-        if (output.length > 1024 * 1024) throw new Error('Cursor response exceeded 1 MiB');
-        progress(output.slice(-4000));
-      }
-    },
-  });
-  try {
-    await rpc.request('initialize', {
-      protocolVersion: 1, clientInfo: { name: 'comty', version: '0.1.0' },
-      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
-    });
-    await rpc.request('authenticate', { methodId: 'cursor_login' });
-    const session = await rpc.request('session/new', { cwd, mcpServers: [] });
-    if (!session?.sessionId) throw new Error('Cursor did not create a session');
-    await rpc.request('session/set_mode', { sessionId: session.sessionId, modeId: 'agent' });
-    const result = await rpc.request('session/prompt', {
-      sessionId: session.sessionId,
-      prompt: [{ type: 'text', text: `${taskPrompt(task)}\n\nEnd your final response with <comty_result>JSON</comty_result>. The JSON must match this schema: ${JSON.stringify(receiptSchema)}. Write nothing after the closing tag.` }],
-    }, 0);
-    if (result?.stopReason !== 'end_turn') throw new Error(`Cursor stopped: ${result?.stopReason || 'unknown reason'}`);
-    const text = output.trim();
-    const start = text.lastIndexOf('<comty_result>');
-    if (start < 0 || !text.endsWith('</comty_result>')) throw new Error('Cursor did not return a completion receipt');
-    return parseReceipt(text.slice(start + '<comty_result>'.length, -'</comty_result>'.length));
-  } finally { await rpc.close(); }
-}

package/src/dev.mjs

@@ -1,169 +0,0 @@
-#!/usr/bin/env node
-import { createServer, request as httpRequest } from 'node:http';
-import { spawn } from 'node:child_process';
-import { readFile } from 'node:fs/promises';
-import { realpathSync } from 'node:fs';
-import { resolve, delimiter } from 'node:path';
-import { parseArgs } from 'node:util';
-import { pathToFileURL } from 'node:url';
-import { createCompanion, isLoopback } from './companion.mjs';
-
-export async function startDev({ cwd = process.cwd(), target = 'http://127.0.0.1:5173', port = 4387, provider = 'codex', model, projectKey, apiUrl, command = [] } = {}) {
-  const upstream = new URL(target);
-  if (upstream.protocol !== 'http:' || !isLoopback(upstream.hostname) || upstream.username || upstream.password || upstream.pathname !== '/' || upstream.search || upstream.hash) {
-    throw new Error('--target must be a loopback HTTP origin, e.g. http://127.0.0.1:5173');
-  }
-  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('Invalid --port');
-  const runtime = await readFile(new URL('./browser.js', import.meta.url));
-  const style = await readFile(new URL('./style.js', import.meta.url));
-  const anchors = await readFile(new URL('./anchors.js', import.meta.url));
-  const capture = await readFile(new URL('./capture.js', import.meta.url));
-  const comments = await readFile(new URL('./comments.js', import.meta.url));
-  const measurements = await readFile(new URL('./measurements.js', import.meta.url));
-  let companion, origin, child, closing, finished;
-  const sockets = new Set();
-  const proxies = new Set();
-  const server = createServer((request, response) => {
-    if (!origin || request.headers.host !== new URL(origin).host) {
-      response.writeHead(403); response.end('Comty is available on its loopback URL only'); return;
-    }
-    let url;
-    try { url = new URL(request.url, origin); }
-    catch { response.writeHead(400); response.end('Invalid request target'); return; }
-    if (url.origin !== origin) { response.writeHead(400); response.end('Invalid request target'); return; }
-    if (url.pathname.startsWith('/__comty/')) {
-      if (request.headers.origin && request.headers.origin !== origin) {
-        response.writeHead(403); response.end(); return;
-      }
-      if (request.method === 'GET' && ['/__comty/browser.js', '/__comty/style.js', '/__comty/anchors.js', '/__comty/capture.js', '/__comty/comments.js', '/__comty/measurements.js', '/__comty/start.js'].includes(url.pathname)) {
-        response.writeHead(200, { 'Content-Type': 'text/javascript', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' });
-        response.end(url.pathname.endsWith('/browser.js') ? runtime : url.pathname.endsWith('/style.js') ? style : url.pathname.endsWith('/anchors.js') ? anchors : url.pathname.endsWith('/capture.js') ? capture : url.pathname.endsWith('/comments.js') ? comments : url.pathname.endsWith('/measurements.js') ? measurements :
-          `import { initComty } from '/__comty/browser.js';\ninitComty(${JSON.stringify({ projectKey, apiUrl, agent: { url: `${origin}/__comty`, token: companion.token } })}).catch(console.error);`);
-        return;
-      }
-      void companion.handle(request, response); return;
-    }
-    const destination = new URL(upstream);
-    destination.pathname = url.pathname; destination.search = url.search;
-    const proxy = httpRequest(destination, {
-      method: request.method,
-      headers: { ...request.headers, host: upstream.host, 'accept-encoding': 'identity' },
-    }, incoming => {
-      const headers = { ...incoming.headers };
-      if (headers.location?.startsWith(upstream.origin)) headers.location = headers.location.replace(upstream.origin, origin);
-      if (!headers['content-type']?.includes('text/html') || request.method === 'HEAD') {
-        response.writeHead(incoming.statusCode, headers); incoming.pipe(response); return;
-      }
-      // ponytail: buffer development HTML for injection; use the Vite integration for streamed HTML.
-      const chunks = []; let length = 0;
-      incoming.on('data', chunk => {
-        length += chunk.length;
-        if (length > 8 * 1024 * 1024) incoming.destroy(new Error('HTML exceeds the 8 MiB development limit'));
-        else chunks.push(chunk);
-      });
-      incoming.on('error', error => { if (!response.headersSent) response.writeHead(502); response.end(error.message); });
-      incoming.on('end', () => {
-        if (incoming.headers['content-encoding'] && incoming.headers['content-encoding'] !== 'identity') {
-          response.writeHead(502); response.end('Comty requires uncompressed development HTML'); return;
-        }
-        const html = Buffer.concat(chunks).toString('utf8');
-        const script = '<script type="module" src="/__comty/start.js"></script>';
-        const injected = /<head(?:\s[^>]*)?>/i.test(html) ? html.replace(/<head(?:\s[^>]*)?>/i, match => match + script) : script + html;
-        delete headers['content-length']; delete headers.etag; delete headers['content-encoding'];
-        headers['cache-control'] = 'no-store';
-        response.writeHead(incoming.statusCode, headers); response.end(injected);
-      });
-    });
-    proxies.add(proxy); proxy.on('close', () => proxies.delete(proxy));
-    proxy.on('error', () => {
-      if (!response.headersSent) response.writeHead(502, { 'Content-Type': 'text/plain' });
-      response.end(`Development server unavailable at ${upstream.origin}. Check its terminal output and reload.`);
-    });
-    request.on('aborted', () => proxy.destroy());
-    response.on('close', () => proxy.destroy());
-    request.pipe(proxy);
-  });
-  server.on('connection', socket => { sockets.add(socket); socket.on('close', () => sockets.delete(socket)); });
-  server.on('upgrade', (request, socket, head) => {
-    if (request.headers.host !== new URL(origin).host || (request.headers.origin && request.headers.origin !== origin)) return socket.destroy();
-    let url;
-    try { url = new URL(request.url, origin); } catch { return socket.destroy(); }
-    if (url.origin !== origin || url.pathname.startsWith('/__comty/')) return socket.destroy();
-    const destination = new URL(upstream);
-    destination.pathname = url.pathname; destination.search = url.search;
-    const proxy = httpRequest(destination, { headers: { ...request.headers, host: upstream.host } });
-    proxies.add(proxy); proxy.on('close', () => proxies.delete(proxy));
-    proxy.on('upgrade', (response, upstreamSocket, upstreamHead) => {
-      sockets.add(upstreamSocket); upstreamSocket.on('close', () => sockets.delete(upstreamSocket));
-      socket.write(`HTTP/1.1 ${response.statusCode} ${response.statusMessage}\r\n${response.rawHeaders.reduce((text, value, index, all) => index % 2 ? text : text + value + ': ' + all[index + 1] + '\r\n', '')}\r\n`);
-      if (upstreamHead.length) socket.write(upstreamHead);
-      if (head.length) upstreamSocket.write(head);
-      socket.pipe(upstreamSocket).pipe(socket);
-      socket.on('error', () => upstreamSocket.destroy());
-      upstreamSocket.on('error', () => socket.destroy());
-      socket.on('close', () => upstreamSocket.destroy());
-      upstreamSocket.on('close', () => socket.destroy());
-    });
-    proxy.on('response', response => { response.resume(); socket.destroy(); });
-    proxy.on('error', () => socket.destroy());
-    proxy.end();
-  });
-  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
-  origin = `http://127.0.0.1:${server.address().port}`;
-  if (new URL(origin).port === upstream.port) { server.close(); throw new Error('Comty and the application must use different ports'); }
-  try { companion = createCompanion({ cwd, origin, provider, model }); }
-  catch (error) { server.close(); throw error; }
-  async function close() {
-    if (closing) return closing;
-    closing = (async () => {
-      const kill = signal => {
-        if (!child?.pid) return;
-        try {
-          if (process.platform === 'win32') child.kill(signal);
-          else process.kill(-child.pid, signal);
-        } catch (error) { if (error.code !== 'ESRCH') throw error; }
-      };
-      kill('SIGTERM');
-      const force = setTimeout(() => kill('SIGKILL'), 2000);
-      for (const proxy of proxies) proxy.destroy();
-      for (const socket of sockets) socket.destroy();
-      await Promise.all([companion.close(), new Promise(resolve => server.close(resolve)),
-        child && child.exitCode === null && child.signalCode === null ? new Promise(resolve => child.once('close', resolve)) : Promise.resolve()]);
-      clearTimeout(force);
-    })();
-    return closing;
-  }
-  if (command.length) {
-    child = spawn(command[0], command.slice(1), {
-      cwd, stdio: 'inherit', detached: process.platform !== 'win32', env: { ...process.env, PATH: `${resolve(cwd, 'node_modules/.bin')}${delimiter}${process.env.PATH || ''}` },
-    });
-    child.on('error', error => { console.error(`Comty could not start ${command[0]}: ${error.message}`); });
-    finished = new Promise(resolve => child.once('close', code => resolve(Number.isInteger(code) && code >= 0 ? code : 1))).then(async code => {
-      await close();
-      return code;
-    });
-    finished.catch(error => console.error(`Comty shutdown failed: ${error.message}`));
-  }
-  return { origin, close, finished };
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  if (!args.length || args.includes('--help')) {
-    console.log('Usage: comty dev [--agent codex|claude|cursor] [--model MODEL] [--target http://127.0.0.1:5173] [--port 4387] [--project-key KEY --api-url URL] -- vite --strictPort'); return;
-  }
-  if (args.shift() !== 'dev') throw new Error('Expected comty dev. Use --help for usage.');
-  const split = args.indexOf('--');
-  const { values } = parseArgs({ args: split < 0 ? args : args.slice(0, split), options: {
-    target: { type: 'string' }, port: { type: 'string' }, agent: { type: 'string' }, model: { type: 'string' }, 'project-key': { type: 'string' }, 'api-url': { type: 'string' },
-  } });
-  const session = await startDev({ target: values.target, port: values.port === undefined ? 4387 : Number(values.port), provider: values.agent, model: values.model,
-    projectKey: values['project-key'], apiUrl: values['api-url'], command: split < 0 ? [] : args.slice(split + 1) });
-  console.log(`Comty: ${session.origin} — open this URL to annotate. Local tasks: .comty/tasks.json`);
-  for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => { void session.close().catch(console.error); });
-  if (session.finished) process.exitCode = await session.finished;
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
-  main().catch(error => { console.error(`Comty: ${error.message}`); process.exitCode = 1; });
-}

package/src/vite.d.ts

@@ -1,5 +0,0 @@
-import type { Plugin } from 'vite';
-import type { ComtyOptions } from './browser.js';
-
-/** Development only: leaves production builds untouched. */
-export function comty(options?: Pick<ComtyOptions, 'projectKey' | 'apiUrl'> & { agent?: 'codex' | 'claude' | 'cursor'; model?: string }): Plugin;

package/src/vite.mjs

@@ -1,66 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { createCompanion, isLoopback } from './companion.mjs';
-
-/** Starts the local companion on Vite's own origin, without a second port. */
-export function comty(options = {}) {
-  let companion, origin, start;
-  return {
-    name: 'comty', apply: 'serve',
-    configureServer(server) {
-      const host = server.config.server.host;
-      if (host === true || (typeof host === 'string' && !isLoopback(host))) {
-        throw new Error('Comty Agent requires Vite to bind localhost or 127.0.0.1');
-      }
-      if (!server.httpServer) throw new Error('Comty requires a Vite HTTP server (middleware mode is unsupported)');
-      const runtime = new URL('./browser.js', import.meta.url);
-      const style = new URL('./style.js', import.meta.url);
-      const anchors = new URL('./anchors.js', import.meta.url);
-      const capture = new URL('./capture.js', import.meta.url);
-      const comments = new URL('./comments.js', import.meta.url);
-      const measurements = new URL('./measurements.js', import.meta.url);
-      start = new Promise((resolve, reject) => {
-        const onError = error => {
-          // Vite retries the next port after EADDRINUSE unless strictPort is set.
-          if (error.code !== 'EADDRINUSE' || server.config.server.strictPort) reject(error);
-        };
-        server.httpServer.on('error', onError);
-        server.httpServer.once('listening', () => {
-          server.httpServer.off('error', onError);
-          try {
-            const address = server.httpServer.address();
-            const hostname = typeof host === 'string' ? host : 'localhost';
-            origin = `${server.config.server.https ? 'https' : 'http'}://${hostname}:${address.port}`;
-            companion = createCompanion({ cwd: server.config.root, origin, provider: options.agent, model: options.model });
-            server.httpServer.once('close', () => { void companion.close().catch(error => server.config.logger.error(`Comty: ${error.message}`)); });
-            resolve();
-          } catch (error) { reject(error); }
-        });
-      });
-      start.catch(error => server.config.logger.error(`Comty: ${error.message}`));
-      server.middlewares.use(async (request, response, next) => {
-        if (!request.url?.startsWith('/__comty/')) return next();
-        try {
-          await start;
-          if (request.headers.host !== new URL(origin).host || (request.headers.origin && request.headers.origin !== origin)) {
-            response.writeHead(403); response.end(); return;
-          }
-          const path = new URL(request.url, origin).pathname;
-          if (request.method === 'GET' && ['/__comty/browser.js', '/__comty/style.js', '/__comty/anchors.js', '/__comty/capture.js', '/__comty/comments.js', '/__comty/measurements.js', '/__comty/start.js'].includes(path)) {
-            response.setHeader('Content-Type', 'text/javascript'); response.setHeader('Cache-Control', 'no-store');
-            response.setHeader('X-Content-Type-Options', 'nosniff');
-            response.end(path.endsWith('/browser.js') ? await readFile(runtime) : path.endsWith('/style.js') ? await readFile(style) : path.endsWith('/anchors.js') ? await readFile(anchors) : path.endsWith('/capture.js') ? await readFile(capture) : path.endsWith('/comments.js') ? await readFile(comments) : path.endsWith('/measurements.js') ? await readFile(measurements) :
-              `import { initComty } from '/__comty/browser.js';\ninitComty(${JSON.stringify({ projectKey: options.projectKey, apiUrl: options.apiUrl, agent: { url: `${origin}/__comty`, token: companion.token } })}).catch(console.error);`);
-          } else await companion.handle(request, response);
-        } catch (error) { next(error); }
-      });
-    },
-    transformIndexHtml: {
-      order: 'pre',
-      async handler() {
-        await start;
-        return [{ tag: 'script', attrs: { type: 'module', src: '/__comty/start.js', 'vite-ignore': '' }, injectTo: 'head-prepend' }];
-      },
-    },
-    async closeBundle() { await companion?.close(); },
-  };
-}