@mitsein-ai/cli 0.1.5 → 0.2.0

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.5"
+  "version": "0.2.0"
 }

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.ts

@@ -80,9 +80,47 @@ export function registerAuth(program: Command): void {
         setJsonMode(Boolean(g.json));
         void opts.endpoint;
         const profile = opts.profile ?? 'default';
+
+        // Check env token first (MITSEIN_TOKEN or --token)
+        if (g.token) {
+          // Try to parse dev token format: #{"userid":"...", ...}
+          const raw = g.token.startsWith('#') ? g.token.slice(1) : g.token;
+          try {
+            const parsed = JSON.parse(raw) as Record<string, string>;
+            emit(
+              {
+                email: parsed.email ?? 'unknown',
+                user_id: parsed.userid ?? 'unknown',
+                username: parsed.username ?? 'unknown',
+                source: 'env/flag',
+                profile,
+              },
+              (payload) => {
+                const d = payload as Record<string, string>;
+                consola.success(`Logged in as ${d.email}`);
+                consola.log(`  User ID:  ${d.user_id}`);
+                consola.log(`  Username: ${d.username}`);
+                consola.log(`  Source:   ${d.source}`);
+              }
+            );
+            return;
+          } catch {
+            // Not a parseable dev token, show raw info
+            emit(
+              { token: '***', source: 'env/flag', profile },
+              (payload) => {
+                const d = payload as Record<string, string>;
+                consola.success('Authenticated via token');
+                consola.log(`  Source: ${d.source}`);
+              }
+            );
+            return;
+          }
+        }
+
         const oauthPath = getOauthPath(profile);
         if (!existsSync(oauthPath)) {
-          throw new CliError('Not logged in. Run `mitsein auth login`.', ExitCode.USAGE_ERROR);
+          throw new CliError('Not logged in. Run `mitsein auth login` or set MITSEIN_TOKEN.', ExitCode.USAGE_ERROR);
         }
         const data = JSON.parse(readFileSync(oauthPath, 'utf8')) as Record<string, string>;
         emit(
@@ -91,6 +129,7 @@ export function registerAuth(program: Command): void {
             user_id: data.user_id ?? 'unknown',
             profile,
             endpoint: data.endpoint ?? '',
+            source: 'profile',
           },
           (payload) => {
             const d = payload as Record<string, string>;

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/commands/thread.ts

@@ -73,7 +73,7 @@ export function registerThread(program: Command): void {
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,
         });
-        const result = await client.post('/api/thread/create', { title: title ?? '' });
+        const result = await client.post('/api/threads', { title: title ?? '' });
         emit(result);
       })
     );

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);
-      })
-    );
-}