@mitsein-ai/cli 0.2.1 → 0.3.0

package/package.json

@@ -46,5 +46,5 @@
     "typecheck": "tsc --noEmit"
   },
   "type": "module",
-  "version": "0.2.1"
+  "version": "0.3.0"
 }

package/src/commands/agent.ts

@@ -1,33 +1,42 @@
 import type { Command } from 'commander';
 import { ApiClient } from '../core/client.js';
+import { runChat } from '../core/chat-run.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';
 
+type InvokeOpts = {
+  wait?: boolean;
+  stream?: boolean;
+  cancelOnInterrupt?: boolean;
+  filter?: string;
+  model?: string;
+  timeout?: string;
+};
+
+function effectiveTimeout(raw: string | undefined, fallback: number): number | null {
+  const v = Number.parseFloat(raw ?? String(fallback));
+  if (!Number.isFinite(v)) return fallback;
+  return v === 0 ? null : v;
+}
+
 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')
+    .description('Send a message and run the agent (default: wait silently)')
+    .option('--wait', 'Block until run completes (default mode)', false)
+    .option('--stream', 'Stream events live to stdout', false)
+    .option('--cancel-on-interrupt', 'Cancel the run on Ctrl-C (default: detach)', false)
+    .option('--filter <types>', 'Comma-separated event types (text,tool_call,...)')
     .option('--model <name>', 'Model override')
-    .option('--timeout <sec>', 'Wait/stream timeout (0 = no limit)', '120')
+    .option('--timeout <sec>', '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;
-        };
+        const opts = this.opts() as InvokeOpts;
         setJsonMode(Boolean(g.json));
 
         if (opts.wait && opts.stream) {
@@ -37,181 +46,154 @@ export function registerAgent(program: Command): void {
         const creds = resolveCredentials({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           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({
+        const result = await runChat({
           endpoint: creds.endpoint,
           token: creds.token,
-          agent_run_id: agentRunId,
-          timeout: effectiveTimeout ?? undefined,
-          stream_output: Boolean(opts.stream),
-          json_mode: Boolean(g.json),
+          threadId,
+          content: [{ type: 'text', text: prompt }],
+          model: opts.model ?? null,
+          timeoutSec: effectiveTimeout(opts.timeout, 120),
           debug: g.debug,
-          event_filter: commaSet(opts.filter),
+          streamOutput: Boolean(opts.stream),
+          jsonMode: Boolean(g.json),
+          eventFilter: commaSet(opts.filter),
+          cancelOnInterrupt: Boolean(opts.cancelOnInterrupt),
         });
 
-        if (opts.wait && !opts.stream) {
-          emit(result);
-        }
-      })
+        if (!opts.stream) emit(result);
+      }),
     );
 
-  /* ── running sub-group (formerly top-level `run` command) ── */
+  /* ── agent running ─────────────────────────────────────────────────────── */
   const running = agent.command('running').description('Agent run management');
 
   running
-    .command('list <thread_id>')
-    .description('List agent runs for a thread')
+    .command('list')
+    .description('List all active agent runs for the current account')
     .action(
-      handleErrors(async function runListAction(this: Command, threadId: string) {
+      handleErrors(async function runListAction(this: Command) {
         const g = readGlobals(this);
         setJsonMode(Boolean(g.json));
         const client = ApiClient.fromOptions({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,
         });
-        const result = await client.post(`/api/thread/${threadId}/agent-runs`);
-        emit(result);
-      })
+        const result = (await client.get('/api/next/runs/active')) as {
+          runs?: unknown[];
+        } | null;
+        emit(result?.runs ?? result);
+      }),
     );
 
   running
-    .command('status <run_id>')
-    .description('Get agent run status')
+    .command('status <thread_id>')
+    .description('Get active-run status for a thread')
     .action(
-      handleErrors(async function runStatusAction(this: Command, runId: string) {
+      handleErrors(async function runStatusAction(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',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,
         });
-        const result = await client.post(`/api/agent-run/${runId}`);
-        emit(result);
-      })
+        const detail = (await client.get(`/api/next/threads/${threadId}`)) as {
+          active_run?: unknown;
+        } | null;
+        emit(detail?.active_run ?? { status: 'idle', last_event_id: null, error: null });
+      }),
     );
 
   running
-    .command('tail <run_id>')
-    .description('Stream agent run events (tail -f)')
+    .command('tail <thread_id>')
+    .description("Reconnect to a running agent's event stream (tail -f)")
     .option('--filter <types>', 'Comma-separated event types')
-    .option('--timeout <sec>', 'Timeout (0 = no limit)', '120')
+    .option('--since <event_id>', 'Resume from this SSE event id')
+    .option('--timeout <sec>', 'Stream timeout (0 = no limit)', '120')
     .action(
-      handleErrors(async function runTailAction(this: Command, runId: string) {
+      handleErrors(async function runTailAction(this: Command, threadId: string) {
         const g = readGlobals(this);
-        const opts = this.opts() as { filter?: string; timeout?: string };
+        const opts = this.opts() as { filter?: string; since?: string; timeout?: string };
         setJsonMode(Boolean(g.json));
         const creds = resolveCredentials({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           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({
+        await runChat({
           endpoint: creds.endpoint,
           token: creds.token,
-          agent_run_id: runId,
-          timeout: effectiveTimeout ?? undefined,
-          stream_output: true,
-          json_mode: Boolean(g.json),
+          threadId,
+          // no `content` → reconnect mode
+          lastEventId: opts.since ?? null,
+          timeoutSec: effectiveTimeout(opts.timeout, 120),
           debug: g.debug,
-          event_filter: commaSet(opts.filter),
+          streamOutput: true,
+          jsonMode: Boolean(g.json),
+          eventFilter: commaSet(opts.filter),
         });
-      })
+      }),
     );
 
   running
-    .command('wait <run_id>')
-    .description('Block until agent run completes')
-    .option('--timeout <sec>', 'Timeout (0 = no limit)', '120')
+    .command('wait <thread_id>')
+    .description('Block until the active run for a thread completes')
+    .option('--since <event_id>', 'Resume from this SSE event id')
+    .option('--timeout <sec>', 'Wait timeout (0 = no limit)', '120')
     .action(
-      handleErrors(async function runWaitAction(this: Command, runId: string) {
+      handleErrors(async function runWaitAction(this: Command, threadId: string) {
         const g = readGlobals(this);
-        const opts = this.opts() as { timeout?: string };
+        const opts = this.opts() as { since?: string; timeout?: string };
         setJsonMode(Boolean(g.json));
         const creds = resolveCredentials({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           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({
+        const result = await runChat({
           endpoint: creds.endpoint,
           token: creds.token,
-          agent_run_id: runId,
-          timeout: effectiveTimeout ?? undefined,
-          stream_output: false,
-          json_mode: Boolean(g.json),
+          threadId,
+          lastEventId: opts.since ?? null,
+          timeoutSec: effectiveTimeout(opts.timeout, 120),
           debug: g.debug,
+          streamOutput: false,
+          jsonMode: Boolean(g.json),
         });
         emit(result);
-      })
+      }),
     );
 
   running
-    .command('cancel <run_id>')
-    .description('Cancel a running agent')
+    .command('cancel <thread_id>')
+    .description("Cancel a thread's running agent")
     .action(
-      handleErrors(async function runCancelAction(this: Command, runId: string) {
+      handleErrors(async function runCancelAction(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',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,
         });
-        const result = await client.post(`/api/agent-run/${runId}/stop`);
+        const result = await client.post(`/api/next/chat/${threadId}/cancel`);
         emit(result);
-      })
+      }),
     );
 }

package/src/commands/api-auto.ts

@@ -232,7 +232,7 @@ export function registerApi(program: Command): void {
         const client = ApiClient.fromOptions({
           token: opts.token ?? g.token,
           endpoint: opts.endpoint ?? g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: effectiveTimeout,
           debug: Boolean(opts.debug ?? g.debug),

package/src/commands/dev.ts

@@ -39,7 +39,7 @@ export function registerDev(parent: Command): void {
         const creds = resolveCredentials({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           real: g.real,
         });
         emit(creds.token);

package/src/commands/files.ts

@@ -13,7 +13,7 @@ function makeClient(cmd: Command): ApiClient {
   return ApiClient.fromOptions({
     token: g.token,
     endpoint: g.endpoint,
-    profile: g.profile ?? 'e2e',
+    profile: g.profile ?? 'default',
     real: g.real,
     timeoutSec: httpTimeoutSec(g),
     debug: g.debug,

package/src/commands/project.ts

@@ -20,18 +20,18 @@ export function registerProject(program: Command): void {
         const client = ApiClient.fromOptions({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           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', {
+        const result = (await client.post('/api/project/list', {
           offset: Number.isFinite(offset) ? offset : 0,
           limit: Number.isFinite(limit) ? limit : 20,
-        });
-        emit(result);
+        })) as { data?: unknown[] } | null;
+        emit(result?.data ?? result);
       })
     );
 
@@ -45,7 +45,7 @@ export function registerProject(program: Command): void {
         const client = ApiClient.fromOptions({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,
@@ -65,7 +65,7 @@ export function registerProject(program: Command): void {
         const client = ApiClient.fromOptions({
           token: g.token,
           endpoint: g.endpoint,
-          profile: g.profile ?? 'e2e',
+          profile: g.profile ?? 'default',
           real: g.real,
           timeoutSec: httpTimeoutSec(g),
           debug: g.debug,

package/src/commands/thread.ts

@@ -1,13 +1,24 @@
 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 { 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';
+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 ?? 'default',
+    real: g.real,
+    timeoutSec: httpTimeoutSec(g),
+    debug: g.debug,
+  });
+}
 
 export function registerThread(program: Command): void {
-  const thread = program.command('thread').description('Thread management and messaging');
+  const thread = program.command('thread').description('Thread management');
 
   thread
     .command('list')
@@ -16,24 +27,15 @@ export function registerThread(program: Command): void {
     .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 client = makeClient(this);
         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', {
+        const result = (await client.get('/api/threads', {
           offset: Number.isFinite(offset) ? offset : 0,
           limit: Number.isFinite(limit) ? limit : 20,
-        });
-        emit(result);
-      })
+        })) as { threads?: unknown[] } | null;
+        emit(result?.threads ?? result);
+      }),
     );
 
   thread
@@ -41,147 +43,68 @@ export function registerThread(program: Command): void {
     .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);
-      })
+        const client = makeClient(this);
+        const result = (await client.get(`/api/threads/${threadId}`)) as {
+          thread?: unknown;
+        } | null;
+        emit(result?.thread ?? result);
+      }),
     );
 
   thread
     .command('create')
     .description('Create a new thread')
-    .option('--title <title>', 'Thread title', '')
+    .option('--name <name>', 'Thread name', '')
+    .option('--agent <id>', 'Agent id to bind to the thread')
     .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/threads', { title: title ?? '' });
+        const client = makeClient(this);
+        const opts = this.opts() as { name?: string; agent?: string };
+        const body: Record<string, unknown> = {};
+        if (opts.name) body.name = opts.name;
+        if (opts.agent) body.agent_id = opts.agent;
+        const result = await client.post('/api/next/threads', body);
         emit(result);
-      })
+      }),
     );
 
   thread
-    .command('history <thread_id>')
-    .description('Show message history for a thread')
-    .option('--limit <n>', 'Max messages', '50')
+    .command('rename <thread_id> <name>')
+    .description('Rename a thread')
     .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,
-        });
+      handleErrors(async function threadRenameAction(this: Command, threadId: string, name: string) {
+        const client = makeClient(this);
+        const result = await client.patch(`/api/next/threads/${threadId}`, { name });
         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')
+    .command('delete <thread_id>')
+    .description('Delete a thread')
     .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),
-        });
+      handleErrors(async function threadDeleteAction(this: Command, threadId: string) {
+        const client = makeClient(this);
+        const result = await client.delete(`/api/next/threads/${threadId}`);
+        emit(result);
+      }),
+    );
 
-        if (opts.wait && !opts.stream) {
-          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 client = makeClient(this);
+        const { limit: lim } = this.opts() as { limit?: string };
+        const limit = Number.parseInt(String(lim ?? '50'), 10);
+        const result = (await client.get(`/api/next/threads/${threadId}`)) as {
+          messages?: unknown[];
+        } | null;
+        const messages = Array.isArray(result?.messages) ? result!.messages : [];
+        const take = Number.isFinite(limit) && limit > 0 ? limit : 50;
+        emit(messages.slice(-take));
+      }),
     );
 }