@opencoven/coven-code 0.0.3 → 0.0.6

package/src/mcp/remote-oauth.mjs

@@ -1,55 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-export function oauthMcpHeaders(serverName = '') {
-  const credential = readMcpOauthCredential(serverName);
-  return credential.accessToken || credential.access_token ? { Authorization: `Bearer ${credential.accessToken ?? credential.access_token}` } : {};
-}
-
-function readMcpOauthCredential(serverName = '') {
-  if (!serverName) return {};
-  try {
-    return JSON.parse(readFileSync(mcpOauthCredentialPath(serverName), 'utf8'));
-  } catch {
-    return {};
-  }
-}
-
-export async function refreshMcpOauthToken(serverName = '', config = {}) {
-  if (hasExplicitAuthorizationHeader(config)) return false;
-  const credential = readMcpOauthCredential(serverName);
-  const refreshToken = credential.refreshToken ?? credential.refresh_token;
-  const tokenUrl = credential.tokenUrl ?? credential.token_url;
-  if (!refreshToken || !tokenUrl) return false;
-  const response = await fetch(tokenUrl, {
-    method: 'POST',
-    headers: { 'content-type': 'application/x-www-form-urlencoded' },
-    body: new URLSearchParams({
-      grant_type: 'refresh_token',
-      refresh_token: refreshToken,
-      ...(credential.clientId || credential.client_id ? { client_id: credential.clientId ?? credential.client_id } : {}),
-      ...(credential.clientSecret || credential.client_secret ? { client_secret: credential.clientSecret ?? credential.client_secret } : {}),
-    }),
-  });
-  if (!response.ok) return false;
-  const token = await response.json();
-  const nextCredential = {
-    ...credential,
-    accessToken: token.access_token ?? token.accessToken ?? credential.accessToken,
-    refreshToken: token.refresh_token ?? token.refreshToken ?? credential.refreshToken,
-    ...(token.expires_in || token.expiresIn ? { expiresAt: Date.now() + Number(token.expires_in ?? token.expiresIn) * 1000 } : {}),
-  };
-  const credentialPath = mcpOauthCredentialPath(serverName);
-  mkdirSync(path.dirname(credentialPath), { recursive: true, mode: 0o700 });
-  writeFileSync(credentialPath, `${JSON.stringify(nextCredential, null, 2)}\n`, { mode: 0o600 });
-  return Boolean(nextCredential.accessToken);
-}
-
-function hasExplicitAuthorizationHeader(config = {}) {
-  return Object.keys(config.headers ?? {}).some((key) => key.toLowerCase() === 'authorization');
-}
-
-function mcpOauthCredentialPath(serverName) {
-  return path.join(os.homedir(), '.coven-code', 'oauth', `${serverName}.json`);
-}

package/src/mcp/remote-session.mjs

@@ -1,54 +0,0 @@
-import { oauthMcpHeaders } from './remote-oauth.mjs';
-
-export const remoteMcpSessions = new Map();
-
-export function remoteMcpHeaders(config = {}, accept, serverName = '') {
-  return {
-    'content-type': 'application/json',
-    accept,
-    ...oauthMcpHeaders(serverName),
-    ...remoteMcpSessionHeader(config, serverName),
-    ...(config.headers ?? {}),
-  };
-}
-
-export async function initializeRemoteMcpSession(config = {}, serverName = '', signal) {
-  const response = await fetch(config.url, {
-    method: 'POST',
-    headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-    body: JSON.stringify({
-      jsonrpc: '2.0',
-      id: 0,
-      method: 'initialize',
-      params: {
-        protocolVersion: '2025-06-18',
-        capabilities: {},
-        clientInfo: { name: 'coven-code', version: '0.0.0' },
-      },
-    }),
-    signal,
-  });
-  rememberRemoteMcpSession(config, serverName, response);
-  if (!response.ok || !remoteMcpSessions.has(remoteMcpSessionKey(config, serverName))) return false;
-  await fetch(config.url, {
-    method: 'POST',
-    headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-    body: JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }),
-    signal,
-  });
-  return true;
-}
-
-export function rememberRemoteMcpSession(config = {}, serverName = '', response) {
-  const sessionId = response.headers.get('mcp-session-id');
-  if (sessionId) remoteMcpSessions.set(remoteMcpSessionKey(config, serverName), sessionId);
-}
-
-function remoteMcpSessionHeader(config = {}, serverName = '') {
-  const sessionId = remoteMcpSessions.get(remoteMcpSessionKey(config, serverName));
-  return sessionId ? { 'Mcp-Session-Id': sessionId } : {};
-}
-
-export function remoteMcpSessionKey(config = {}, serverName = '') {
-  return `${serverName}\n${config.url ?? ''}`;
-}

package/src/mcp/remote-sse.mjs

@@ -1,82 +0,0 @@
-import { refreshMcpOauthToken } from './remote-oauth.mjs';
-import { rememberRemoteMcpSession, remoteMcpHeaders } from './remote-session.mjs';
-
-export async function postLegacySseMcp(config = {}, body, signal, serverName = '') {
-  const endpoint = await discoverLegacySseEndpoint(config, signal, serverName);
-  if (!endpoint) return {};
-  const response = await fetch(endpoint, {
-    method: 'POST',
-    headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-    body,
-    signal,
-  });
-  rememberRemoteMcpSession(config, serverName, response);
-  if (response.status === 401 && await refreshMcpOauthToken(serverName, config)) {
-    const retry = await fetch(endpoint, {
-      method: 'POST',
-      headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-      body,
-      signal,
-    });
-    rememberRemoteMcpSession(config, serverName, retry);
-    return parseRemoteMcpResponse(await retry.text());
-  }
-  return parseRemoteMcpResponse(await response.text());
-}
-
-async function discoverLegacySseEndpoint(config = {}, signal, serverName = '') {
-  const response = await fetch(config.url, {
-    method: 'GET',
-    headers: remoteMcpHeaders(config, 'text/event-stream', serverName),
-    signal,
-  });
-  if (!response.ok) return '';
-  return resolveRemoteMcpUrl(config.url, parseLegacySseEndpoint(await response.text()));
-}
-
-function parseLegacySseEndpoint(text = '') {
-  let event = 'message';
-  const data = [];
-  for (const line of text.split(/\r?\n/)) {
-    if (!line) {
-      if (event === 'endpoint' && data.length) return data.join('\n').trim();
-      event = 'message';
-      data.length = 0;
-      continue;
-    }
-    if (line.startsWith(':')) continue;
-    const separator = line.indexOf(':');
-    const field = separator === -1 ? line : line.slice(0, separator);
-    const value = separator === -1 ? '' : line.slice(separator + 1).replace(/^ /, '');
-    if (field === 'event') event = value;
-    if (field === 'data') data.push(value);
-  }
-  if (event === 'endpoint' && data.length) return data.join('\n').trim();
-  return '';
-}
-
-function resolveRemoteMcpUrl(base, endpoint) {
-  if (!endpoint) return '';
-  try {
-    return new URL(endpoint, base).href;
-  } catch {
-    return '';
-  }
-}
-
-export function parseRemoteMcpResponse(text = '') {
-  for (const chunk of text.split(/\r?\n/).filter(Boolean)) {
-    const line = chunk.startsWith('data:') ? chunk.slice('data:'.length).trim() : chunk.trim();
-    if (!line || line === '[DONE]') continue;
-    try {
-      return JSON.parse(line);
-    } catch {
-      // Remote MCP servers can include diagnostic or event wrapper lines.
-    }
-  }
-  try {
-    return JSON.parse(text);
-  } catch {
-    return {};
-  }
-}

package/src/mcp/remote.mjs

@@ -1,74 +0,0 @@
-import { parseMcpCallOutput, parseMcpResourceOutput } from './parsers.mjs';
-import { refreshMcpOauthToken } from './remote-oauth.mjs';
-import {
-  initializeRemoteMcpSession,
-  rememberRemoteMcpSession,
-  remoteMcpHeaders,
-  remoteMcpSessionKey,
-  remoteMcpSessions,
-} from './remote-session.mjs';
-import { parseRemoteMcpResponse, postLegacySseMcp } from './remote-sse.mjs';
-
-export async function queryRemoteMcpTools(config = {}, serverName = '') {
-  const message = await postRemoteMcp(config, 'tools/list', {}, serverName);
-  if (Array.isArray(message.result?.tools)) return message.result.tools;
-  if (Array.isArray(message.tools)) return message.tools;
-  return [];
-}
-
-export async function callRemoteMcpTool(config = {}, name, args = {}, serverName = '') {
-  const message = await postRemoteMcp(config, 'tools/call', { name, arguments: args }, serverName);
-  return parseMcpCallOutput(`${JSON.stringify(message)}\n`);
-}
-
-export async function readRemoteMcpResource(config = {}, uri, serverName = '') {
-  const message = await postRemoteMcp(config, 'resources/read', { uri }, serverName);
-  return parseMcpResourceOutput(`${JSON.stringify(message)}\n`);
-}
-
-async function postRemoteMcp(config = {}, method, params, serverName = '') {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 1500);
-  const body = JSON.stringify({ jsonrpc: '2.0', id: 1, method, params });
-  try {
-    if (config.transport === 'sse') {
-      return await postLegacySseMcp(config, body, controller.signal, serverName);
-    }
-    const response = await fetch(config.url, {
-      method: 'POST',
-      headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-      body,
-      signal: controller.signal,
-    });
-    rememberRemoteMcpSession(config, serverName, response);
-    if (response.status === 400 && !remoteMcpSessions.has(remoteMcpSessionKey(config, serverName)) && await initializeRemoteMcpSession(config, serverName, controller.signal)) {
-      const retry = await fetch(config.url, {
-        method: 'POST',
-        headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-        body,
-        signal: controller.signal,
-      });
-      rememberRemoteMcpSession(config, serverName, retry);
-      return parseRemoteMcpResponse(await retry.text());
-    }
-    if (response.status === 401 && await refreshMcpOauthToken(serverName, config)) {
-      const retry = await fetch(config.url, {
-        method: 'POST',
-        headers: remoteMcpHeaders(config, 'application/json, text/event-stream', serverName),
-        body,
-        signal: controller.signal,
-      });
-      rememberRemoteMcpSession(config, serverName, retry);
-      return parseRemoteMcpResponse(await retry.text());
-    }
-    if (response.status >= 400 && response.status < 500) {
-      return await postLegacySseMcp(config, body, controller.signal, serverName);
-    }
-    const text = await response.text();
-    return parseRemoteMcpResponse(text);
-  } catch {
-    return {};
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/plugins/api.mjs

@@ -1,187 +0,0 @@
-import { pathToFileURL } from 'node:url';
-import { createPluginConfigurationApi } from './configuration.mjs';
-import {
-  filePathFromURI,
-  filesModifiedByToolCall,
-  isPluginUINotAvailableError,
-  runPluginShell,
-  toolCallsInMessages,
-} from './helpers.mjs';
-import {
-  createPluginAI,
-  createPluginExperimentalApi,
-  createPluginLogger,
-  createPluginSystem,
-  createPluginThreadContext,
-  pluginEnvConfirm,
-  pluginEnvInput,
-  pluginEnvSelection,
-} from './subsystems.mjs';
-import { createSubscription } from './configuration.mjs';
-import {
-  removeFirst,
-  validateCommandAvailability,
-  validatePluginCommand,
-  validatePluginConfirmOptions,
-  validatePluginInputOptions,
-  validatePluginNotifyMessage,
-  validatePluginSelectOptions,
-  validatePluginToolDefinition,
-  validatePluginToolName,
-} from './validators.mjs';
-
-export function createPluginApi({ cwd, runtime }) {
-  return {
-    registerTool(tool) {
-      const summary = runtime.currentPlugin;
-      validatePluginToolName(tool?.name);
-      validatePluginToolDefinition(tool);
-      const registeredTool = { ...tool };
-      if (tool?.name) summary?.tools.push(tool.name);
-      runtime.tools.push(registeredTool);
-      return createSubscription(() => {
-        runtime.tools = runtime.tools.filter((entry) => entry !== registeredTool);
-        if (tool?.name && summary) removeFirst(summary.tools, tool.name);
-      });
-    },
-    registerCommand(name, metadata = {}, handler = async () => undefined) {
-      const summary = runtime.currentPlugin;
-      validatePluginCommand(name, metadata);
-      summary?.commands.push(name);
-      const commandMetadata = {
-        ...metadata,
-        category: metadata.category ?? summary?.name,
-      };
-      const command = {
-        name,
-        metadata: commandMetadata,
-        handler,
-        availability: validateCommandAvailability(name, commandMetadata.availability ?? { type: 'enabled' }),
-      };
-      runtime.commands.push(command);
-      return {
-        setAvailability(availability) {
-          command.availability = validateCommandAvailability(name, availability);
-        },
-        ...createSubscription(() => {
-          runtime.commands = runtime.commands.filter((entry) => entry !== command);
-          if (summary) removeFirst(summary.commands, name);
-        }),
-      };
-    },
-    on(eventName, handler) {
-      const summary = runtime.currentPlugin;
-      summary?.events.push(eventName);
-      if (!runtime.handlers[eventName]) runtime.handlers[eventName] = [];
-      runtime.handlers[eventName].push(handler);
-      return createSubscription(() => {
-        runtime.handlers[eventName] = (runtime.handlers[eventName] ?? []).filter((entry) => entry !== handler);
-        if (summary) removeFirst(summary.events, eventName);
-      });
-    },
-    configuration: createPluginConfigurationApi(cwd, runtime),
-    ai: createPluginAI(),
-    helpers: {
-      shellCommandFromToolCall(event = {}) {
-        if (event.tool !== 'Bash' && event.tool !== 'shell_command') return null;
-        const command = event.input?.command ?? event.input?.cmd;
-        if (typeof command !== 'string' || !command) return null;
-        const dir = typeof event.input?.dir === 'string' && event.input.dir ? event.input.dir : undefined;
-        return dir ? { command, dir } : { command };
-      },
-      toolCallsInMessages(messages = []) {
-        return toolCallsInMessages(messages);
-      },
-      filesModifiedByToolCall(event = {}) {
-        const files = filesModifiedByToolCall(event);
-        return files ? files.map((filePath) => pathToFileURL(filePath)) : null;
-      },
-      filePathFromURI(uri) {
-        return filePathFromURI(uri);
-      },
-      isPluginUINotAvailableError(error) {
-        return isPluginUINotAvailableError(error);
-      },
-    },
-    logger: createPluginLogger(),
-    system: createPluginSystem((target) => {
-      runtime.notifications.push(String(target));
-    }),
-    ui: {
-      async notify(message) {
-        runtime.notifications.push(validatePluginNotifyMessage(message));
-      },
-      confirm: async (options) => pluginEnvConfirm(options),
-      input: async (options) => pluginEnvInput(options),
-      select: async (options) => pluginEnvSelection(options),
-    },
-    $: (strings, ...values) => runPluginShell(cwd, strings, values),
-    experimental: createPluginExperimentalApi(runtime),
-  };
-}
-
-export function createPluginContext(event = {}) {
-  return {
-    logger: createPluginLogger(),
-    $: (strings, ...values) => runPluginShell(process.cwd(), strings, values),
-    ui: {
-      async notify(message) {
-        validatePluginNotifyMessage(message);
-      },
-      confirm: async (options) => {
-        validatePluginConfirmOptions(options);
-        return false;
-      },
-      input: async (options) => {
-        validatePluginInputOptions(options);
-        return undefined;
-      },
-      select: async (options) => {
-        validatePluginSelectOptions(options);
-        return undefined;
-      },
-    },
-    ai: createPluginAI(),
-    system: createPluginSystem(),
-    thread: createPluginThreadContext(event.thread?.id),
-  };
-}
-
-export function createPluginCommandContext(cwd = process.cwd()) {
-  const notifications = [];
-  const context = {
-    ui: {
-      async notify(message) {
-        notifications.push(validatePluginNotifyMessage(message));
-      },
-      confirm: async (options) => pluginEnvConfirm(options),
-      input: async (options) => pluginEnvInput(options),
-      select: async (options) => pluginEnvSelection(options),
-    },
-    system: createPluginSystem((target) => {
-      notifications.push(String(target));
-    }),
-    ai: createPluginAI(),
-    $: (strings, ...values) => runPluginShell(cwd, strings, values),
-    thread: createPluginThreadContext(),
-  };
-  Object.defineProperty(context, 'notifications', {
-    value: notifications,
-    enumerable: false,
-  });
-  return context;
-}
-
-export function createPluginToolContext() {
-  return {
-    ui: {
-      notify: async (message) => {
-        validatePluginNotifyMessage(message);
-      },
-      confirm: async (options) => pluginEnvConfirm(options),
-      input: async (options) => pluginEnvInput(options),
-      select: async (options) => pluginEnvSelection(options),
-    },
-    logger: createPluginLogger(),
-  };
-}

package/src/plugins/configuration.mjs

@@ -1,124 +0,0 @@
-import {
-  SETTINGS_PREFIX,
-  readEffectiveSettings,
-  readSettings,
-  readSettingsFile,
-  writeSettings,
-  writeSettingsFile,
-} from '../settings/load.mjs';
-import { findProjectRoot, workspaceSettingsFile } from '../settings/paths.mjs';
-
-export function createSubscription(dispose) {
-  return {
-    unsubscribe: dispose,
-  };
-}
-
-export function createPluginConfigurationApi(cwd, runtime) {
-  const observableSymbol = Symbol.observable ?? Symbol.for('observable');
-  const api = {
-    async get() {
-      return pluginConfiguration(readEffectiveSettings());
-    },
-    async update(patch = {}, scope = 'workspace') {
-      const normalizedPatch = normalizePluginConfigurationPatch(patch);
-      const target = normalizePluginConfigurationTarget(scope);
-      if (target === 'workspace') {
-        const filePath = workspaceSettingsFile(findProjectRoot(cwd));
-        await writeSettingsFile(filePath, { ...readSettingsFile(filePath), ...normalizedPatch });
-      } else {
-        await writeSettings({ ...readSettings(), ...normalizedPatch });
-      }
-      await notifyConfigurationSubscribers(runtime);
-    },
-    async delete(key, scope = 'workspace') {
-      const normalizedKey = normalizePluginConfigurationKey(key);
-      const target = normalizePluginConfigurationTarget(scope);
-      if (target === 'workspace') {
-        const filePath = workspaceSettingsFile(findProjectRoot(cwd));
-        const settings = readSettingsFile(filePath);
-        delete settings[normalizedKey];
-        await writeSettingsFile(filePath, settings);
-      } else {
-        const settings = readSettings();
-        delete settings[normalizedKey];
-        await writeSettings(settings);
-      }
-      await notifyConfigurationSubscribers(runtime);
-    },
-    subscribe(handler) {
-      validateObservableSubscriber(handler);
-      runtime.configurationSubscribers.push(handler);
-      return createSubscription(() => {
-        runtime.configurationSubscribers = runtime.configurationSubscribers.filter((entry) => entry !== handler);
-      });
-    },
-    pipe(op) {
-      return op(api);
-    },
-    [observableSymbol]() {
-      return api;
-    },
-  };
-  return api;
-}
-
-function pluginConfiguration(settings = {}) {
-  const config = { ...settings };
-  for (const [key, value] of Object.entries(settings)) {
-    if (key.startsWith(SETTINGS_PREFIX) && !Object.hasOwn(config, key.slice(SETTINGS_PREFIX.length))) {
-      config[key.slice(SETTINGS_PREFIX.length)] = value;
-    }
-  }
-  return config;
-}
-
-function normalizePluginConfigurationPatch(patch = {}) {
-  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
-    throw new Error('plugin configuration update patch must be an object');
-  }
-  return Object.fromEntries(Object.entries(patch).map(([key, value]) => [
-    normalizePluginConfigurationKey(key),
-    value,
-  ]));
-}
-
-function normalizePluginConfigurationKey(key) {
-  if (typeof key !== 'string') {
-    throw new Error('plugin configuration key must be a string');
-  }
-  const text = String(key);
-  if (text.startsWith(SETTINGS_PREFIX)) return text;
-  return `${SETTINGS_PREFIX}${text}`;
-}
-
-function normalizePluginConfigurationTarget(target = 'workspace') {
-  if (target !== 'workspace' && target !== 'global') {
-    throw new Error(`plugin configuration target must be workspace or global: ${String(target)}`);
-  }
-  return target;
-}
-
-async function notifyConfigurationSubscribers(runtime) {
-  if (runtime.configurationSubscribers.length === 0) return;
-  const config = pluginConfiguration(readEffectiveSettings());
-  for (const subscriber of runtime.configurationSubscribers) {
-    await notifyObservableSubscriber(subscriber, config);
-  }
-}
-
-export async function notifyObservableSubscriber(subscriber, value) {
-  if (typeof subscriber === 'function') {
-    await subscriber(value);
-    return;
-  }
-  if (typeof subscriber?.next === 'function') {
-    await subscriber.next(value);
-  }
-}
-
-export function validateObservableSubscriber(subscriber) {
-  if (typeof subscriber === 'function') return;
-  if (subscriber && typeof subscriber === 'object' && !Array.isArray(subscriber)) return;
-  throw new Error('plugin observable subscriber must be a function or observer object');
-}

package/src/plugins/discover.mjs

@@ -1,84 +0,0 @@
-import { existsSync, readdirSync } from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { configDir, findProjectRoot } from '../settings/paths.mjs';
-import {
-  createPluginApi,
-  createPluginCommandContext,
-  createPluginContext,
-  createPluginToolContext,
-} from './api.mjs';
-
-export { createPluginCommandContext, createPluginToolContext };
-
-export function discoverPluginFiles(cwd) {
-  const projectRoot = findProjectRoot(cwd);
-  return [
-    ...readPluginDir(path.join(projectRoot, '.coven-code', 'plugins'), 'project'),
-    ...readPluginDir(path.join(configDir(), 'coven-code', 'plugins'), 'user'),
-  ];
-}
-
-function readPluginDir(dir, source) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((entry) => entry.endsWith('.ts'))
-    .sort((a, b) => a.localeCompare(b))
-    .map((entry) => ({
-      name: path.basename(entry, '.ts'),
-      source,
-      path: path.join(dir, entry),
-    }));
-}
-
-export async function loadPlugins(cwd) {
-  const runtime = {
-    tools: [],
-    commands: [],
-    handlers: {},
-    configurationSubscribers: [],
-    notifications: [],
-    statusItems: [],
-    pluginSummaries: [],
-    currentPlugin: undefined,
-  };
-  const seen = new Set();
-  const api = createPluginApi({ cwd, runtime });
-  for (const plugin of discoverPluginFiles(cwd)) {
-    const module = await import(pathToFileURL(plugin.path).href);
-    const summary = {
-      name: plugin.name,
-      source: plugin.source,
-      path: plugin.path,
-      tools: [],
-      commands: [],
-      events: [],
-    };
-    runtime.currentPlugin = summary;
-    if (typeof module.default === 'function') await module.default(api);
-    runtime.pluginSummaries.push(summary);
-    runtime.currentPlugin = undefined;
-  }
-  runtime.tools = runtime.tools.filter((tool) => {
-    if (!tool?.name || seen.has(tool.name)) return false;
-    seen.add(tool.name);
-    return true;
-  });
-  runtime.commands = runtime.commands.filter((command) => command?.name);
-  return runtime;
-}
-
-export async function listPluginTools(cwd) {
-  return (await loadPlugins(cwd)).tools;
-}
-
-export async function runPluginEventHandlers(handlers = [], event = {}, validateResult = () => {}) {
-  let decision;
-  for (const handler of handlers) {
-    const result = await handler(event, createPluginContext(event));
-    if (result) validateResult(result);
-    if (!result || result.action === 'allow') continue;
-    decision ??= result;
-  }
-  return decision ?? { action: 'allow' };
-}