@mitsein-ai/cli 0.1.0

package/src/core/openapi.ts

@@ -0,0 +1,182 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { ensureConfigDir, getOpenapiCachePath } from './config.js';
+import { CliError, ExitCode } from './errors.js';
+
+export type OpenApiSpec = Record<string, unknown>;
+
+export interface OperationInfo {
+  operation_id: string;
+  tag: string;
+  method: string;
+  path: string;
+  summary: string;
+  parameters: Record<string, unknown>[];
+  request_body: Record<string, unknown> | null;
+}
+
+/** camelCase / PascalCase / snake_case / spaces → kebab-case (Python `_kebab`). */
+export function kebab(s: string): string {
+  let x = s.replace(/([a-z0-9])([A-Z])/g, '$1-$2');
+  x = x.replace(/[_\s/]+/g, '-');
+  x = x.replace(/-+/g, '-');
+  x = x.replace(/^-+|-+$/g, '');
+  return x.toLowerCase();
+}
+
+export class OpenApiIndex {
+  private readonly _spec: OpenApiSpec;
+  private readonly _operations = new Map<string, OperationInfo[]>();
+  private readonly _byId = new Map<string, OperationInfo>();
+
+  constructor(spec: OpenApiSpec) {
+    this._spec = spec;
+    this.parse();
+  }
+
+  private parse(): void {
+    const paths = this._spec.paths;
+    if (paths === null || typeof paths !== 'object' || Array.isArray(paths)) {
+      return;
+    }
+    for (const [path, pathItem] of Object.entries(paths as Record<string, unknown>)) {
+      if (pathItem === null || typeof pathItem !== 'object' || Array.isArray(pathItem)) {
+        continue;
+      }
+      const pi = pathItem as Record<string, unknown>;
+      if ('$ref' in pi && Object.keys(pi).length === 1) {
+        continue;
+      }
+      for (const method of ['get', 'post', 'put', 'patch', 'delete'] as const) {
+        const op = pi[method];
+        if (op === null || typeof op !== 'object' || Array.isArray(op)) {
+          continue;
+        }
+        const o = op as Record<string, unknown>;
+        const opIdRaw = typeof o.operationId === 'string' ? o.operationId : '';
+        const tags = Array.isArray(o.tags) ? o.tags : ['untagged'];
+        const firstTag = typeof tags[0] === 'string' ? tags[0] : 'untagged';
+        const tag = kebab(firstTag);
+        const summary = typeof o.summary === 'string' ? o.summary : '';
+        const parameters = Array.isArray(o.parameters) ? (o.parameters as Record<string, unknown>[]) : [];
+        const requestBody =
+          o.requestBody !== null && typeof o.requestBody === 'object' && !Array.isArray(o.requestBody)
+            ? (o.requestBody as Record<string, unknown>)
+            : null;
+
+        const operation_id = opIdRaw
+          ? kebab(opIdRaw)
+          : `${method}-${kebab(path)}`;
+
+        const info: OperationInfo = {
+          operation_id,
+          tag,
+          method,
+          path,
+          summary,
+          parameters,
+          request_body: requestBody,
+        };
+
+        const list = this._operations.get(tag) ?? [];
+        list.push(info);
+        this._operations.set(tag, list);
+        this._byId.set(operation_id, info);
+      }
+    }
+  }
+
+  get tags(): string[] {
+    return [...this._operations.keys()].sort();
+  }
+
+  operationsForTag(tag: string): OperationInfo[] {
+    return this._operations.get(tag) ?? [];
+  }
+
+  getOperation(operationId: string): OperationInfo | undefined {
+    return this._byId.get(operationId);
+  }
+
+  get allOperations(): OperationInfo[] {
+    return [...this._byId.values()];
+  }
+}
+
+function loadFromFile(path: string): OpenApiSpec {
+  const text = readFileSync(path, 'utf8');
+  try {
+    return JSON.parse(text) as OpenApiSpec;
+  } catch {
+    const trimmed = text.trim();
+    if (trimmed.startsWith('openapi:') || trimmed.startsWith('swagger:')) {
+      throw new CliError(
+        `File ${path} appears to be YAML; install a YAML parser or use JSON.`,
+        ExitCode.USAGE_ERROR
+      );
+    }
+    throw new CliError(`Failed to parse ${path} as JSON`, ExitCode.USAGE_ERROR);
+  }
+}
+
+async function fetchAndCache(endpoint: string, cachePath: string): Promise<OpenApiSpec> {
+  const url = `${endpoint.replace(/\/$/, '')}/openapi.json`;
+  let res: Response;
+  try {
+    res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+  } catch (e) {
+    throw new CliError(`Failed to fetch OpenAPI spec from ${url}: ${e}`, ExitCode.HTTP_ERROR);
+  }
+  if (!res.ok) {
+    throw new CliError(
+      `Failed to fetch OpenAPI spec from ${url}: HTTP ${res.status}`,
+      ExitCode.HTTP_ERROR
+    );
+  }
+  const spec = (await res.json()) as OpenApiSpec;
+  try {
+    ensureConfigDir();
+    writeFileSync(cachePath, `${JSON.stringify(spec, null, 2)}\n`, 'utf8');
+  } catch {
+    /* non-fatal */
+  }
+  return spec;
+}
+
+export interface LoadOpenApiOptions {
+  endpoint?: string | null;
+  refresh?: boolean;
+}
+
+export async function loadOpenApiSpec(options: LoadOpenApiOptions = {}): Promise<OpenApiSpec> {
+  const envPath = process.env.MITSEIN_OPENAPI_PATH;
+  if (envPath) {
+    return loadFromFile(envPath);
+  }
+
+  const cachePath = getOpenapiCachePath();
+  if (!options.refresh && existsSync(cachePath)) {
+    try {
+      return loadFromFile(cachePath);
+    } catch {
+      /* fall through */
+    }
+  }
+
+  if (options.endpoint) {
+    return fetchAndCache(options.endpoint, cachePath);
+  }
+
+  if (existsSync(cachePath)) {
+    return loadFromFile(cachePath);
+  }
+
+  throw new CliError(
+    'No OpenAPI spec available. Run `mitsein dev openapi --refresh` or set MITSEIN_OPENAPI_PATH.',
+    ExitCode.USAGE_ERROR
+  );
+}
+
+export async function buildIndex(options: LoadOpenApiOptions = {}): Promise<OpenApiIndex> {
+  const spec = await loadOpenApiSpec(options);
+  return new OpenApiIndex(spec);
+}

package/src/core/output.ts

@@ -0,0 +1,59 @@
+let jsonMode = false;
+
+export function setJsonMode(enabled: boolean): void {
+  jsonMode = enabled;
+}
+
+export function isJsonMode(): boolean {
+  return jsonMode;
+}
+
+export function isTTY(): boolean {
+  return process.stdout.isTTY === true;
+}
+
+export type HumanFormatter = (data: unknown) => void;
+
+/**
+ * Emit output: JSON if `--json`, otherwise human-readable.
+ * Mirrors Python `emit()` (rich console → stdout lines here).
+ */
+export function emit(data: unknown, humanFormatter?: HumanFormatter): void {
+  if (jsonMode) {
+    process.stdout.write(`${JSON.stringify(data, replacer)}\n`);
+    return;
+  }
+  if (humanFormatter) {
+    humanFormatter(data);
+    return;
+  }
+  if (data !== null && typeof data === 'object' && !Array.isArray(data)) {
+    printDictHuman(data as Record<string, unknown>);
+    return;
+  }
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
+        printDictHuman(item as Record<string, unknown>);
+      } else {
+        process.stdout.write(`${String(item)}\n`);
+      }
+      process.stdout.write('\n');
+    }
+    return;
+  }
+  process.stdout.write(`${data === undefined ? '' : String(data)}\n`);
+}
+
+function replacer(_key: string, value: unknown): unknown {
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  return value;
+}
+
+function printDictHuman(d: Record<string, unknown>): void {
+  for (const [key, value] of Object.entries(d)) {
+    process.stdout.write(`${key}: ${String(value)}\n`);
+  }
+}

package/src/core/sse.ts

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,169 @@
+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;
+}

package/src/index.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import consola from 'consola';
+import { registerAgent } from './commands/agent.js';
+import { registerApi } from './commands/api-auto.js';
+import { registerAuth } from './commands/auth.js';
+import { registerDev } from './commands/dev.js';
+import { registerMessages } from './commands/messages.js';
+import { registerProject } from './commands/project.js';
+import { registerRun } from './commands/run.js';
+import { registerThread } from './commands/thread.js';
+import { runVersion } from './commands/version.js';
+import { CliError } from './core/errors.js';
+import { setJsonMode } from './core/output.js';
+
+interface GlobalOpts {
+  json?: boolean;
+}
+
+const program = new Command();
+
+program
+  .name('mitsein')
+  .description('Mitsein CLI — internal dev tool for agent verification and workflow automation.')
+  .option('--endpoint <url>', 'API endpoint URL')
+  .option('--token <token>', 'Bearer token')
+  .option('--profile <name>', 'Profile name', 'e2e')
+  .option('--real', 'Use real account for dev token', false)
+  .option('--json', 'Output structured JSON', false)
+  .option('--debug', 'Print HTTP request/response details', false)
+  .option('--timeout <sec>', 'HTTP timeout in seconds (0 = no timeout)', '30')
+  .hook('preAction', (_thisCommand, actionCommand) => {
+    const cmd = actionCommand ?? _thisCommand;
+    const g = cmd.optsWithGlobals() as GlobalOpts;
+    setJsonMode(Boolean(g.json));
+  });
+
+program
+  .command('version')
+  .description('Print CLI version')
+  .action(() => {
+    runVersion();
+  });
+
+registerDev(program);
+registerApi(program);
+registerThread(program);
+registerRun(program);
+registerMessages(program);
+registerAgent(program);
+registerProject(program);
+registerAuth(program);
+
+try {
+  await program.parseAsync(process.argv, { from: 'node' });
+} catch (e) {
+  if (e instanceof CliError) {
+    consola.error(`Error: ${e.message}`);
+    if (e.detail != null && e.detail !== '') {
+      consola.error(String(e.detail));
+    }
+    process.exit(e.code);
+  }
+  consola.error(e);
+  process.exit(1);
+}