@mitsein-ai/cli 0.2.1 → 0.3.0

package/src/core/sse.ts

@@ -1,135 +0,0 @@
-import { CliError, ExitCode } from './errors.js';
-
-export interface SseEvent {
-  event_type: string;
-  data: Record<string, unknown> | string;
-  raw: string;
-  timestamp: number;
-}
-
-function normalizeBase(endpoint: string): string {
-  return endpoint.replace(/\/$/, '');
-}
-
-/** Parse one SSE block (`\n\n` delimited). Returns `null` for heartbeats / empty. */
-export function parseSseEvent(text: string, debug = false): SseEvent | null {
-  const lines = text.trim().split('\n');
-  const dataLines: string[] = [];
-
-  for (const line of lines) {
-    if (line.startsWith(':')) {
-      if (debug) {
-        process.stderr.write(`[debug] SSE comment: ${line}\n`);
-      }
-      continue;
-    }
-    if (line.startsWith('data: ')) {
-      dataLines.push(line.slice(6));
-    } else if (line.startsWith('data:')) {
-      dataLines.push(line.slice(5));
-    }
-  }
-
-  if (dataLines.length === 0) {
-    return null;
-  }
-
-  const rawData = dataLines.join('\n');
-  const timestamp = Date.now() / 1000;
-
-  try {
-    const parsed = JSON.parse(rawData) as unknown;
-    const event_type =
-      typeof parsed === 'object' &&
-      parsed !== null &&
-      'type' in parsed &&
-      typeof (parsed as { type: unknown }).type === 'string'
-        ? (parsed as { type: string }).type
-        : 'message';
-    return {
-      event_type,
-      data: parsed as Record<string, unknown>,
-      raw: rawData,
-      timestamp,
-    };
-  } catch {
-    return {
-      event_type: 'unknown',
-      data: rawData,
-      raw: rawData,
-      timestamp,
-    };
-  }
-}
-
-export interface StreamSseOptions {
-  endpoint: string;
-  path: string;
-  token: string;
-  timeoutSec?: number | null;
-  debug?: boolean;
-  signal?: AbortSignal | undefined;
-}
-
-/** SSE client using `fetch` + `ReadableStream`. */
-export async function* streamSse(options: StreamSseOptions): AsyncGenerator<SseEvent> {
-  const url = `${normalizeBase(options.endpoint)}${options.path.startsWith('/') ? options.path : `/${options.path}`}`;
-  if (options.debug) {
-    process.stderr.write(`[debug] SSE connecting to ${url}\n`);
-  }
-
-  const start = Date.now();
-  const timeoutMs =
-    options.timeoutSec === undefined || options.timeoutSec === null || options.timeoutSec === 0
-      ? null
-      : options.timeoutSec * 1000;
-
-  const res = await fetch(url, {
-    headers: {
-      Authorization: `Bearer ${options.token}`,
-      Accept: 'text/event-stream',
-    },
-    signal: options.signal,
-  });
-
-  if (!res.ok) {
-    throw new CliError(`SSE connection failed: HTTP ${res.status}`, ExitCode.HTTP_ERROR);
-  }
-
-  if (options.debug) {
-    process.stderr.write(`[debug] SSE connected (${res.status})\n`);
-  }
-
-  const body = res.body;
-  if (!body) {
-    throw new CliError('SSE response has no body', ExitCode.HTTP_ERROR);
-  }
-
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  try {
-    for (;;) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let sep: number;
-      while ((sep = buffer.indexOf('\n\n')) !== -1) {
-        const block = buffer.slice(0, sep);
-        buffer = buffer.slice(sep + 2);
-        const ev = parseSseEvent(block, options.debug ?? false);
-        if (ev !== null) {
-          yield ev;
-          if (timeoutMs !== null && Date.now() - start > timeoutMs) {
-            throw new CliError('Stream timeout', ExitCode.TIMEOUT);
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}

package/src/core/waiters-output.ts

@@ -1,95 +0,0 @@
-import { isTTY } from './output.js';
-import type { SseEvent } from './sse.js';
-
-function formatLocalTime(tsSec: number): string {
-  const d = new Date(tsSec * 1000);
-  const h = String(d.getHours()).padStart(2, '0');
-  const m = String(d.getMinutes()).padStart(2, '0');
-  const s = String(d.getSeconds()).padStart(2, '0');
-  return `${h}:${m}:${s}`;
-}
-
-function truncateStr(s: string, max: number): string {
-  return s.length > max ? `${s.slice(0, max)}...` : s;
-}
-
-/** Human-readable line for one SSE event (`waiters._print_event_human`). */
-export function printEventHuman(event: SseEvent): void {
-  const data = event.data;
-
-  if (typeof data !== 'object' || data === null) {
-    process.stdout.write(`\x1b[2m${String(data)}\x1b[0m\n`);
-    return;
-  }
-
-  const etype = event.event_type;
-  const content =
-    typeof data.content === 'string' ? data.content : '';
-  const ts = formatLocalTime(event.timestamp);
-
-  if (etype === 'assistant' || etype === 'text' || etype === 'message') {
-    process.stdout.write(
-      `\x1b[2m[${ts}]\x1b[0m \x1b[1massistant:\x1b[0m ${content}\n`
-    );
-  } else if (etype === 'tool_call') {
-    const name =
-      (typeof data.name === 'string' ? data.name : null) ??
-      (typeof data.tool_name === 'string' ? data.tool_name : null) ??
-      '?';
-    let args = data.arguments ?? data.args ?? '';
-    if (typeof args === 'string') {
-      args = truncateStr(args, 80);
-    } else {
-      args = JSON.stringify(args);
-    }
-    process.stdout.write(
-      `\x1b[2m[${ts}]\x1b[0m \x1b[33mtool_call:\x1b[0m  ${name}(${String(args)})\n`
-    );
-  } else if (etype === 'tool_result') {
-    let output = data.output ?? data.result ?? data.content ?? '';
-    if (typeof output === 'string') {
-      output = truncateStr(output, 100);
-    } else {
-      output = JSON.stringify(output);
-    }
-    process.stdout.write(
-      `\x1b[2m[${ts}]\x1b[0m \x1b[32mtool_result:\x1b[0m ${String(output)}\n`
-    );
-  } else if (etype === 'status') {
-    const st = typeof data.status === 'string' ? data.status : '';
-    process.stdout.write(`\x1b[2m[${ts}]\x1b[0m \x1b[34mstatus:\x1b[0m ${st}\n`);
-  } else if (etype === 'error') {
-    process.stdout.write(
-      `\x1b[2m[${ts}]\x1b[0m \x1b[1m\x1b[31merror:\x1b[0m ${content}\n`
-    );
-  } else {
-    const snippet = JSON.stringify(data).slice(0, 120);
-    process.stdout.write(`\x1b[2m[${ts}]\x1b[0m \x1b[2m${etype}:\x1b[0m ${snippet}\n`);
-  }
-}
-
-/** Completion summary after streaming (`waiters._print_summary`). */
-export function printSummary(result: Record<string, unknown>): void {
-  const status = String(result.status ?? '');
-  const durationMs = Number(result.duration_ms ?? 0) / 1000;
-  const eventsCount = result.events_count;
-
-  if (status === 'succeeded') {
-    process.stdout.write(
-      `\n\x1b[1m\x1b[32m✓\x1b[0m run completed in ${durationMs.toFixed(1)}s (${eventsCount} events)\n`
-    );
-  } else if (status === 'failed') {
-    const err = String(result.error ?? '');
-    process.stdout.write(
-      `\n\x1b[1m\x1b[31m✗\x1b[0m run failed in ${durationMs.toFixed(1)}s: ${err}\n`
-    );
-  } else if (status === 'disconnected') {
-    process.stdout.write(
-      `\n\x1b[2mdisconnected after ${durationMs.toFixed(1)}s (${eventsCount} events)\x1b[0m\n`
-    );
-  }
-}
-
-export function shouldPrintStreamSummary(streamOutput: boolean, jsonMode: boolean): boolean {
-  return streamOutput && !jsonMode && isTTY();
-}

package/src/core/waiters.ts

@@ -1,169 +0,0 @@
-import { CliError, ExitCode } from './errors.js';
-import { isJsonMode } from './output.js';
-import {
-  printEventHuman,
-  printSummary,
-  shouldPrintStreamSummary,
-} from './waiters-output.js';
-import { streamSse, type SseEvent } from './sse.js';
-
-export interface WaitForRunOptions {
-  endpoint: string;
-  token: string;
-  agent_run_id: string;
-  timeout?: number | null;
-  stream_output?: boolean;
-  json_mode?: boolean;
-  debug?: boolean;
-  event_filter?: Set<string> | null;
-  on_event?: ((e: SseEvent) => void) | null;
-  /** Test hook: custom event stream instead of `streamSse`. */
-  eventStream?: AsyncIterable<SseEvent> | null;
-}
-
-function outputEvent(
-  event: SseEvent,
-  jsonMode: boolean,
-  eventFilter: Set<string> | null | undefined
-): void {
-  if (eventFilter && !eventFilter.has(event.event_type)) {
-    return;
-  }
-  if (jsonMode) {
-    if (typeof event.data === 'object' && event.data !== null) {
-      const line = { ts: event.timestamp, ...event.data };
-      process.stdout.write(`${JSON.stringify(line)}\n`);
-    } else {
-      process.stdout.write(
-        `${JSON.stringify({ ts: event.timestamp, type: event.event_type, raw: event.data })}\n`
-      );
-    }
-  } else {
-    printEventHuman(event);
-  }
-}
-
-/**
- * Wait for an agent run via SSE (`waiters.wait_for_run`).
- * Exit semantics via `CliError`: failed run → BUSINESS_ERROR; timeout from stream → TIMEOUT.
- */
-export async function waitForRun(options: WaitForRunOptions): Promise<Record<string, unknown>> {
-  const start = Date.now();
-  const events: { type: string; data: unknown }[] = [];
-  let finalStatus = 'unknown';
-  let errorMessage: string | null = null;
-  const assistantTextParts: string[] = [];
-  const toolCalls: Record<string, unknown>[] = [];
-
-  const streamOutput = options.stream_output ?? false;
-  const jsonMode = options.json_mode ?? isJsonMode();
-  const eventFilter = options.event_filter ?? null;
-  const debug = options.debug ?? false;
-
-  const useBuiltinStream = options.eventStream == null;
-  const ac = useBuiltinStream ? new AbortController() : null;
-  const onSigint = (): void => {
-    ac?.abort();
-  };
-  if (useBuiltinStream) {
-    process.once('SIGINT', onSigint);
-  }
-
-  const path = `/api/agent-run/${options.agent_run_id}/stream`;
-  const iterable: AsyncIterable<SseEvent> =
-    options.eventStream ??
-    streamSse({
-      endpoint: options.endpoint,
-      path,
-      token: options.token,
-      timeoutSec: options.timeout ?? undefined,
-      debug,
-      signal: ac?.signal,
-    });
-
-  try {
-    try {
-      for await (const event of iterable) {
-        events.push({ type: event.event_type, data: event.data });
-        options.on_event?.(event);
-        if (streamOutput) {
-          outputEvent(event, jsonMode, eventFilter);
-        }
-        if (typeof event.data === 'object' && event.data !== null) {
-          const d = event.data as Record<string, unknown>;
-          const etype = event.event_type;
-          if (etype === 'status') {
-            const st = typeof d.status === 'string' ? d.status : '';
-            if (st === 'completed') {
-              finalStatus = 'succeeded';
-              break;
-            }
-            if (st === 'failed' || st === 'error') {
-              finalStatus = 'failed';
-              errorMessage =
-                (typeof d.content === 'string' ? d.content : null) ??
-                (typeof d.error === 'string' ? d.error : null) ??
-                null;
-              break;
-            }
-          } else if (etype === 'error') {
-            finalStatus = 'failed';
-            errorMessage =
-              (typeof d.content === 'string' ? d.content : null) ?? String(event.data);
-            break;
-          } else if (etype === 'assistant' || etype === 'text' || etype === 'message') {
-            const c = typeof d.content === 'string' ? d.content : '';
-            if (c) {
-              assistantTextParts.push(c);
-            }
-          } else if (etype === 'tool_call' || etype === 'tool_result') {
-            toolCalls.push(d);
-          }
-        }
-      }
-    } catch (e) {
-      if (e !== null && typeof e === 'object' && (e as Error).name === 'AbortError') {
-        if (!jsonMode) {
-          process.stderr.write(
-            '\n\x1b[2mDisconnected from stream (run continues in background)\x1b[0m\n'
-          );
-        }
-        finalStatus = 'disconnected';
-      } else {
-        throw e;
-      }
-    }
-  } finally {
-    if (useBuiltinStream) {
-      process.off('SIGINT', onSigint);
-    }
-  }
-
-  const duration_ms = Date.now() - start;
-  const result: Record<string, unknown> = {
-    status: finalStatus,
-    agent_run_id: options.agent_run_id,
-    duration_ms,
-    events_count: events.length,
-  };
-
-  if (assistantTextParts.length > 0) {
-    result.assistant_message = assistantTextParts.join('');
-  }
-  if (toolCalls.length > 0) {
-    result.tool_calls = toolCalls;
-  }
-  if (errorMessage) {
-    result.error = errorMessage;
-  }
-
-  if (shouldPrintStreamSummary(streamOutput, jsonMode)) {
-    printSummary(result);
-  }
-
-  if (finalStatus === 'failed') {
-    throw new CliError(`Run failed: ${errorMessage ?? 'unknown error'}`, ExitCode.BUSINESS_ERROR, result);
-  }
-
-  return result;
-}