@mitsein-ai/cli 0.1.0

package/src/commands/agent.ts

@@ -0,0 +1,91 @@
+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 registerAgent(program: Command): void {
+  const agent = program.command('agent').description('Agent operations');
+
+  agent
+    .command('invoke <thread_id> <prompt>')
+    .description('Send a message, start the agent, optional wait/stream')
+    .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('--model <name>', 'Model override')
+    .option('--timeout <sec>', 'Wait/stream timeout (0 = no limit)', '120')
+    .action(
+      handleErrors(async function agentInvokeAction(this: Command, threadId: string, prompt: 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: prompt,
+        });
+
+        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/api-auto.ts

@@ -0,0 +1,245 @@
+import { readFileSync } from 'node:fs';
+import type { Command } from 'commander';
+import consola from 'consola';
+import { ApiClient } from '../core/client.js';
+import { CliError, ExitCode, handleErrors } from '../core/errors.js';
+import { buildIndex, type OperationInfo } from '../core/openapi.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { readGlobals } from './command-opts.js';
+
+function parseExtraArgs(args: string[]): Record<string, string> {
+  const params: Record<string, string> = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === undefined) {
+      break;
+    }
+    if (arg.startsWith('--')) {
+      const key = arg.replace(/^-+/, '');
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        params[key] = next;
+        i += 2;
+      } else {
+        params[key] = 'true';
+        i += 1;
+      }
+    } else {
+      i += 1;
+    }
+  }
+  return params;
+}
+
+function resolveBody(body: string | undefined, bodyStdin: boolean): unknown | undefined {
+  if (bodyStdin) {
+    const raw = readFileSync(0, 'utf8');
+    try {
+      return JSON.parse(raw) as unknown;
+    } catch (e) {
+      throw new CliError(`Invalid JSON from stdin: ${e}`, ExitCode.USAGE_ERROR);
+    }
+  }
+  if (body === undefined) {
+    return undefined;
+  }
+  if (body.startsWith('@')) {
+    const filePath = body.slice(1);
+    try {
+      const text = readFileSync(filePath, 'utf8');
+      return JSON.parse(text) as unknown;
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
+        throw new CliError(`File not found: ${filePath}`, ExitCode.USAGE_ERROR);
+      }
+      throw new CliError(`Invalid JSON in ${filePath}: ${e}`, ExitCode.USAGE_ERROR);
+    }
+  }
+  try {
+    return JSON.parse(body) as unknown;
+  } catch (e) {
+    throw new CliError(`Invalid JSON body: ${e}`, ExitCode.USAGE_ERROR);
+  }
+}
+
+async function executeOperation(
+  client: ApiClient,
+  op: OperationInfo,
+  body: unknown | undefined,
+  extraParams: Record<string, string>
+): Promise<unknown> {
+  let path = op.path;
+  const method = op.method;
+  const pathParams = [...path.matchAll(/\{(\w+)\}/g)].map((m) => m[1] ?? '');
+  const queryParams = { ...extraParams };
+  for (const param of pathParams) {
+    if (param in queryParams) {
+      const v = queryParams[param];
+      delete queryParams[param];
+      path = path.replace(`{${param}}`, v ?? '');
+    } else {
+      throw new CliError(`Missing required path parameter: --${param}`, ExitCode.USAGE_ERROR);
+    }
+  }
+
+  if (method === 'get') {
+    const q = Object.keys(queryParams).length > 0 ? { ...queryParams } : undefined;
+    return client.get(path, q as Record<string, unknown> | undefined);
+  }
+  if (method === 'post') {
+    return client.post(path, body);
+  }
+  if (method === 'patch') {
+    return client.patch(path, body);
+  }
+  if (method === 'put') {
+    return client.put(path, body);
+  }
+  if (method === 'delete') {
+    return client.delete(path);
+  }
+  throw new CliError(`Unsupported HTTP method: ${method}`, ExitCode.USAGE_ERROR);
+}
+
+function tagHuman(data: unknown): void {
+  const d = data as { tag?: string; operations?: number };
+  consola.log(`  \x1b[1m${d.tag ?? ''}\x1b[0m (${d.operations ?? 0} operations)`);
+}
+
+function opHuman(data: unknown): void {
+  const d = data as { method?: string; operation?: string; summary?: string };
+  const method = d.method ?? '';
+  const color =
+    method === 'GET'
+      ? '\x1b[32m'
+      : method === 'POST'
+        ? '\x1b[34m'
+        : method === 'PATCH'
+          ? '\x1b[33m'
+          : method === 'DELETE'
+            ? '\x1b[31m'
+            : '\x1b[37m';
+  const op = (d.operation ?? '').padEnd(30);
+  consola.log(`  ${color}${method.padEnd(6)}\x1b[0m ${op} ${d.summary ?? ''}`);
+}
+
+export function registerApi(program: Command): void {
+  const api = program
+    .command('api')
+    .description('Auto-generated API commands from OpenAPI spec');
+
+  api
+    .command('list-tags')
+    .description('List all available API tags')
+    .option('--endpoint <url>', 'API base URL')
+    .action(
+      handleErrors(async function listTagsAction(this: Command) {
+        const g = readGlobals(this);
+        const o = this.opts() as { endpoint?: string };
+        setJsonMode(Boolean(g.json));
+        const index = await buildIndex({ endpoint: o.endpoint ?? g.endpoint });
+        for (const tag of index.tags) {
+          const ops = index.operationsForTag(tag);
+          emit({ tag, operations: ops.length }, tagHuman);
+        }
+      })
+    );
+
+  api
+    .command('list-ops <tag>')
+    .description('List operations for a tag')
+    .option('--endpoint <url>', 'API base URL')
+    .action(
+      handleErrors(async function listOpsAction(this: Command, tag: string) {
+        const g = readGlobals(this);
+        const o = this.opts() as { endpoint?: string };
+        setJsonMode(Boolean(g.json));
+        const index = await buildIndex({ endpoint: o.endpoint ?? g.endpoint });
+        const ops = index.operationsForTag(tag);
+        if (ops.length === 0) {
+          throw new CliError(
+            `Unknown tag '${tag}'. Available: ${index.tags.join(', ')}`,
+            ExitCode.USAGE_ERROR
+          );
+        }
+        for (const op of ops) {
+          emit(
+            { operation: op.operation_id, method: op.method.toUpperCase(), path: op.path, summary: op.summary },
+            opHuman
+          );
+        }
+      })
+    );
+
+  api
+    .command('api-call <tag> <operation>')
+    .description(
+      'Execute an API operation (examples: mitsein api api-call threads list-threads --body \'{"limit":20}\')'
+    )
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .option('--body <json>', 'JSON body: inline or @file.json')
+    .option('--body-stdin', 'Read JSON body from stdin', false)
+    .option('--endpoint <url>', 'API base URL')
+    .option('--token <token>', 'Bearer token')
+    .option('--timeout <sec>', 'HTTP timeout (0 = none)', '30')
+    .option('--debug', 'Print HTTP details', false)
+    .action(
+      handleErrors(async function apiCallAction(this: Command, tag: string, operation: string) {
+        const g = readGlobals(this);
+        const opts = this.opts() as {
+          body?: string;
+          bodyStdin?: boolean;
+          endpoint?: string;
+          token?: string;
+          timeout?: string;
+          debug?: boolean;
+        };
+        setJsonMode(Boolean(g.json));
+
+        const index = await buildIndex({ endpoint: opts.endpoint ?? g.endpoint });
+        const op = index.getOperation(operation);
+        if (op === undefined) {
+          const ops = index.operationsForTag(tag);
+          if (ops.length === 0) {
+            const available =
+              index.tags.length > 0
+                ? index.tags.join(', ')
+                : '(none — run `mitsein dev openapi --refresh`)';
+            throw new CliError(`Unknown tag '${tag}'. Available tags: ${available}`, ExitCode.USAGE_ERROR);
+          }
+          const available = ops.map((o) => o.operation_id).join(', ');
+          throw new CliError(
+            `Unknown operation '${operation}' in tag '${tag}'. Available: ${available}`,
+            ExitCode.USAGE_ERROR
+          );
+        }
+        if (op.tag !== tag) {
+          throw new CliError(
+            `Operation '${operation}' belongs to tag '${op.tag}', not '${tag}'.`,
+            ExitCode.USAGE_ERROR
+          );
+        }
+
+        const requestBody = resolveBody(opts.body, Boolean(opts.bodyStdin));
+        const extra = parseExtraArgs((this.args as string[]).slice(2));
+
+        const rawTimeout = opts.timeout ?? g.timeout ?? '30';
+        const tn = Number.parseFloat(rawTimeout);
+        const effectiveTimeout = Number.isFinite(tn) && tn === 0 ? undefined : Number.isFinite(tn) ? tn : 30;
+
+        const client = ApiClient.fromOptions({
+          token: opts.token ?? g.token,
+          endpoint: opts.endpoint ?? g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+          timeoutSec: effectiveTimeout,
+          debug: Boolean(opts.debug ?? g.debug),
+        });
+
+        const result = await executeOperation(client, op, requestBody, extra);
+        emit(result);
+      })
+    );
+}

package/src/commands/auth-browser.ts

@@ -0,0 +1,126 @@
+import { createServer } from 'node:http';
+import { parse as parseQuery, type ParsedUrlQuery } from 'node:querystring';
+import consola from 'consola';
+import { CliError, ExitCode } from '../core/errors.js';
+import { emit } from '../core/output.js';
+import { LOCALHOST_PORT, openBrowserUrl, saveOAuthCredentials } from './auth-internal.js';
+
+function firstQuery(q: ParsedUrlQuery, key: string): string | undefined {
+  const v = q[key];
+  if (Array.isArray(v)) {
+    return v[0];
+  }
+  return v;
+}
+
+export async function loginBrowserFlow(
+  endpoint: string,
+  provider: string,
+  profile: string,
+  jsonOutput: boolean
+): Promise<void> {
+  const received: Record<string, string | boolean> = {};
+
+  await new Promise<void>((resolve, reject) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer !== undefined) {
+        clearTimeout(timer);
+      }
+      server.close(() => resolve());
+    };
+
+    const server = createServer((req, res) => {
+      const u = req.url ?? '';
+      let pathname = '';
+      try {
+        pathname = new URL(u, 'http://127.0.0.1').pathname;
+      } catch {
+        pathname = '';
+      }
+      if (pathname !== '/callback') {
+        res.writeHead(404);
+        res.end();
+        finish();
+        return;
+      }
+      const q = u.includes('?') ? parseQuery(u.split('?', 2)[1] ?? '') : {};
+      if (q.error) {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        const msg = firstQuery(q, 'error_description') ?? firstQuery(q, 'error') ?? 'Unknown error';
+        res.end(`<html><body><h2>Login failed</h2><p>${String(msg)}</p></body></html>`);
+        received.error = String(msg);
+        finish();
+        return;
+      }
+      if (q.account) {
+        received.account = firstQuery(q, 'account') ?? '';
+      }
+      if (q.email) {
+        received.email = firstQuery(q, 'email') ?? '';
+      }
+      if (q.token) {
+        received.token = firstQuery(q, 'token') ?? '';
+      }
+      if (q.session_id) {
+        received.session_id = firstQuery(q, 'session_id') ?? '';
+      }
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(
+        '<html><body><h2>Login successful!</h2><p>You can close this window.</p></body></html>'
+      );
+      received.success = true;
+      finish();
+    });
+
+    server.once('error', (err) => {
+      if (!settled) {
+        settled = true;
+        if (timer !== undefined) {
+          clearTimeout(timer);
+        }
+        reject(err);
+      }
+    });
+
+    timer = setTimeout(() => finish(), 300_000);
+
+    server.listen(LOCALHOST_PORT, '127.0.0.1', () => {
+      const loginUrl = `${endpoint}/api/auth/cognito/login?provider=${encodeURIComponent(provider)}`;
+      if (!jsonOutput) {
+        consola.log('\nOpening browser for login...');
+        consola.log(`If browser does not open, visit: ${loginUrl}\n`);
+      }
+      openBrowserUrl(loginUrl);
+      if (!jsonOutput) {
+        consola.log('Waiting for browser login...');
+      }
+    });
+  });
+
+  if (received.error !== undefined) {
+    throw new CliError(`Login failed: ${String(received.error)}`, ExitCode.BUSINESS_ERROR);
+  }
+  if (received.success === true) {
+    const result = {
+      access_token: String(received.token ?? ''),
+      user_email: String(received.email ?? ''),
+      user_id: String(received.account ?? ''),
+    };
+    saveOAuthCredentials(profile, endpoint, result);
+    emit(
+      { status: 'logged_in', email: result.user_email, profile },
+      () => {
+        consola.success(`Logged in as ${result.user_email}`);
+      }
+    );
+    return;
+  }
+  throw new CliError('Login timed out. Try again.', ExitCode.TIMEOUT);
+}

package/src/commands/auth-device.ts

@@ -0,0 +1,97 @@
+import consola from 'consola';
+import { CliError, ExitCode } from '../core/errors.js';
+import { emit } from '../core/output.js';
+import { openBrowserUrl, saveOAuthCredentials } from './auth-internal.js';
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+export async function loginDeviceCodeFlow(
+  endpoint: string,
+  profile: string,
+  jsonOutput: boolean
+): Promise<void> {
+  const deviceRes = await fetch(`${endpoint}/api/auth/cli/device`, {
+    method: 'POST',
+    signal: AbortSignal.timeout(10_000),
+  });
+  if (!deviceRes.ok) {
+    throw new CliError(`Failed to create device code: HTTP ${deviceRes.status}`, ExitCode.HTTP_ERROR);
+  }
+  const data = (await deviceRes.json()) as {
+    device_code: string;
+    user_code: string;
+    verification_url: string;
+    expires_in: number;
+    interval?: number;
+  };
+  const {
+    device_code: deviceCodeVal,
+    user_code: userCode,
+    verification_url: verificationUrl,
+    expires_in: expiresIn,
+  } = data;
+  const interval = data.interval ?? 5;
+  const fullUrl = `${verificationUrl}?user_code=${encodeURIComponent(userCode)}`;
+
+  if (!jsonOutput) {
+    consola.log('\nMitsein CLI Login\n');
+    consola.log('Open this URL in your browser:');
+    consola.log(fullUrl);
+    consola.log(`Or go to ${verificationUrl} and enter code:`);
+    consola.log(userCode);
+    consola.log(`Waiting for authorization (expires in ${Math.floor(expiresIn / 60)} min)...`);
+  }
+
+  openBrowserUrl(fullUrl);
+
+  const deadline = Date.now() + expiresIn * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000);
+    try {
+      const pollResp = await fetch(`${endpoint}/api/auth/cli/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ device_code: deviceCodeVal, grant_type: 'device_code' }),
+        signal: AbortSignal.timeout(10_000),
+      });
+      const result = (await pollResp.json()) as {
+        status?: string;
+        user_email?: string;
+        access_token?: string;
+        user_id?: string;
+        expires_in?: number;
+      };
+      const status = result.status;
+
+      if (status === 'authorized') {
+        saveOAuthCredentials(profile, endpoint, result);
+        emit(
+          { status: 'logged_in', email: result.user_email ?? '', profile },
+          () => {
+            consola.success(`\nLogged in as ${result.user_email ?? ''}`);
+          }
+        );
+        return;
+      }
+      if (status === 'expired') {
+        throw new CliError(
+          'Device code expired. Run `mitsein auth login` again.',
+          ExitCode.BUSINESS_ERROR
+        );
+      }
+      if (!jsonOutput) {
+        process.stderr.write('.');
+      }
+    } catch (e) {
+      if (e instanceof CliError) {
+        throw e;
+      }
+      if (!jsonOutput) {
+        consola.log(`\nPoll error: ${e}, retrying...`);
+      }
+    }
+  }
+  throw new CliError('Login timed out. Run `mitsein auth login` again.', ExitCode.TIMEOUT);
+}

package/src/commands/auth-internal.ts

@@ -0,0 +1,49 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { ensureConfigDir, getOauthPath, DEFAULT_ENDPOINT } from '../core/config.js';
+
+export const LOCALHOST_PORT = 19284;
+
+export function saveOAuthCredentials(
+  profile: string,
+  endpoint: string,
+  result: {
+    access_token?: string;
+    user_email?: string;
+    user_id?: string;
+    expires_in?: number;
+  }
+): void {
+  ensureConfigDir();
+  const oauthPath = getOauthPath(profile);
+  mkdirSync(dirname(oauthPath), { recursive: true, mode: 0o700 });
+  const data = {
+    access_token: result.access_token ?? '',
+    user_email: result.user_email ?? '',
+    user_id: result.user_id ?? '',
+    endpoint,
+    created_at: Date.now() / 1000,
+    expires_in: result.expires_in ?? 86400,
+  };
+  writeFileSync(oauthPath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+  chmodSync(oauthPath, 0o600);
+}
+
+export function openBrowserUrl(url: string): void {
+  try {
+    if (process.platform === 'darwin') {
+      execFileSync('open', [url], { stdio: 'ignore' });
+    } else if (process.platform === 'win32') {
+      execFileSync('cmd', ['/c', 'start', '', url], { stdio: 'ignore' });
+    } else {
+      execFileSync('xdg-open', [url], { stdio: 'ignore' });
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+export function normalizeEndpoint(endpoint: string | undefined): string {
+  return (endpoint ?? process.env.MITSEIN_API_URL ?? DEFAULT_ENDPOINT).replace(/\/$/, '');
+}