@mitsein-ai/cli 0.1.6 → 0.2.1

package/package.json

@@ -8,7 +8,7 @@
     "ofetch": "^1.4.1",
     "undici": "^8.0.2"
   },
-  "description": "Mitsein CLI — dev tooling, API helpers, and workflow automation",
+  "description": "Mitsein CLI \u2014 dev tooling, API helpers, and workflow automation",
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.3.3"
@@ -46,5 +46,5 @@
     "typecheck": "tsc --noEmit"
   },
   "type": "module",
-  "version": "0.1.6"
+  "version": "0.2.1"
 }

package/src/commands/agent.ts

@@ -88,4 +88,130 @@ export function registerAgent(program: Command): void {
         }
       })
     );
+
+  /* ── running sub-group (formerly top-level `run` command) ── */
+  const running = agent.command('running').description('Agent run management');
+
+  running
+    .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);
+      })
+    );
+
+  running
+    .command('status <run_id>')
+    .description('Get agent run status')
+    .action(
+      handleErrors(async function runStatusAction(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);
+      })
+    );
+
+  running
+    .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),
+        });
+      })
+    );
+
+  running
+    .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);
+      })
+    );
+
+  running
+    .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);
+      })
+    );
 }

package/src/commands/auth-browser.ts

@@ -15,7 +15,7 @@ function firstQuery(q: ParsedUrlQuery, key: string): string | undefined {
 
 export async function loginBrowserFlow(
   endpoint: string,
-  provider: string,
+  provider: string | undefined,
   profile: string,
   jsonOutput: boolean
 ): Promise<void> {
@@ -92,7 +92,12 @@ export async function loginBrowserFlow(
     timer = setTimeout(() => finish(), 300_000);
 
     server.listen(LOCALHOST_PORT, '127.0.0.1', () => {
-      const loginUrl = `${endpoint}/api/auth/cognito/login?provider=${encodeURIComponent(provider)}`;
+      const redirectUri = `http://127.0.0.1:${LOCALHOST_PORT}/callback`;
+      const params = new URLSearchParams({ redirect_uri: redirectUri });
+      if (provider) {
+        params.set('provider', provider);
+      }
+      const loginUrl = `${endpoint}/api/auth/cognito/login?${params.toString()}`;
       if (!jsonOutput) {
         consola.log('\nOpening browser for login...');
         consola.log(`If browser does not open, visit: ${loginUrl}\n`);

package/src/commands/auth.ts

@@ -16,7 +16,7 @@ export function registerAuth(program: Command): void {
     .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('--provider <name>', 'OAuth provider (e.g. google, msa). Omit to let the server show a chooser')
     .option('--endpoint <url>', 'API base URL')
     .option('--profile <name>', 'Profile to save credentials', 'default')
     .action(
@@ -33,7 +33,7 @@ export function registerAuth(program: Command): void {
         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));
+          await loginBrowserFlow(ep, opts.provider, opts.profile ?? 'default', Boolean(g.json));
         }
       })
     );

package/src/commands/files.ts

@@ -0,0 +1,216 @@
+import { readFile } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import type { Command } from 'commander';
+import { ApiClient } from '../core/client.js';
+import { CliError, ExitCode, handleErrors } from '../core/errors.js';
+import { emit, setJsonMode } from '../core/output.js';
+import { httpTimeoutSec, readGlobals } from './command-opts.js';
+
+function makeClient(cmd: Command): ApiClient {
+  const g = readGlobals(cmd);
+  setJsonMode(Boolean(g.json));
+  return ApiClient.fromOptions({
+    token: g.token,
+    endpoint: g.endpoint,
+    profile: g.profile ?? 'e2e',
+    real: g.real,
+    timeoutSec: httpTimeoutSec(g),
+    debug: g.debug,
+  });
+}
+
+export function registerFiles(program: Command): void {
+  const files = program.command('files').description('Sandbox file operations');
+
+  files
+    .command('list <thread_id>')
+    .description('List files in a thread sandbox')
+    .option('--path <dir>', 'Directory path', '')
+    .option('--filter <glob>', 'Glob filter', '*')
+    .action(
+      handleErrors(async function filesListAction(this: Command, threadId: string) {
+        const client = makeClient(this);
+        const opts = this.opts() as { path: string; filter: string };
+        const result = await client.get(`/api/files/${threadId}/list`, {
+          path: opts.path,
+          filter: opts.filter,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('read <thread_id> <path>')
+    .description('Read file content from sandbox')
+    .action(
+      handleErrors(async function filesReadAction(this: Command, threadId: string, filePath: string) {
+        const client = makeClient(this);
+        const result = await client.get(`/api/files/${threadId}/read`, {
+          path: filePath,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('info <thread_id> <path>')
+    .description('Get file metadata')
+    .action(
+      handleErrors(async function filesInfoAction(this: Command, threadId: string, filePath: string) {
+        const client = makeClient(this);
+        const result = await client.get(`/api/files/${threadId}/info`, {
+          path: filePath,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('upload <thread_id> <local_path>')
+    .description('Upload a local file to the sandbox')
+    .option('--remote-path <path>', 'Remote destination path (default: filename)')
+    .action(
+      handleErrors(async function filesUploadAction(
+        this: Command,
+        threadId: string,
+        localPath: string,
+      ) {
+        const client = makeClient(this);
+        const opts = this.opts() as { remotePath?: string };
+        const absPath = resolve(localPath);
+        const bytes = await readFile(absPath);
+        const fileName = basename(absPath);
+        const remotePath = opts.remotePath ?? fileName;
+        const file = new File([bytes], fileName);
+        const result = await client.postMultipart(`/api/files/${threadId}/upload`, {
+          file,
+          path: remotePath,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('write <thread_id> <remote_path>')
+    .description('Write content to a file in the sandbox')
+    .option('--from <local_path>', 'Local file to read (reads stdin if omitted)')
+    .action(
+      handleErrors(async function filesWriteAction(
+        this: Command,
+        threadId: string,
+        remotePath: string,
+      ) {
+        const client = makeClient(this);
+        const opts = this.opts() as { from?: string };
+        let bytes: Buffer;
+        if (opts.from) {
+          bytes = await readFile(resolve(opts.from));
+        } else {
+          bytes = await readStdin();
+        }
+        const fileName = basename(remotePath);
+        const content = new File([bytes], fileName);
+        const result = await client.postMultipart(`/api/files/${threadId}/write`, {
+          content,
+          path: remotePath,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('mkdir <thread_id> <path>')
+    .description('Create a directory in the sandbox')
+    .action(
+      handleErrors(async function filesMkdirAction(this: Command, threadId: string, dirPath: string) {
+        const client = makeClient(this);
+        const result = await client.post(`/api/files/${threadId}/folder`, {
+          path: dirPath,
+        });
+        emit(result);
+      })
+    );
+
+  files
+    .command('delete <thread_id> <path>')
+    .description('Delete a file from the sandbox')
+    .action(
+      handleErrors(async function filesDeleteAction(
+        this: Command,
+        threadId: string,
+        filePath: string,
+      ) {
+        const client = makeClient(this);
+        const result = await client.delete(`/api/files/${threadId}/delete`, { path: filePath });
+        emit(result);
+      })
+    );
+
+  files
+    .command('download <thread_id>')
+    .description('Download file(s) from the sandbox')
+    .option('--path <path>', 'Single file path to download')
+    .option('--paths <paths...>', 'Multiple file paths (batch download)')
+    .option('--out <dir>', 'Output directory', '.')
+    .action(
+      handleErrors(async function filesDownloadAction(this: Command, threadId: string) {
+        const client = makeClient(this);
+        const opts = this.opts() as {
+          path?: string;
+          paths?: string[];
+          out: string;
+        };
+
+        if (!opts.path && (!opts.paths || opts.paths.length === 0)) {
+          throw new CliError(
+            'Either --path or --paths is required',
+            ExitCode.USAGE_ERROR,
+          );
+        }
+
+        if (opts.path && opts.paths && opts.paths.length > 0) {
+          throw new CliError(
+            '--path and --paths are mutually exclusive',
+            ExitCode.USAGE_ERROR,
+          );
+        }
+
+        if (opts.path) {
+          const result = await client.get(
+            `/api/files/${threadId}/read-binary`,
+            { path: opts.path },
+          );
+          const outPath = resolve(opts.out, basename(opts.path));
+          if (result instanceof ArrayBuffer || Buffer.isBuffer(result)) {
+            await writeFile(outPath, Buffer.from(result as ArrayBuffer));
+          } else {
+            await writeFile(outPath, String(result));
+          }
+          emit({ downloaded: outPath });
+        } else {
+          const result = await client.post(
+            `/api/files/${threadId}/batch-download`,
+            { paths: opts.paths },
+          );
+          emit(result);
+        }
+      })
+    );
+}
+
+async function readStdin(timeoutMs = 30_000): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  const timer = setTimeout(() => {
+    process.stderr.write('error: stdin read timed out (no input received)\n');
+    process.exit(1);
+  }, timeoutMs);
+  try {
+    for await (const chunk of process.stdin) {
+      chunks.push(Buffer.from(chunk as Uint8Array));
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+  return Buffer.concat(chunks);
+}

package/src/core/client.ts

@@ -168,6 +168,66 @@ export class ApiClient {
     }
   }
 
+  async postMultipart(
+    path: string,
+    fields: Record<string, string | File | Blob>,
+  ): Promise<unknown> {
+    const p = path.startsWith('/') ? path : `/${path}`;
+    const formData = new FormData();
+    for (const [k, v] of Object.entries(fields)) {
+      formData.append(k, v);
+    }
+    if (this.debug) {
+      logDebug(this.debug, `POST ${p} (multipart)`);
+      logDebug(this.debug, `fields: ${Object.keys(fields).join(', ')}`);
+    }
+    const url = `${this.baseUrl}${p}`;
+    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}`,
+        },
+        body: formData,
+        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) {
@@ -194,8 +254,8 @@ export class ApiClient {
     );
   }
 
-  async delete(path: string): Promise<unknown> {
+  async delete(path: string, query?: Record<string, unknown> | null): Promise<unknown> {
     const p = path.startsWith('/') ? path : `/${path}`;
-    return handleFetch(this.fetchImpl(p, { method: 'DELETE' }));
+    return handleFetch(this.fetchImpl(p, { method: 'DELETE', query: query ?? undefined }));
   }
 }

package/src/index.ts

@@ -6,9 +6,9 @@ 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 { registerFiles } from './commands/files.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';
@@ -49,12 +49,28 @@ program
 registerDev(program);
 registerApi(program);
 registerThread(program);
-registerRun(program);
 registerMessages(program);
 registerAgent(program);
 registerProject(program);
+registerFiles(program);
 registerAuth(program);
 
+// Deprecated: `mitsein run` was merged into `mitsein agent running` in v0.2.0
+program
+  .command('run', { hidden: true })
+  .description('[deprecated] Use `mitsein agent running` instead')
+  .allowUnknownOption(true)
+  .action(() => {
+    process.stderr.write(
+      'error: `mitsein run` has been removed in v0.2.0.\n' +
+      'Use `mitsein agent running <subcommand>` instead.\n' +
+      'Examples:\n' +
+      '  mitsein run list  →  mitsein agent running list\n' +
+      '  mitsein run status  →  mitsein agent running status\n',
+    );
+    process.exit(1);
+  });
+
 try {
   await program.parseAsync(process.argv, { from: 'node' });
 } catch (e) {

package/src/commands/run.ts

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