agents-city 0.3.0-beta.21

package/plugin/channel/runtime/command.ts

@@ -0,0 +1,62 @@
+import { basename } from 'path';
+import { NativeRuntime } from './types.js';
+
+export function commandWords(command: string): string[] {
+  const words: string[] = [];
+  let current = '';
+  let quote = '';
+  let escaped = false;
+  for (const character of command.trim()) {
+    if (escaped) {
+      current += character;
+      escaped = false;
+    } else if (character === '\\' && quote !== "'") {
+      escaped = true;
+    } else if (quote) {
+      if (character === quote) quote = '';
+      else current += character;
+    } else if (character === "'" || character === '"') {
+      quote = character;
+    } else if (/\s/.test(character)) {
+      if (current) words.push(current);
+      current = '';
+    } else {
+      current += character;
+    }
+  }
+  if (escaped) current += '\\';
+  if (quote) throw new Error('runtime command has an unterminated quote');
+  if (current) words.push(current);
+  return words;
+}
+
+export function runtimeFor(command: string): NativeRuntime | 'claude' | 'unknown' {
+  const executable = basename(commandWords(command)[0] || '').toLowerCase();
+  if (executable === 'claude' || executable === 'claude-code') return 'claude';
+  if (executable === 'codex') return 'codex';
+  if (executable === 'opencode') return 'opencode';
+  if (executable === 'kimi' || executable === 'kimi-code') return 'kimi';
+  return 'unknown';
+}
+
+export function executableFor(command: string, fallback: string): string {
+  return commandWords(command)[0] || fallback;
+}
+
+export function optionValue(command: string, names: string[]): string {
+  const words = commandWords(command);
+  for (let index = 1; index < words.length; index += 1) {
+    const word = words[index];
+    if (names.includes(word)) return words[index + 1] || '';
+    for (const name of names) {
+      if (word.startsWith(`${name}=`)) return word.slice(name.length + 1);
+    }
+  }
+  return '';
+}
+
+export function hasOption(command: string, names: string[]): boolean {
+  return commandWords(command).some(
+    (word) => names.includes(word) || names.some((name) => word.startsWith(`${name}=`)),
+  );
+}

package/plugin/channel/runtime/factory.ts

@@ -0,0 +1,15 @@
+import { ClaudeConnector } from './claude.js';
+import { CodexConnector } from './codex.js';
+import { KimiConnector } from './kimi.js';
+import { OpenCodeConnector } from './opencode.js';
+import { ConnectorOptions, NativeRuntime, RuntimeConnector } from './types.js';
+
+export function createConnector(
+  runtime: NativeRuntime,
+  options: ConnectorOptions,
+): RuntimeConnector {
+  if (runtime === 'claude') return new ClaudeConnector(options);
+  if (runtime === 'codex') return new CodexConnector(options);
+  if (runtime === 'opencode') return new OpenCodeConnector(options);
+  return new KimiConnector(options);
+}

package/plugin/channel/runtime/json-rpc.ts

@@ -0,0 +1,154 @@
+import WebSocket from 'ws';
+import { randomId } from '../protocol.js';
+import { wait } from './process.js';
+
+type JsonObject = Record<string, unknown>;
+
+export class WebSocketJsonRpc {
+  private readonly pending = new Map<
+    string,
+    { resolve: (value: unknown) => void; reject: (error: Error) => void; timer: NodeJS.Timeout }
+  >();
+  private closed = false;
+
+  private constructor(
+    private readonly socket: WebSocket,
+    private readonly onNotification: (method: string, params: JsonObject) => void,
+    private readonly onRequest?: (method: string, params: JsonObject) => Promise<unknown>,
+  ) {
+    socket.on('message', (raw) => void this.receive(String(raw)));
+    socket.on('close', () => this.failAll(new Error('native WebSocket closed')));
+    socket.on('error', () => {});
+  }
+
+  static async connect(
+    url: string,
+    onNotification: (method: string, params: JsonObject) => void = () => {},
+    onRequest?: (method: string, params: JsonObject) => Promise<unknown>,
+    headers: Record<string, string> = {},
+    timeoutMs = 15_000,
+  ): Promise<WebSocketJsonRpc> {
+    const deadline = Date.now() + timeoutMs;
+    let last = 'not listening';
+    while (Date.now() < deadline) {
+      try {
+        const socket = await open(url, headers);
+        return new WebSocketJsonRpc(socket, onNotification, onRequest);
+      } catch (error) {
+        last = (error as Error).message;
+        await wait(100);
+      }
+    }
+    throw new Error(`native WebSocket did not become ready: ${last}`);
+  }
+
+  request(method: string, params: JsonObject = {}, timeoutMs = 30_000): Promise<unknown> {
+    if (this.closed) return Promise.reject(new Error('native WebSocket is closed'));
+    const id = randomId('rpc');
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.socket.send(JSON.stringify({ jsonrpc: '2.0', id, method, params }), (error) => {
+        if (!error) return;
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        clearTimeout(pending.timer);
+        this.pending.delete(id);
+        pending.reject(error);
+      });
+    });
+  }
+
+  notify(method: string, params: JsonObject = {}): Promise<void> {
+    if (this.closed) return Promise.reject(new Error('native WebSocket is closed'));
+    return new Promise((resolve, reject) => {
+      this.socket.send(JSON.stringify({ jsonrpc: '2.0', method, params }), (error) =>
+        error ? reject(error) : resolve(),
+      );
+    });
+  }
+
+  close(): void {
+    this.closed = true;
+    this.failAll(new Error('native WebSocket stopped'));
+    try {
+      this.socket.close();
+    } catch {}
+  }
+
+  private async receive(raw: string): Promise<void> {
+    let message: JsonObject;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const id = message.id === undefined ? '' : String(message.id);
+    if (id && ('result' in message || 'error' in message) && !message.method) {
+      const pending = this.pending.get(id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(id);
+      if (message.error) {
+        const error = message.error as JsonObject;
+        pending.reject(new Error(String(error.message || 'native JSON-RPC request failed')));
+      } else {
+        pending.resolve(message.result);
+      }
+      return;
+    }
+    const method = String(message.method || '');
+    const params = object(message.params);
+    if (!id) {
+      if (method) this.onNotification(method, params);
+      return;
+    }
+    try {
+      if (!this.onRequest) throw new Error(`unsupported native request: ${method}`);
+      const result = await this.onRequest(method, params);
+      this.socket.send(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }));
+    } catch (error) {
+      this.socket.send(
+        JSON.stringify({
+          jsonrpc: '2.0',
+          id: message.id,
+          error: { code: -32601, message: (error as Error).message },
+        }),
+      );
+    }
+  }
+
+  private failAll(error: Error): void {
+    this.closed = true;
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pending.delete(id);
+    }
+  }
+}
+
+function open(url: string, headers: Record<string, string>): Promise<WebSocket> {
+  return new Promise((resolve, reject) => {
+    const socket = new WebSocket(url, { headers });
+    const timer = setTimeout(() => {
+      socket.terminate();
+      reject(new Error('connection timed out'));
+    }, 1_000);
+    socket.once('open', () => {
+      clearTimeout(timer);
+      resolve(socket);
+    });
+    socket.once('error', (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+function object(value: unknown): JsonObject {
+  return value && typeof value === 'object' && !Array.isArray(value) ? (value as JsonObject) : {};
+}

package/plugin/channel/runtime/kimi.ts

@@ -0,0 +1,277 @@
+import { ChildProcess } from 'child_process';
+import WebSocket from 'ws';
+import { BusEnvelope, randomId } from '../protocol.js';
+import { NativeAcceptance } from '../runtime-metrics.js';
+import { executableFor, hasOption, optionValue } from './command.js';
+import { freeLoopbackPort, spawnNative, terminate, wait, waitForHttp } from './process.js';
+import { ConnectorOptions, RuntimeConnector } from './types.js';
+
+export class KimiConnector implements RuntimeConnector {
+  readonly runtime = 'kimi' as const;
+  readonly transport = 'kimi-rest-ws';
+  private child: ChildProcess | null = null;
+  private baseUrl = '';
+  private token = '';
+  private outputBuffer = '';
+  private sessionId = '';
+  private socket: WebSocket | null = null;
+  private turnDone: Promise<void> = Promise.resolve();
+  private finishTurn: (() => void) | null = null;
+  private assistantBuffer = '';
+  private activeSource = '';
+  private activeThread = '';
+
+  constructor(private readonly options: ConnectorOptions) {}
+
+  async start(): Promise<void> {
+    this.baseUrl = (process.env.CITY_KIMI_SERVER_URL || '').replace(/\/$/, '');
+    this.token = process.env.CITY_KIMI_SERVER_TOKEN || '';
+    if (!this.baseUrl) {
+      const port = await freeLoopbackPort();
+      this.baseUrl = `http://127.0.0.1:${port}`;
+      this.child = spawnNative(
+        executableFor(this.options.command, 'kimi'),
+        ['web', '--port', String(port), '--no-open', '--log-level', 'error'],
+        this.options.cwd,
+        process.env,
+        `kimi:${this.options.actor}`,
+        (chunk) => this.output(chunk),
+      );
+      const deadline = Date.now() + 15_000;
+      while (!this.token && Date.now() < deadline) {
+        if (this.child.exitCode !== null) {
+          throw new Error(
+            `Kimi server exited before publishing its bearer token (${this.child.exitCode})`,
+          );
+        }
+        await wait(50);
+      }
+    }
+    if (!this.token) throw new Error('Kimi server bearer token was not available');
+    await waitForHttp(`${this.baseUrl}/api/v1/meta`, this.auth(), this.child);
+    const model = optionValue(this.options.command, ['--model', '-m']);
+    const created = object(
+      await this.json('/api/v1/sessions', {
+        method: 'POST',
+        body: JSON.stringify({
+          title: `Agents City · ${this.options.actor}`,
+          metadata: { cwd: this.options.cwd },
+          agent_config: {
+            ...(model ? { model } : {}),
+            permission_mode: this.permissionMode(),
+            system_prompt:
+              'You are one member of an Agents City committee. Never contact repo peers directly; ' +
+              'submit evidence through the agents-city committee CLI named in each assignment.',
+          },
+        }),
+      }),
+    );
+    this.sessionId = String(object(created.data).id || '');
+    if (!this.sessionId)
+      throw new Error(`Kimi server did not return a session id: ${created.msg || ''}`);
+    await this.startEvents();
+    process.stderr.write(
+      `[city-gateway:${this.options.actor}] Kimi session ${this.sessionId} ready over REST/WebSocket\n`,
+    );
+  }
+
+  async accept(prompt: string, envelope: BusEnvelope): Promise<NativeAcceptance> {
+    if (!this.sessionId) throw new Error('Kimi connector is not ready');
+    await this.turnDone;
+    this.turnDone = new Promise<void>((resolve) => {
+      this.finishTurn = resolve;
+    });
+    this.assistantBuffer = '';
+    this.activeSource = envelope.id;
+    this.activeThread = envelope.thread || envelope.id;
+    const model = optionValue(this.options.command, ['--model', '-m']);
+    const response = object(
+      await this.json(`/api/v1/sessions/${encodeURIComponent(this.sessionId)}/prompts`, {
+        method: 'POST',
+        body: JSON.stringify({
+          content: [{ type: 'text', text: prompt }],
+          prompt_id: envelope.id,
+          permission_mode: this.permissionMode(),
+          ...(model ? { model } : {}),
+        }),
+      }),
+    );
+    if (Number(response.code) !== 0) {
+      this.endTurn();
+      throw new Error(`Kimi rejected the prompt: ${String(response.msg || 'unknown error')}`);
+    }
+    const data = object(response.data);
+    return {
+      acceptedAt: new Date().toISOString(),
+      runtime: this.runtime,
+      transport: this.transport,
+      providerRequestId: String(data.prompt_id || envelope.id),
+    };
+  }
+
+  async close(): Promise<void> {
+    this.endTurn();
+    try {
+      this.socket?.close();
+    } catch {}
+    this.socket = null;
+    await terminate(this.child);
+    this.child = null;
+  }
+
+  private permissionMode(): 'auto' | 'yolo' | 'manual' {
+    if (hasOption(this.options.command, ['--auto'])) return 'auto';
+    if (this.options.autoApprove || hasOption(this.options.command, ['--yolo', '-y']))
+      return 'yolo';
+    return 'manual';
+  }
+
+  private auth(): Record<string, string> {
+    return { authorization: `Bearer ${this.token}` };
+  }
+
+  private async json(path: string, init: RequestInit): Promise<unknown> {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...init,
+      headers: { ...this.auth(), 'content-type': 'application/json', ...(init.headers || {}) },
+      signal: AbortSignal.timeout(30_000),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+      throw new Error(`Kimi API ${path} failed (HTTP ${response.status}): ${body.slice(0, 400)}`);
+    }
+    try {
+      return JSON.parse(body);
+    } catch {
+      throw new Error(`Kimi API ${path} returned invalid JSON`);
+    }
+  }
+
+  private async startEvents(): Promise<void> {
+    const url = new URL(this.baseUrl);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    url.pathname = '/api/v1/ws';
+    url.search = '';
+    const socket = new WebSocket(url, { headers: this.auth() });
+    this.socket = socket;
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Kimi event WebSocket timed out')), 5_000);
+      socket.once('open', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      socket.once('error', (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+    const helloId = randomId('hello');
+    const acknowledged = new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Kimi event subscription timed out')), 5_000);
+      socket.on('message', (raw) => {
+        let message: Record<string, unknown>;
+        try {
+          message = JSON.parse(String(raw));
+        } catch {
+          return;
+        }
+        if (message.type === 'ack' && message.id === helloId) {
+          clearTimeout(timer);
+          if (Number(message.code) === 0) resolve();
+          else reject(new Error(`Kimi event subscription failed: ${String(message.msg || '')}`));
+          return;
+        }
+        this.event(message);
+      });
+    });
+    socket.send(
+      JSON.stringify({
+        type: 'client_hello',
+        id: helloId,
+        payload: {
+          client_id: `agents-city-${this.options.actor}`,
+          subscriptions: [this.sessionId],
+        },
+      }),
+    );
+    await acknowledged;
+  }
+
+  private event(message: Record<string, unknown>): void {
+    if (message.type === 'ping') {
+      this.socket?.send(
+        JSON.stringify({ type: 'pong', id: String(message.id || randomId('pong')), payload: {} }),
+      );
+      return;
+    }
+    if (message.session_id && message.session_id !== this.sessionId) return;
+    const payload = object(message.payload);
+    const type = String(payload.type || message.type || '');
+    if (type === 'assistant.delta') {
+      const delta = String(payload.delta || '');
+      this.assistantBuffer += delta;
+      process.stdout.write(delta);
+    } else if (type === 'turn.ended') {
+      process.stdout.write('\n');
+      if (payload.reason && payload.reason !== 'completed') {
+        process.stderr.write(
+          `[kimi:${this.options.actor}] turn ended as ${String(payload.reason)} ` +
+            `${JSON.stringify(payload.error || '')}\n`,
+        );
+      }
+      const summary = this.assistantBuffer.trim().slice(0, 4_000);
+      if (summary) {
+        this.options.onActivity?.({
+          sourceId: `kimi:${this.sessionId}:${this.activeSource || String(payload.turnId || 'turn')}:answer`,
+          kind: 'conversation.agent',
+          thread: this.activeThread || this.sessionId,
+          phase: 'answered',
+          tone: payload.reason && payload.reason !== 'completed' ? 'error' : 'evidence',
+          title: `${this.options.actor} answered`,
+          summary,
+        });
+      } else if (payload.reason && payload.reason !== 'completed') {
+        this.options.onActivity?.({
+          sourceId: `kimi:${this.sessionId}:${this.activeSource || String(payload.turnId || 'turn')}:error`,
+          kind: 'runtime.turn.failed',
+          thread: this.activeThread || this.sessionId,
+          phase: 'failed',
+          tone: 'error',
+          title: `${this.options.actor} runtime failed`,
+          summary: `Kimi ended the turn as ${String(payload.reason)}.`,
+        });
+      }
+      this.endTurn();
+    }
+  }
+
+  private output(chunk: string): void {
+    this.outputBuffer += chunk;
+    let newline = this.outputBuffer.indexOf('\n');
+    while (newline >= 0) {
+      const line = this.outputBuffer.slice(0, newline);
+      this.outputBuffer = this.outputBuffer.slice(newline + 1);
+      const token = line.match(/#token=([^\s]+)/)?.[1] || '';
+      if (token) this.token = token;
+      process.stderr.write(
+        `[kimi:${this.options.actor}] ${line.replace(/#token=[^\s]+/, '#token=[redacted]')}\n`,
+      );
+      newline = this.outputBuffer.indexOf('\n');
+    }
+  }
+
+  private endTurn(): void {
+    this.assistantBuffer = '';
+    this.activeSource = '';
+    this.activeThread = '';
+    const finish = this.finishTurn;
+    this.finishTurn = null;
+    finish?.();
+  }
+}
+
+function object(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}