@mitsein-ai/cli 0.1.0

package/src/commands/thread.ts

@@ -0,0 +1,187 @@
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { resolveCredentials } from '../core/credentials.js';
+import { CliError, ExitCode, handleErrors } from '../core/errors.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { waitForRun } from '../core/waiters.js';
+import { commaSet, httpTimeoutSec, readGlobals } from './command-opts.js';
+
+export function registerThread(program: Command): void {
+  const thread = program.command('thread').description('Thread management and messaging');
+
+  thread
+    .command('list')
+    .description('List threads')
+    .option('--offset <n>', 'Pagination offset', '0')
+    .option('--limit <n>', 'Max results', '20')
+    .action(
+      handleErrors(async function threadListAction(this: Command) {
+        const g = readGlobals(this);
+        setJsonMode(Boolean(g.json));
+        const client = ApiClient.fromOptions({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+          timeoutSec: httpTimeoutSec(g),
+          debug: g.debug,
+        });
+        const offset = Number.parseInt(String(this.opts().offset ?? '0'), 10);
+        const limit = Number.parseInt(String(this.opts().limit ?? '20'), 10);
+        const result = await client.post('/api/thread/list', {
+          offset: Number.isFinite(offset) ? offset : 0,
+          limit: Number.isFinite(limit) ? limit : 20,
+        });
+        emit(result);
+      })
+    );
+
+  thread
+    .command('get <thread_id>')
+    .description('Get thread details')
+    .action(
+      handleErrors(async function threadGetAction(this: Command, threadId: string) {
+        const g = readGlobals(this);
+        setJsonMode(Boolean(g.json));
+        const client = ApiClient.fromOptions({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+          timeoutSec: httpTimeoutSec(g),
+          debug: g.debug,
+        });
+        const result = await client.post('/api/thread/get', { thread_id: threadId });
+        emit(result);
+      })
+    );
+
+  thread
+    .command('create')
+    .description('Create a new thread')
+    .option('--title <title>', 'Thread title', '')
+    .action(
+      handleErrors(async function threadCreateAction(this: Command) {
+        const g = readGlobals(this);
+        const { title } = this.opts() as { title?: string };
+        setJsonMode(Boolean(g.json));
+        const client = ApiClient.fromOptions({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+          timeoutSec: httpTimeoutSec(g),
+          debug: g.debug,
+        });
+        const result = await client.post('/api/thread/create', { title: title ?? '' });
+        emit(result);
+      })
+    );
+
+  thread
+    .command('history <thread_id>')
+    .description('Show message history for a thread')
+    .option('--limit <n>', 'Max messages', '50')
+    .action(
+      handleErrors(async function threadHistoryAction(this: Command, threadId: string) {
+        const g = readGlobals(this);
+        const { limit: lim } = this.opts() as { limit?: string };
+        setJsonMode(Boolean(g.json));
+        const client = ApiClient.fromOptions({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+          timeoutSec: httpTimeoutSec(g),
+          debug: g.debug,
+        });
+        const limit = Number.parseInt(String(lim ?? '50'), 10);
+        const result = await client.post('/api/message/list', {
+          thread_id: threadId,
+          limit: Number.isFinite(limit) ? limit : 50,
+        });
+        emit(result);
+      })
+    );
+
+  thread
+    .command('send <thread_id> <message>')
+    .description('Send a message and start an agent run')
+    .option('--wait', 'Block until run completes', false)
+    .option('--stream', 'Stream run events', false)
+    .option('--cancel-on-interrupt', 'Cancel run on Ctrl-C (reserved)', false)
+    .option('--filter <types>', 'Comma-separated SSE event types')
+    .option('--agent <name>', 'Agent name (reserved)', '')
+    .option('--model <name>', 'Model override')
+    .option('--timeout <sec>', 'Wait/stream timeout (0 = no limit)', '120')
+    .action(
+      handleErrors(async function threadSendAction(this: Command, threadId: string, message: string) {
+        const g = readGlobals(this);
+        const opts = this.opts() as {
+          wait?: boolean;
+          stream?: boolean;
+          filter?: string;
+          model?: string;
+          timeout?: string;
+        };
+        setJsonMode(Boolean(g.json));
+
+        if (opts.wait && opts.stream) {
+          throw new CliError('--wait and --stream are mutually exclusive', ExitCode.USAGE_ERROR);
+        }
+
+        const creds = resolveCredentials({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+        });
+        const client = new ApiClient(creds, {
+          debug: g.debug,
+          timeoutSec: httpTimeoutSec(g),
+        });
+
+        const addResult = await client.post('/api/message/add', {
+          thread_id: threadId,
+          content: message,
+        });
+
+        const startData: Record<string, string> = {};
+        if (opts.model) {
+          startData.model_name = opts.model;
+        }
+        const startResult = (await client.postForm(`/api/thread/${threadId}/agent/start`, startData)) as {
+          agent_run_id?: string;
+        };
+        const agentRunId = startResult.agent_run_id ?? '';
+
+        if (!opts.wait && !opts.stream) {
+          emit({
+            message: addResult,
+            agent_run_id: agentRunId,
+            status: 'started',
+          });
+          return;
+        }
+
+        const rawT = opts.timeout ?? '120';
+        const tNum = Number.parseFloat(rawT);
+        const effectiveTimeout = Number.isFinite(tNum) && tNum === 0 ? null : Number.isFinite(tNum) ? tNum : 120;
+
+        const result = await waitForRun({
+          endpoint: creds.endpoint,
+          token: creds.token,
+          agent_run_id: agentRunId,
+          timeout: effectiveTimeout ?? undefined,
+          stream_output: Boolean(opts.stream),
+          json_mode: Boolean(g.json),
+          debug: g.debug,
+          event_filter: commaSet(opts.filter),
+        });
+
+        if (opts.wait && !opts.stream) {
+          emit(result);
+        }
+      })
+    );
+}

package/src/commands/version.ts

@@ -0,0 +1,17 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { emit } from '../core/output.js';
+
+export function getPackageVersion(): string {
+  const pkgPath = join(import.meta.dir, '..', '..', 'package.json');
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version?: string };
+    return pkg.version ?? '0.1.0-dev';
+  } catch {
+    return '0.1.0-dev';
+  }
+}
+
+export function runVersion(): void {
+  emit(getPackageVersion());
+}

package/src/core/client.ts

@@ -0,0 +1,201 @@
+import { type $Fetch, FetchError, ofetch } from 'ofetch';
+import type { Credentials } from './credentials.js';
+import { resolveCredentials, type ResolveCredentialsOptions } from './credentials.js';
+import { HttpError } from './errors.js';
+
+export interface ApiClientOptions {
+  timeoutSec?: number | undefined;
+  debug?: boolean | undefined;
+  /** Injected `$fetch` instance (tests). */
+  fetcher?: $Fetch | undefined;
+}
+
+function normalizeBase(endpoint: string): string {
+  return endpoint.replace(/\/$/, '');
+}
+
+function logDebug(debug: boolean, message: string): void {
+  if (debug) {
+    process.stderr.write(`[debug] ${message}\n`);
+  }
+}
+
+function parseErrorBody(body: unknown): { message: string; detail: unknown } {
+  let message = 'HTTP error';
+  let detail: unknown;
+  if (body !== null && typeof body === 'object' && !Array.isArray(body)) {
+    const o = body as Record<string, unknown>;
+    message = typeof o.message === 'string' ? o.message : message;
+    detail = o.detail ?? o.error;
+  }
+  return { message, detail };
+}
+
+async function handleFetch<T>(p: Promise<T>): Promise<T> {
+  try {
+    return await p;
+  } catch (e) {
+    if (e instanceof FetchError) {
+      const status = e.statusCode ?? e.status ?? 0;
+      const { message, detail } = parseErrorBody(e.data);
+      throw new HttpError(status || 599, message, detail);
+    }
+    throw e;
+  }
+}
+
+export class ApiClient {
+  private readonly timeoutMs: number | undefined;
+  private readonly debug: boolean;
+  private readonly fetchImpl: $Fetch;
+  private readonly baseUrl: string;
+  private readonly bearerToken: string;
+
+  constructor(credentials: Credentials, options: ApiClientOptions = {}) {
+    this.debug = options.debug ?? false;
+    this.timeoutMs =
+      options.timeoutSec === undefined || options.timeoutSec === 0
+        ? undefined
+        : options.timeoutSec * 1000;
+    this.baseUrl = normalizeBase(credentials.endpoint);
+    this.bearerToken = credentials.token;
+
+    const dbg = this.debug;
+    this.fetchImpl =
+      options.fetcher ??
+      ofetch.create({
+        baseURL: this.baseUrl,
+        timeout: this.timeoutMs,
+        headers: {
+          Authorization: `Bearer ${credentials.token}`,
+          'Content-Type': 'application/json',
+        },
+        retry: 0,
+        onRequest({ request }) {
+          logDebug(dbg, `${request.method} ${request.url}`);
+        },
+        onResponse({ response }) {
+          logDebug(
+            dbg,
+            `→ ${response.status} (${response.headers.get('content-length') ?? '?'} bytes)`
+          );
+        },
+      });
+  }
+
+  static fromOptions(opts: ResolveCredentialsOptions & ApiClientOptions): ApiClient {
+    const { timeoutSec, debug, fetcher, ...credOpts } = opts;
+    const credentials = resolveCredentials(credOpts);
+    return new ApiClient(credentials, { timeoutSec, debug, fetcher });
+  }
+
+  async get(path: string, query?: Record<string, unknown> | null): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    return handleFetch(this.fetchImpl(p, { method: 'GET', query: query ?? undefined }));
+  }
+
+  async post(path: string, jsonBody?: unknown | null): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    if (this.debug && jsonBody !== undefined && jsonBody !== null) {
+      logDebug(this.debug, `body: ${JSON.stringify(jsonBody)}`);
+    }
+    return handleFetch(
+      this.fetchImpl(p, {
+        method: 'POST',
+        body: jsonBody === undefined || jsonBody === null ? undefined : (jsonBody as object),
+      })
+    );
+  }
+
+  async postForm(path: string, data?: Record<string, unknown> | null): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    const payload: Record<string, string> = {};
+    for (const [k, v] of Object.entries(data ?? {})) {
+      if (v !== undefined && v !== null) {
+        payload[k] = String(v);
+      }
+    }
+    if (this.debug) {
+      logDebug(this.debug, `POST ${p}`);
+      logDebug(this.debug, `form: ${JSON.stringify(payload)}`);
+    }
+    const url = `${this.baseUrl}${p}`;
+    const body = new URLSearchParams(payload);
+    const controller = new AbortController();
+    const ms = this.timeoutMs;
+    const timer =
+      ms === undefined ? null : setTimeout(() => controller.abort(), ms);
+    try {
+      const r = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.bearerToken}`,
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body,
+        signal: controller.signal,
+      });
+      logDebug(this.debug, `→ ${r.status} (${r.headers.get('content-length') ?? '?'} bytes)`);
+      if (r.ok) {
+        const ct = r.headers.get('content-type') ?? '';
+        if (ct.includes('application/json')) {
+          return r.json();
+        }
+        return r.text();
+      }
+      let message = `HTTP ${r.status}`;
+      let detail: unknown;
+      try {
+        const j = (await r.json()) as Record<string, unknown>;
+        message = typeof j.message === 'string' ? j.message : message;
+        detail = j.detail ?? j.error;
+      } catch {
+        /* ignore */
+      }
+      throw new HttpError(r.status, message, detail);
+    } catch (e) {
+      if (e instanceof HttpError) {
+        throw e;
+      }
+      if (e instanceof Error && e.name === 'AbortError') {
+        throw new HttpError(599, 'Request aborted or timed out');
+      }
+      throw e;
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
+
+  async patch(path: string, jsonBody?: unknown | null): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    if (this.debug && jsonBody !== undefined && jsonBody !== null) {
+      logDebug(this.debug, `body: ${JSON.stringify(jsonBody)}`);
+    }
+    return handleFetch(
+      this.fetchImpl(p, {
+        method: 'PATCH',
+        body: jsonBody === undefined || jsonBody === null ? undefined : (jsonBody as object),
+      })
+    );
+  }
+
+  async put(path: string, jsonBody?: unknown | null): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    if (this.debug && jsonBody !== undefined && jsonBody !== null) {
+      logDebug(this.debug, `body: ${JSON.stringify(jsonBody)}`);
+    }
+    return handleFetch(
+      this.fetchImpl(p, {
+        method: 'PUT',
+        body: jsonBody === undefined || jsonBody === null ? undefined : (jsonBody as object),
+      })
+    );
+  }
+
+  async delete(path: string): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    return handleFetch(this.fetchImpl(p, { method: 'DELETE' }));
+  }
+}

package/src/core/config.ts

@@ -0,0 +1,26 @@
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/** Default API base URL (matches Python `DEFAULT_ENDPOINT`). */
+export const DEFAULT_ENDPOINT = 'http://localhost:8000';
+
+/** Default OAuth / profile name. */
+export const DEFAULT_PROFILE = 'e2e';
+
+/** Base config directory: `~/.mitsein`. */
+export const CONFIG_DIR = join(homedir(), '.mitsein');
+
+/** Create `~/.mitsein/` if missing (`0o700`). */
+export function ensureConfigDir(): string {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  return CONFIG_DIR;
+}
+
+export function getOauthPath(profile: string = DEFAULT_PROFILE): string {
+  return join(CONFIG_DIR, 'oauth', `${profile}.json`);
+}
+
+export function getOpenapiCachePath(): string {
+  return join(CONFIG_DIR, 'openapi.json');
+}

package/src/core/credentials.ts

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_ENDPOINT, getOauthPath } from './config.js';
+import { NoCredentialsError } from './errors.js';
+
+export interface Credentials {
+  token: string;
+  endpoint: string;
+}
+
+export interface ResolveCredentialsOptions {
+  token?: string | undefined;
+  endpoint?: string | undefined;
+  profile?: string | undefined;
+  real?: boolean | undefined;
+  projectRoot?: string | undefined;
+  /** Injected for tests (Bun.spawnSync). */
+  spawnDevToken?: typeof runDevTokenScript;
+}
+
+function parseUrlHost(endpoint: string): string {
+  try {
+    return new URL(endpoint).hostname;
+  } catch {
+    return '';
+  }
+}
+
+function isLocalhost(endpoint: string): boolean {
+  const host = parseUrlHost(endpoint);
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0';
+}
+
+function findDevTokenScript(projectRoot: string | undefined): string | null {
+  const roots: string[] = [];
+  if (projectRoot) {
+    roots.push(projectRoot);
+  }
+  roots.push(process.cwd());
+
+  for (const root of roots) {
+    let current = root;
+    for (let depth = 0; depth < 10; depth++) {
+      const candidate = join(current, 'scripts', 'dev-token.sh');
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+      const parent = join(current, '..');
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  return null;
+}
+
+function runDevTokenScript(scriptPath: string, real: boolean): { ok: boolean; stdout: string } {
+  const args = [scriptPath, '--raw'];
+  if (real) {
+    args.push('--real');
+  }
+  const proc = Bun.spawnSync(['bash', ...args], {
+    timeout: 10_000,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+  const stdout = proc.stdout.toString().trim();
+  return { ok: proc.success && stdout.length > 0, stdout };
+}
+
+function loadExplicit(token: string | undefined, endpoint: string | undefined): Credentials | null {
+  if (token) {
+    return { token, endpoint: endpoint ?? DEFAULT_ENDPOINT };
+  }
+  return null;
+}
+
+function loadEnv(): Credentials | null {
+  const token = process.env.MITSEIN_TOKEN;
+  if (token) {
+    return {
+      token,
+      endpoint: process.env.MITSEIN_API_URL ?? DEFAULT_ENDPOINT,
+    };
+  }
+  return null;
+}
+
+function loadOAuth(profile: string, endpointOverride: string | undefined): Credentials | null {
+  const oauthPath = getOauthPath(profile);
+  if (!existsSync(oauthPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(oauthPath, 'utf8');
+    const data = JSON.parse(raw) as { access_token?: string; endpoint?: string };
+    const token = data.access_token;
+    if (token) {
+      return {
+        token,
+        endpoint: endpointOverride ?? data.endpoint ?? DEFAULT_ENDPOINT,
+      };
+    }
+  } catch {
+    /* ignore malformed oauth file */
+  }
+  return null;
+}
+
+function loadDevToken(
+  endpoint: string | undefined,
+  real: boolean,
+  projectRoot: string | undefined,
+  spawnDevToken: typeof runDevTokenScript
+): Credentials | null {
+  const resolvedEndpoint = endpoint ?? DEFAULT_ENDPOINT;
+  if (!isLocalhost(resolvedEndpoint)) {
+    return null;
+  }
+  const script = findDevTokenScript(projectRoot);
+  if (!script) {
+    return null;
+  }
+  try {
+    const { ok, stdout } = spawnDevToken(script, real);
+    if (ok) {
+      return { token: stdout, endpoint: resolvedEndpoint };
+    }
+  } catch {
+    /* timeout / missing bash */
+  }
+  return null;
+}
+
+/**
+ * Credential provider chain (Python `resolve_credentials`):
+ * 1. Explicit --token / --endpoint
+ * 2. MITSEIN_TOKEN / MITSEIN_API_URL
+ * 3. ~/.mitsein/oauth/<profile>.json
+ * 4. scripts/dev-token.sh (localhost only)
+ */
+export function resolveCredentials(options: ResolveCredentialsOptions = {}): Credentials {
+  const profile = options.profile ?? 'e2e';
+  const spawnFn = options.spawnDevToken ?? runDevTokenScript;
+
+  const explicit = loadExplicit(options.token, options.endpoint);
+  if (explicit) {
+    return explicit;
+  }
+
+  const fromEnv = loadEnv();
+  if (fromEnv) {
+    return fromEnv;
+  }
+
+  const fromOAuth = loadOAuth(profile, options.endpoint);
+  if (fromOAuth) {
+    return fromOAuth;
+  }
+
+  const fromDev = loadDevToken(
+    options.endpoint,
+    options.real ?? false,
+    options.projectRoot,
+    spawnFn
+  );
+  if (fromDev) {
+    return fromDev;
+  }
+
+  throw new NoCredentialsError();
+}

package/src/core/errors.ts

@@ -0,0 +1,76 @@
+import type { Command } from 'commander';
+import consola from 'consola';
+
+/** Standard CLI exit codes (Python `ExitCode`). */
+export enum ExitCode {
+  SUCCESS = 0,
+  BUSINESS_ERROR = 1,
+  USAGE_ERROR = 2,
+  HTTP_ERROR = 3,
+  TIMEOUT = 124,
+}
+
+export type ErrorDetail = unknown;
+
+/** Structured CLI error with exit code. */
+export class CliError extends Error {
+  readonly code: ExitCode;
+  readonly detail: ErrorDetail;
+
+  constructor(message: string, code: ExitCode = ExitCode.BUSINESS_ERROR, detail?: ErrorDetail) {
+    super(message);
+    this.name = 'CliError';
+    this.code = code;
+    this.detail = detail;
+  }
+}
+
+/** No credentials matched the provider chain. */
+export class NoCredentialsError extends CliError {
+  constructor(
+    message = 'No credentials found. Set MITSEIN_TOKEN, pass --token, or run from a dev environment with scripts/dev-token.sh.'
+  ) {
+    super(message, ExitCode.USAGE_ERROR);
+    this.name = 'NoCredentialsError';
+  }
+}
+
+/** HTTP request failed with a non-success status. */
+export class HttpError extends CliError {
+  readonly statusCode: number;
+
+  constructor(statusCode: number, message: string, detail?: ErrorDetail) {
+    const code =
+      statusCode >= 400 && statusCode < 500 ? ExitCode.BUSINESS_ERROR : ExitCode.HTTP_ERROR;
+    super(message, code, detail);
+    this.name = 'HttpError';
+    this.statusCode = statusCode;
+  }
+}
+
+/**
+ * Wrap a Commander action: catch `CliError`, print, `process.exit(code)`;
+ * `KeyboardInterrupt` equivalent → exit 130.
+ */
+export function handleErrors<T extends unknown[]>(
+  fn: (this: Command, ...args: T) => void | Promise<void>
+): (this: Command, ...args: T) => Promise<void> {
+  return async function handleErrorsWrapped(this: Command, ...args: T): Promise<void> {
+    try {
+      await Promise.resolve(fn.apply(this, args));
+    } 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);
+      }
+      if (e !== null && typeof e === 'object' && (e as Error).name === 'AbortError') {
+        process.stderr.write('\nInterrupted.\n');
+        process.exit(130);
+      }
+      throw e;
+    }
+  };
+}