@mitsein-ai/cli 0.1.0

package/src/commands/auth.ts

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync, unlinkSync } from 'node:fs';
+import type { Command } from 'commander';
+import consola from 'consola';
+import { getOauthPath } from '../core/config.js';
+import { CliError, ExitCode, handleErrors } from '../core/errors.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { loginBrowserFlow } from './auth-browser.js';
+import { loginDeviceCodeFlow } from './auth-device.js';
+import { normalizeEndpoint } from './auth-internal.js';
+import { readGlobals } from './command-opts.js';
+
+export function registerAuth(program: Command): void {
+  const auth = program.command('auth').description('Authentication management');
+
+  auth
+    .command('login')
+    .description('Log in (browser callback on localhost, or --device-code)')
+    .option('--device-code', 'Device code flow', false)
+    .option('--provider <name>', 'OAuth provider: google or msa', 'google')
+    .option('--endpoint <url>', 'API base URL')
+    .option('--profile <name>', 'Profile to save credentials', 'default')
+    .action(
+      handleErrors(async function authLoginAction(this: Command) {
+        const g = readGlobals(this);
+        const opts = this.opts() as {
+          deviceCode?: boolean;
+          provider?: string;
+          endpoint?: string;
+          profile?: string;
+        };
+        setJsonMode(Boolean(g.json));
+        const ep = normalizeEndpoint(opts.endpoint ?? g.endpoint);
+        if (opts.deviceCode) {
+          await loginDeviceCodeFlow(ep, opts.profile ?? 'default', Boolean(g.json));
+        } else {
+          await loginBrowserFlow(ep, opts.provider ?? 'google', opts.profile ?? 'default', Boolean(g.json));
+        }
+      })
+    );
+
+  auth
+    .command('logout')
+    .description('Remove saved credentials for a profile')
+    .option('--profile <name>', 'Profile', 'default')
+    .action(
+      handleErrors(async function authLogoutAction(this: Command) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { profile?: string };
+        setJsonMode(Boolean(g.json));
+        const profile = opts.profile ?? 'default';
+        const oauthPath = getOauthPath(profile);
+        if (existsSync(oauthPath)) {
+          unlinkSync(oauthPath);
+          emit(
+            { status: 'logged_out', profile },
+            () => {
+              consola.success(`Logged out from profile '${profile}'`);
+            }
+          );
+        } else {
+          emit(
+            { status: 'not_logged_in', profile },
+            () => {
+              consola.log(`Not logged in (profile '${profile}')`);
+            }
+          );
+        }
+      })
+    );
+
+  auth
+    .command('whoami')
+    .description('Show current identity')
+    .option('--profile <name>', 'Profile', 'default')
+    .option('--endpoint <url>', 'API base URL (display only)')
+    .action(
+      handleErrors(async function authWhoamiAction(this: Command) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { profile?: string; endpoint?: string };
+        setJsonMode(Boolean(g.json));
+        void opts.endpoint;
+        const profile = opts.profile ?? 'default';
+        const oauthPath = getOauthPath(profile);
+        if (!existsSync(oauthPath)) {
+          throw new CliError('Not logged in. Run `mitsein auth login`.', ExitCode.USAGE_ERROR);
+        }
+        const data = JSON.parse(readFileSync(oauthPath, 'utf8')) as Record<string, string>;
+        emit(
+          {
+            email: data.user_email ?? 'unknown',
+            user_id: data.user_id ?? 'unknown',
+            profile,
+            endpoint: data.endpoint ?? '',
+          },
+          (payload) => {
+            const d = payload as Record<string, string>;
+            consola.success(`Logged in as ${d.email}`);
+            consola.log(`  User ID:  ${d.user_id}`);
+            consola.log(`  Profile:  ${d.profile}`);
+            consola.log(`  Endpoint: ${d.endpoint}`);
+          }
+        );
+      })
+    );
+}

package/src/commands/command-opts.ts

@@ -0,0 +1,41 @@
+import type { Command } from 'commander';
+
+/** Options merged from root `program` + subcommand (`optsWithGlobals`). */
+export interface MitseinGlobalOpts {
+  endpoint?: string;
+  token?: string;
+  profile?: string;
+  real?: boolean;
+  json?: boolean;
+  debug?: boolean;
+  timeout?: string;
+}
+
+export function readGlobals(cmd: Command): MitseinGlobalOpts {
+  return cmd.optsWithGlobals() as MitseinGlobalOpts;
+}
+
+/** HTTP client timeout from `--timeout` (0 = no limit). */
+/** Comma-separated list → `Set` (trimmed, non-empty parts). */
+export function commaSet(value: string | undefined): Set<string> | null {
+  if (!value) {
+    return null;
+  }
+  const parts = value
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  return parts.length > 0 ? new Set(parts) : null;
+}
+
+export function httpTimeoutSec(g: MitseinGlobalOpts): number | undefined {
+  const raw = g.timeout ?? '30';
+  const n = Number.parseFloat(raw);
+  if (!Number.isFinite(n)) {
+    return 30;
+  }
+  if (n === 0) {
+    return undefined;
+  }
+  return n;
+}

package/src/commands/dev.ts

@@ -0,0 +1,100 @@
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { resolveCredentials } from '../core/credentials.js';
+import { getOpenapiCachePath } from '../core/config.js';
+import { handleErrors } from '../core/errors.js';
+import { loadOpenApiSpec } from '../core/openapi.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { httpTimeoutSec, readGlobals } from './command-opts.js';
+
+function healthHuman(data: unknown): void {
+  const record =
+    typeof data === 'object' && data !== null ? (data as Record<string, unknown>) : null;
+  const ok = Boolean(record && (record.status === 'ok' || record.ok === true));
+  if (ok) {
+    process.stdout.write('✓ Backend is healthy\n');
+  } else {
+    process.stdout.write('✗ Backend is unhealthy\n');
+  }
+}
+
+function openapiHuman(data: unknown): void {
+  const d = data as { title?: string; version?: string; paths?: number; cached_at?: string };
+  process.stdout.write(`✓ ${d.title ?? ''} v${d.version ?? ''}\n`);
+  process.stdout.write(`  ${d.paths ?? 0} paths\n`);
+  process.stdout.write(`  Cached at: ${d.cached_at ?? ''}\n`);
+}
+
+export function registerDev(parent: Command): void {
+  const dev = parent.command('dev').description('Development utilities');
+
+  dev
+    .command('token')
+    .description('Print the resolved dev token')
+    .action(
+      handleErrors(async function devTokenAction(this: Command) {
+        const g = readGlobals(this);
+        if (g.real) {
+          process.stderr.write('⚠️  Using --real: this token accesses real data, not e2e sandbox.\n');
+        }
+        const creds = resolveCredentials({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+        });
+        emit(creds.token);
+      })
+    );
+
+  dev
+    .command('health')
+    .description('Check backend health (GET /health)')
+    .action(
+      handleErrors(async function devHealthAction(this: Command) {
+        const g = readGlobals(this);
+        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.get('/health');
+        emit(result, healthHuman);
+      })
+    );
+
+  dev
+    .command('openapi')
+    .description('Fetch and cache OpenAPI spec from backend')
+    .option('--refresh', 'Force re-fetch from backend', false)
+    .action(
+      handleErrors(async function devOpenapiAction(this: Command) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { refresh?: boolean };
+        setJsonMode(Boolean(g.json));
+        const spec = await loadOpenApiSpec({
+          endpoint: g.endpoint,
+          refresh: Boolean(opts.refresh),
+        });
+        const cachePath = getOpenapiCachePath();
+        const paths = spec.paths;
+        const pathsCount =
+          paths !== null && typeof paths === 'object' && !Array.isArray(paths)
+            ? Object.keys(paths as object).length
+            : 0;
+        const info = (spec.info ?? {}) as Record<string, unknown>;
+        emit(
+          {
+            title: String(info.title ?? ''),
+            version: String(info.version ?? ''),
+            paths: pathsCount,
+            cached_at: cachePath,
+          },
+          openapiHuman
+        );
+      })
+    );
+}

package/src/commands/messages.ts

@@ -0,0 +1,61 @@
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { handleErrors } from '../core/errors.js';
+import { httpTimeoutSec, readGlobals } from './command-opts.js';
+
+export function registerMessages(program: Command): void {
+  const messages = program.command('messages').description('Message list and send (no agent)');
+
+  messages
+    .command('list <thread_id>')
+    .description('List messages for a thread')
+    .option('--offset <n>', 'Pagination offset', '0')
+    .option('--limit <n>', 'Max results', '20')
+    .action(
+      handleErrors(async function messagesListAction(this: Command, threadId: string) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { offset?: string; 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 offset = Number.parseInt(String(opts.offset ?? '0'), 10);
+        const limit = Number.parseInt(String(opts.limit ?? '20'), 10);
+        const result = await client.post('/api/message/list', {
+          thread_id: threadId,
+          limit: Number.isFinite(limit) ? limit : 20,
+          offset: Number.isFinite(offset) ? offset : 0,
+        });
+        emit(result);
+      })
+    );
+
+  messages
+    .command('send <thread_id> <content>')
+    .description('Add a user message (does not start the agent)')
+    .action(
+      handleErrors(async function messagesSendAction(this: Command, threadId: string, content: 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/message/add', {
+          thread_id: threadId,
+          content,
+        });
+        emit(result);
+      })
+    );
+}

package/src/commands/project.ts

@@ -0,0 +1,77 @@
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { handleErrors } from '../core/errors.js';
+import { httpTimeoutSec, readGlobals } from './command-opts.js';
+
+export function registerProject(program: Command): void {
+  const project = program.command('project').description('Project management');
+
+  project
+    .command('list')
+    .description('List projects')
+    .option('--offset <n>', 'Pagination offset', '0')
+    .option('--limit <n>', 'Max results', '20')
+    .action(
+      handleErrors(async function projectListAction(this: Command) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { offset?: string; 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 offset = Number.parseInt(String(opts.offset ?? '0'), 10);
+        const limit = Number.parseInt(String(opts.limit ?? '20'), 10);
+        const result = await client.post('/api/project/list', {
+          offset: Number.isFinite(offset) ? offset : 0,
+          limit: Number.isFinite(limit) ? limit : 20,
+        });
+        emit(result);
+      })
+    );
+
+  project
+    .command('get <project_id>')
+    .description('Get project details')
+    .action(
+      handleErrors(async function projectGetAction(this: Command, projectId: 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/project/get', { project_id: projectId });
+        emit(result);
+      })
+    );
+
+  project
+    .command('delete <project_id>')
+    .description('Delete a project')
+    .action(
+      handleErrors(async function projectDeleteAction(this: Command, projectId: 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/project/delete', { project_id: projectId });
+        emit(result);
+      })
+    );
+}

package/src/commands/run.ts

@@ -0,0 +1,134 @@
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { resolveCredentials } from '../core/credentials.js';
+import { 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 registerRun(program: Command): void {
+  const run = program.command('run').description('Agent run management');
+
+  run
+    .command('list <thread_id>')
+    .description('List agent runs for a thread')
+    .action(
+      handleErrors(async function runListAction(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/${threadId}/agent-runs`);
+        emit(result);
+      })
+    );
+
+  run
+    .command('get <run_id>')
+    .description('Get agent run status')
+    .action(
+      handleErrors(async function runGetAction(this: Command, runId: 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/agent-run/${runId}`);
+        emit(result);
+      })
+    );
+
+  run
+    .command('tail <run_id>')
+    .description('Stream agent run events (tail -f)')
+    .option('--filter <types>', 'Comma-separated event types')
+    .option('--timeout <sec>', 'Timeout (0 = no limit)', '120')
+    .action(
+      handleErrors(async function runTailAction(this: Command, runId: string) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { filter?: string; timeout?: string };
+        setJsonMode(Boolean(g.json));
+        const creds = resolveCredentials({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+        });
+        const rawT = opts.timeout ?? '120';
+        const tNum = Number.parseFloat(rawT);
+        const effectiveTimeout = Number.isFinite(tNum) && tNum === 0 ? null : Number.isFinite(tNum) ? tNum : 120;
+        await waitForRun({
+          endpoint: creds.endpoint,
+          token: creds.token,
+          agent_run_id: runId,
+          timeout: effectiveTimeout ?? undefined,
+          stream_output: true,
+          json_mode: Boolean(g.json),
+          debug: g.debug,
+          event_filter: commaSet(opts.filter),
+        });
+      })
+    );
+
+  run
+    .command('wait <run_id>')
+    .description('Block until agent run completes')
+    .option('--timeout <sec>', 'Timeout (0 = no limit)', '120')
+    .action(
+      handleErrors(async function runWaitAction(this: Command, runId: string) {
+        const g = readGlobals(this);
+        const opts = this.opts() as { timeout?: string };
+        setJsonMode(Boolean(g.json));
+        const creds = resolveCredentials({
+          token: g.token,
+          endpoint: g.endpoint,
+          profile: g.profile ?? 'e2e',
+          real: g.real,
+        });
+        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: runId,
+          timeout: effectiveTimeout ?? undefined,
+          stream_output: false,
+          json_mode: Boolean(g.json),
+          debug: g.debug,
+        });
+        emit(result);
+      })
+    );
+
+  run
+    .command('cancel <run_id>')
+    .description('Cancel a running agent')
+    .action(
+      handleErrors(async function runCancelAction(this: Command, runId: 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/agent-run/${runId}/stop`);
+        emit(result);
+      })
+    );
+}