@modelprofile.com/mcp-crossharness 5.0.0

package/ts/classes.connection.opencode.ts

@@ -0,0 +1,443 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+import type * as interfaces from './interfaces.js';
+import type { IOpenCodeCredentials } from './classes.connectionregistry.js';
+
+const serverApiVersion = '1.18.13';
+
+interface IOpencodeRequestOptions {
+  method?: 'GET' | 'POST';
+  query?: Record<string, string>;
+  body?: unknown;
+  timeoutMs: number;
+  signal?: AbortSignal;
+}
+
+export class OpencodeConnection implements interfaces.IHarnessConnection {
+  public readonly harness = 'opencode' as const;
+  public state: interfaces.TConnectionState = 'connecting';
+  private connectedAt = new Date().toISOString();
+  private serverVersion: string | undefined;
+  private activeControllers = new Set<AbortController>();
+  private connectStarted = false;
+
+  constructor(
+    public readonly connectionId: string,
+    public readonly serverUrl: string,
+    public readonly directory: string,
+    private onClosing?: () => void,
+    private onClosed?: () => void,
+    private readonly credentials?: IOpenCodeCredentials,
+  ) {}
+
+  public async connect(): Promise<void> {
+    if (this.connectStarted) {
+      throw new Error(`OpenCode connection ${this.connectionId} has already been started`);
+    }
+    this.connectStarted = true;
+    const health = await this.requestJson('/global/health', { timeoutMs: 5000 }, true);
+    if (!helpers.isRecord(health) || health.healthy !== true || typeof health.version !== 'string') {
+      throw new Error(
+        `OpenCode server at ${this.serverUrl} returned an invalid health response (expected API verified against ${serverApiVersion})`,
+      );
+    }
+    this.serverVersion = health.version;
+    this.state = 'connected';
+  }
+
+  public getInfo(): interfaces.IConnectionInfo {
+    return {
+      connectionId: this.connectionId,
+      harness: this.harness,
+      serverUrl: this.serverUrl,
+      directory: this.directory,
+      state: this.state,
+      connectedAt: this.connectedAt,
+      serverVersion: this.serverVersion,
+    };
+  }
+
+  public async getStatus(): Promise<interfaces.IConnectionStatus> {
+    if (this.state !== 'connected') {
+      return { ...this.getInfo(), healthy: false, detail: `connection is ${this.state}` };
+    }
+    try {
+      const health = await this.requestJson('/global/health', { timeoutMs: 5000 });
+      const healthy = helpers.isRecord(health) && health.healthy === true;
+      return {
+        ...this.getInfo(),
+        healthy,
+        detail: healthy ? 'OpenCode /global/health reported healthy' : 'invalid health response',
+      };
+    } catch (error) {
+      return { ...this.getInfo(), healthy: false, detail: helpers.errorMessage(error) };
+    }
+  }
+
+  public async listChats(limitArg: number): Promise<interfaces.IChatSummary[]> {
+    const payload = await this.requestJson('/session', {
+      query: { directory: this.directory, roots: 'true', limit: String(limitArg) },
+      timeoutMs: 30000,
+    });
+    if (!Array.isArray(payload)) {
+      throw new Error('OpenCode server returned an invalid session list');
+    }
+    const sessions = payload.map((entry) => this.parseSession(entry));
+    if (sessions.some((session) => session.directory !== this.directory)) {
+      throw new Error('OpenCode server returned a session outside the connection directory');
+    }
+    return sessions
+      .filter((session) => session.parentID === undefined)
+      .slice(0, limitArg)
+      .map((session) => ({
+        harness: this.harness,
+        chatId: session.id,
+        title: session.title,
+        directory: session.directory,
+        updatedAt: new Date(session.updatedMs).toISOString(),
+        isActive: Date.now() - session.updatedMs < 120000,
+      }));
+  }
+
+  public async readChat(
+    chatIdArg: string,
+    limitArg: number,
+    maxCharsArg: number,
+  ): Promise<interfaces.IChatTranscript> {
+    this.assertChatId(chatIdArg);
+    const session = await this.requireSession(chatIdArg);
+    const payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}/message`, {
+      query: { directory: this.directory, limit: String(limitArg) },
+      timeoutMs: 30000,
+    });
+    if (!Array.isArray(payload)) {
+      throw new Error('OpenCode server returned an invalid message list');
+    }
+    const messages = payload.map((entry) => this.parseMessage(entry, chatIdArg, maxCharsArg));
+    return {
+      harness: this.harness,
+      chatId: chatIdArg,
+      title: session.title,
+      directory: session.directory,
+      messages,
+    };
+  }
+
+  public async sendMessage(
+    chatIdArg: string,
+    messageArg: string,
+    timeoutSecondsArg: number,
+    signalArg?: AbortSignal,
+  ): Promise<interfaces.ISendResult> {
+    this.assertChatId(chatIdArg);
+    if (messageArg.length > 1024 * 1024) {
+      throw new Error('OpenCode message exceeds the 1 MiB character limit');
+    }
+    const deadline = Date.now() + timeoutSecondsArg * 1000;
+    await this.requireSession(
+      chatIdArg,
+      this.remainingSendMs(deadline, timeoutSecondsArg),
+      signalArg,
+    );
+    const requestMessageId = `msg_${plugins.crypto.randomUUID().replaceAll('-', '')}`;
+    let payload: unknown;
+    try {
+      payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}/message`, {
+        method: 'POST',
+        query: { directory: this.directory },
+        body: {
+          messageID: requestMessageId,
+          parts: [{ type: 'text', text: messageArg }],
+        },
+        timeoutMs: this.remainingSendMs(deadline, timeoutSecondsArg),
+        signal: signalArg,
+      });
+    } catch (error) {
+      throw new Error(
+        `OpenCode send failed; the server may still have queued or started the turn, and Crossharness did not retry: ${helpers.errorMessage(error)}`,
+        { cause: error },
+      );
+    }
+    const parsed = this.parseMessageEnvelope(payload, chatIdArg);
+    if (parsed.info.role !== 'assistant' || parsed.info.parentID !== requestMessageId) {
+      throw new Error('OpenCode server returned an assistant response for a different prompt');
+    }
+    if (parsed.info.error !== undefined && parsed.info.error !== null) {
+      throw new Error('OpenCode server returned an assistant error');
+    }
+    const reply = parsed.parts
+      .filter((part) => part.type === 'text' && typeof part.text === 'string')
+      .map((part) => part.text as string)
+      .join('\n')
+      .trim();
+    if (!reply) {
+      throw new Error('OpenCode server returned no assistant text');
+    }
+    return {
+      harness: this.harness,
+      chatId: chatIdArg,
+      reply,
+      via: `http:${this.serverUrl}`,
+    };
+  }
+
+  public async close(reasonArg = 'connection disconnected'): Promise<void> {
+    if (this.state === 'closed') return;
+    this.state = 'closing';
+    this.onClosing?.();
+    this.onClosing = undefined;
+    for (const controller of this.activeControllers) {
+      controller.abort(new Error(reasonArg));
+    }
+    this.activeControllers.clear();
+    this.state = 'closed';
+    this.onClosed?.();
+    this.onClosed = undefined;
+  }
+
+  private async requireSession(
+    chatIdArg: string,
+    timeoutMsArg = 30000,
+    signalArg?: AbortSignal,
+  ): Promise<{
+    id: string;
+    title: string;
+    directory: string;
+    updatedMs: number;
+    parentID?: string;
+  }> {
+    const payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}`, {
+      query: { directory: this.directory },
+      timeoutMs: timeoutMsArg,
+      signal: signalArg,
+    });
+    const session = this.parseSession(payload);
+    if (session.id !== chatIdArg) {
+      throw new Error(`OpenCode server returned a different session for ${chatIdArg}`);
+    }
+    if (session.directory !== this.directory) {
+      throw new Error(`OpenCode session ${chatIdArg} is outside the connection directory`);
+    }
+    return session;
+  }
+
+  private parseSession(valueArg: unknown): {
+    id: string;
+    title: string;
+    directory: string;
+    updatedMs: number;
+    parentID?: string;
+  } {
+    if (!helpers.isRecord(valueArg) || !helpers.isRecord(valueArg.time)) {
+      throw new Error('OpenCode server returned an invalid session');
+    }
+    const updatedMs = Number(valueArg.time.updated);
+    if (
+      typeof valueArg.id !== 'string' ||
+      typeof valueArg.title !== 'string' ||
+      typeof valueArg.directory !== 'string' ||
+      !Number.isFinite(updatedMs) ||
+      (valueArg.parentID !== undefined && typeof valueArg.parentID !== 'string')
+    ) {
+      throw new Error('OpenCode server returned an invalid session');
+    }
+    return {
+      id: valueArg.id,
+      title: valueArg.title,
+      directory: valueArg.directory,
+      updatedMs,
+      parentID: valueArg.parentID,
+    };
+  }
+
+  private parseMessage(
+    valueArg: unknown,
+    chatIdArg: string,
+    maxCharsArg: number,
+  ): interfaces.IChatMessage {
+    const parsed = this.parseMessageEnvelope(valueArg, chatIdArg);
+    const textParts = parsed.parts
+      .filter((part) => part.type === 'text' && typeof part.text === 'string')
+      .map((part) => part.text as string);
+    const toolParts = parsed.parts
+      .filter((part) => part.type === 'tool' && typeof part.tool === 'string')
+      .map((part) => `[tool: ${part.tool as string}]`);
+    const created = helpers.isRecord(parsed.info.time) ? Number(parsed.info.time.created) : NaN;
+    return {
+      role: parsed.info.role,
+      text: helpers.truncateText([...textParts, ...toolParts].join('\n').trim(), maxCharsArg),
+      timestamp: Number.isFinite(created) ? new Date(created).toISOString() : undefined,
+    };
+  }
+
+  private parseMessageEnvelope(valueArg: unknown, chatIdArg: string): {
+    info: Record<string, unknown> & { id: string; role: string; sessionID: string; parentID?: string };
+    parts: Array<Record<string, unknown> & { type: string }>;
+  } {
+    if (!helpers.isRecord(valueArg) || !helpers.isRecord(valueArg.info) || !Array.isArray(valueArg.parts)) {
+      throw new Error('OpenCode server returned an invalid message');
+    }
+    const info = valueArg.info;
+    if (
+      typeof info.id !== 'string' ||
+      typeof info.role !== 'string' ||
+      info.sessionID !== chatIdArg ||
+      (info.parentID !== undefined && typeof info.parentID !== 'string')
+    ) {
+      throw new Error('OpenCode server returned an invalid message identity');
+    }
+    const parts = valueArg.parts.map((part) => {
+      if (
+        !helpers.isRecord(part) ||
+        typeof part.type !== 'string' ||
+        part.sessionID !== chatIdArg ||
+        part.messageID !== info.id
+      ) {
+        throw new Error('OpenCode server returned an invalid message part');
+      }
+      return part as Record<string, unknown> & { type: string };
+    });
+    return {
+      info: info as Record<string, unknown> & {
+        id: string;
+        role: string;
+        sessionID: string;
+        parentID?: string;
+      },
+      parts,
+    };
+  }
+
+  private async requestJson(
+    pathArg: string,
+    optionsArg: IOpencodeRequestOptions,
+    allowConnectingArg = false,
+  ): Promise<unknown> {
+    if (!allowConnectingArg && this.state !== 'connected') {
+      throw new Error(`OpenCode connection ${this.connectionId} is ${this.state}`);
+    }
+    const url = new URL(pathArg, `${this.serverUrl}/`);
+    for (const [key, value] of Object.entries(optionsArg.query ?? {})) {
+      url.searchParams.set(key, value);
+    }
+    const controller = new AbortController();
+    if (this.activeControllers.size >= 100) {
+      throw new Error('OpenCode connection has too many active requests');
+    }
+    this.activeControllers.add(controller);
+    const abortFromCaller = () => controller.abort(optionsArg.signal?.reason);
+    if (optionsArg.signal?.aborted) abortFromCaller();
+    else optionsArg.signal?.addEventListener('abort', abortFromCaller, { once: true });
+    const timer = setTimeout(
+      () => controller.abort(new Error(`OpenCode request timed out after ${optionsArg.timeoutMs}ms`)),
+      optionsArg.timeoutMs,
+    );
+    try {
+      const response = await fetch(url, {
+        method: optionsArg.method ?? 'GET',
+        headers: {
+          ...this.authHeaders(),
+          accept: 'application/json',
+          ...(optionsArg.body === undefined ? {} : { 'content-type': 'application/json' }),
+        },
+        body: optionsArg.body === undefined ? undefined : JSON.stringify(optionsArg.body),
+        redirect: 'error',
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        const responseText = await this.readResponseText(response, 64 * 1024).catch(
+          () => '[response body unavailable or too large]',
+        );
+        const redactedResponseText = this.redactCredentials(responseText);
+        throw new Error(
+          `OpenCode server returned HTTP ${response.status}${redactedResponseText ? `: ${redactedResponseText.slice(0, 2000)}` : ''}`,
+        );
+      }
+      const responseText = await this.readResponseText(response, 16 * 1024 * 1024);
+      const payload = helpers.parseJson(responseText);
+      if (payload === undefined) {
+        throw new Error('OpenCode server returned invalid JSON');
+      }
+      return payload;
+    } finally {
+      clearTimeout(timer);
+      optionsArg.signal?.removeEventListener('abort', abortFromCaller);
+      this.activeControllers.delete(controller);
+    }
+  }
+
+  private async readResponseText(responseArg: Response, maxBytesArg: number): Promise<string> {
+    const contentLength = Number(responseArg.headers.get('content-length'));
+    if (Number.isFinite(contentLength) && contentLength > maxBytesArg) {
+      await responseArg.body?.cancel().catch(() => {});
+      throw new Error(`OpenCode response exceeds ${maxBytesArg} bytes`);
+    }
+    if (!responseArg.body) return '';
+    const reader = responseArg.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = '';
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        bytes += value.byteLength;
+        if (bytes > maxBytesArg) {
+          await reader.cancel().catch(() => {});
+          throw new Error(`OpenCode response exceeds ${maxBytesArg} bytes`);
+        }
+        text += decoder.decode(value, { stream: true });
+      }
+      return text + decoder.decode();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private authHeaders(): Record<string, string> {
+    const password = this.credentials?.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+    if (!password) {
+      throw new Error('OPENCODE_SERVER_PASSWORD is required for OpenCode connections');
+    }
+    const username = this.credentials
+      ? (this.credentials.username ?? 'opencode')
+      : (process.env.OPENCODE_SERVER_USERNAME ?? 'opencode');
+    return {
+      authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
+    };
+  }
+
+  private redactCredentials(valueArg: string): string {
+    const password = this.credentials?.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+    const username = this.credentials
+      ? (this.credentials.username ?? 'opencode')
+      : (process.env.OPENCODE_SERVER_USERNAME ?? 'opencode');
+    const authorization = password
+      ? `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
+      : '';
+    let value = valueArg;
+    const secrets = [authorization, password, username]
+      .filter((secret): secret is string => Boolean(secret))
+      .sort((left, right) => right.length - left.length);
+    for (const secret of secrets) {
+      if (secret) value = value.replaceAll(secret, '[redacted]');
+    }
+    return value;
+  }
+
+  private remainingSendMs(deadlineArg: number, timeoutSecondsArg: number): number {
+    const remainingMs = deadlineArg - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(
+        `OpenCode send timed out after ${timeoutSecondsArg}s before dispatch; no message was delivered`,
+      );
+    }
+    return remainingMs;
+  }
+
+  private assertChatId(chatIdArg: string): void {
+    if (!chatIdArg || chatIdArg.length > 1024) {
+      throw new Error('OpenCode chatId must contain 1-1024 characters');
+    }
+  }
+}