@vellumai/assistant 0.7.3 → 0.8.1

package/src/cli/commands/status.ts

@@ -1,8 +1,11 @@
+import { existsSync } from "node:fs";
+
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
+import { getAssistantSocketPath } from "../../ipc/socket-path.js";
 import { getWorkspaceDirDisplay } from "../../util/platform.js";
-import { log } from "../logger.js";
+import { registerCommand } from "../lib/register-command.js";
 
 interface HealthResponse {
   version: string;
@@ -16,42 +19,60 @@ function fmtMb(mb: number): string {
 }
 
 export function registerStatusCommand(program: Command): void {
-  program
-    .command("status")
-    .description("Show assistant version, workspace, and runtime health")
-    .action(async () => {
-      const result = await cliIpcCall<HealthResponse>("health");
-
-      if (!result.ok || !result.result) {
-        log.error(
-          result.error ??
-            "Assistant not running — could not connect to IPC socket.",
+  registerCommand(program, {
+    name: "status",
+    transport: "ipc",
+    description: "Show assistant version, workspace, and runtime health",
+    build: (cmd) => {
+      cmd.action(async () => {
+        const result = await cliIpcCall<HealthResponse>("health");
+
+        if (!result.ok) {
+          // Only ENOENT/ECONNREFUSED/connect-timeout produce this prefix; other
+          // failures (daemon-side error, framing error, abort) are real failures.
+          if (result.error?.startsWith("Could not connect to the assistant at ")) {
+            const socketPath = getAssistantSocketPath();
+            const socketExists = existsSync(socketPath);
+            const workspace = getWorkspaceDirDisplay();
+            process.stdout.write(
+              (socketExists ? "Assistant: running" : "Assistant: down") + "\n",
+            );
+            process.stdout.write(`Workspace: ${workspace}\n`);
+            process.exit(0);
+          }
+          process.stderr.write((result.error ?? "health check failed") + "\n");
+          process.exit(1);
+        }
+
+        if (!result.result) {
+          process.stderr.write("health check returned empty response\n");
+          process.exit(1);
+        }
+
+        const h = result.result;
+        const workspace = getWorkspaceDirDisplay();
+
+        const rows: [string, string][] = [
+          ["Version", h.version],
+          ["Workspace", workspace],
+          ["", ""],
+          ["Memory", `${fmtMb(h.memory.currentMb)} / ${fmtMb(h.memory.maxMb)}`],
+          ...(h.disk
+            ? ([["Disk", `${fmtMb(h.disk.freeMb)} free`]] as [string, string][])
+            : []),
+        ];
+
+        const labelWidth = Math.max(
+          ...rows.filter(([l]) => l).map(([l]) => l.length),
         );
-        process.exit(1);
-      }
-
-      const h = result.result;
-      const workspace = getWorkspaceDirDisplay();
-
-      const rows: [string, string][] = [
-        ["Version", h.version],
-        ["Workspace", workspace],
-        ["", ""],
-        ["Memory", `${fmtMb(h.memory.currentMb)} / ${fmtMb(h.memory.maxMb)}`],
-        ...(h.disk
-          ? ([["Disk", `${fmtMb(h.disk.freeMb)} free`]] as [string, string][])
-          : []),
-      ];
-
-      const labelWidth = Math.max(
-        ...rows.filter(([l]) => l).map(([l]) => l.length),
-      );
-      for (const [label, value] of rows) {
-        if (!label) {
-          log.info("");
-          continue;
+        for (const [label, value] of rows) {
+          if (!label) {
+            process.stdout.write("\n");
+            continue;
+          }
+          process.stdout.write(`${label.padEnd(labelWidth)}  ${value}\n`);
         }
-        log.info(`${label.padEnd(labelWidth)}  ${value}`);
-      }
-    });
+      });
+    },
+  });
 }

package/src/cli/commands/stt.ts

@@ -2,28 +2,20 @@
  * CLI command group: `assistant stt`
  *
  * Speech-to-text operations using the configured STT provider.
- * Stateless, request-response commands — no daemon dependency.
+ * Thin IPC wrapper — all daemon work (ffmpeg conversion, chunking,
+ * transcription) is handled by the stt_transcribe_file route.
  */
 
-import { randomUUID } from "node:crypto";
-import { access, mkdir, readdir, readFile, rm, unlink } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { extname, join } from "node:path";
+import { extname, resolve } from "node:path";
 
 import type { Command } from "commander";
 
-import { listProviderIds } from "../../providers/speech-to-text/provider-catalog.js";
-import { resolveBatchTranscriber } from "../../providers/speech-to-text/resolve.js";
-import type { BatchTranscriber } from "../../stt/types.js";
-import {
-  FFMPEG_TRANSCODE_TIMEOUT_MS,
-  FFPROBE_TIMEOUT_MS,
-  spawnWithTimeout,
-} from "../../util/spawn.js";
+import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 
 // ---------------------------------------------------------------------------
-// Constants
+// Constants (client-side extension validation only)
 // ---------------------------------------------------------------------------
 
 const VIDEO_EXTENSIONS = new Set([
@@ -47,170 +39,47 @@ const AUDIO_EXTENSIONS = new Set([
   ".wma",
 ]);
 
-/** Max file size for a single STT chunk request (25MB). */
-const STT_CHUNK_MAX_BYTES = 25 * 1024 * 1024;
-
-/** Duration per chunk when splitting for large files (10 minutes). */
-const CHUNK_DURATION_SECS = 600;
-
-/** Timeout for a single STT transcription request. */
-const STT_REQUEST_TIMEOUT_MS = 300_000;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-async function getAudioDuration(audioPath: string): Promise<number> {
-  const result = await spawnWithTimeout(
-    [
-      "ffprobe",
-      "-v",
-      "error",
-      "-show_entries",
-      "format=duration",
-      "-of",
-      "csv=p=0",
-      audioPath,
-    ],
-    FFPROBE_TIMEOUT_MS,
-  );
-  if (result.exitCode !== 0) return 0;
-  return parseFloat(result.stdout.trim()) || 0;
-}
-
-async function splitAudio(
-  audioPath: string,
-  chunkDir: string,
-  chunkDurationSecs: number,
-): Promise<string[]> {
-  const chunkPattern = join(chunkDir, "chunk-%03d.wav");
-  const result = await spawnWithTimeout(
-    [
-      "ffmpeg",
-      "-y",
-      "-i",
-      audioPath,
-      "-f",
-      "segment",
-      "-segment_time",
-      String(chunkDurationSecs),
-      "-acodec",
-      "pcm_s16le",
-      "-ar",
-      "16000",
-      "-ac",
-      "1",
-      chunkPattern,
-    ],
-    FFMPEG_TRANSCODE_TIMEOUT_MS,
-  );
-  if (result.exitCode !== 0) {
-    throw new Error(`Failed to split audio: ${result.stderr.slice(0, 300)}`);
-  }
-  const files = await readdir(chunkDir);
-  return files
-    .filter((f) => f.startsWith("chunk-") && f.endsWith(".wav"))
-    .sort()
-    .map((f) => join(chunkDir, f));
-}
-
-/** Convert source to 16kHz mono WAV for consistent processing. */
-async function toWav(inputPath: string, isVideo: boolean): Promise<string> {
-  const wavPath = join(tmpdir(), `vellum-transcribe-${randomUUID()}.wav`);
-  const args = ["ffmpeg", "-y", "-i", inputPath];
-  if (isVideo) args.push("-vn");
-  args.push("-acodec", "pcm_s16le", "-ar", "16000", "-ac", "1", wavPath);
-  const result = await spawnWithTimeout(args, FFMPEG_TRANSCODE_TIMEOUT_MS);
-  if (result.exitCode !== 0) {
-    throw new Error(`ffmpeg failed: ${result.stderr.slice(0, 500)}`);
-  }
-  return wavPath;
-}
-
-async function transcribeWithProvider(
-  audioPath: string,
-  transcriber: BatchTranscriber,
-): Promise<string> {
-  const duration = await getAudioDuration(audioPath);
-  const fileSize = Bun.file(audioPath).size;
-
-  // If small enough, send directly
-  if (fileSize <= STT_CHUNK_MAX_BYTES) {
-    const audioBuffer = await readFile(audioPath);
-    const result = await transcriber.transcribe({
-      audio: audioBuffer,
-      mimeType: "audio/wav",
-      signal: AbortSignal.timeout(STT_REQUEST_TIMEOUT_MS),
-    });
-    return result.text;
-  }
-
-  // Split into chunks for large files
-  const chunkDir = join(tmpdir(), `vellum-transcribe-chunks-${randomUUID()}`);
-  await mkdir(chunkDir, { recursive: true });
-
-  try {
-    process.stderr.write(
-      `Large file (${Math.round(duration / 60)}min) - splitting into chunks...\n`,
-    );
-    const chunks = await splitAudio(audioPath, chunkDir, CHUNK_DURATION_SECS);
-    const parts: string[] = [];
-
-    for (let i = 0; i < chunks.length; i++) {
-      process.stderr.write(
-        `  Transcribing chunk ${i + 1}/${chunks.length}...\n`,
-      );
-      const audioBuffer = await readFile(chunks[i]);
-      const result = await transcriber.transcribe({
-        audio: audioBuffer,
-        mimeType: "audio/wav",
-        signal: AbortSignal.timeout(STT_REQUEST_TIMEOUT_MS),
-      });
-      if (result.text) parts.push(result.text);
-    }
-
-    return parts.join(" ");
-  } finally {
-    await rm(chunkDir, { recursive: true, force: true }).catch(() => {});
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Command registration
 // ---------------------------------------------------------------------------
 
 export function registerSttCommand(program: Command): void {
-  const sttCmd = program
-    .command("stt")
-    .description("Speech-to-text operations");
-
-  const supportedProviders = listProviderIds().join(", ");
-
-  sttCmd.addHelpText(
-    "after",
-    `
+  registerCommand(program, {
+    name: "stt",
+    transport: "ipc",
+    description: "Speech-to-text operations",
+    build: (sttCmd) => {
+      sttCmd.addHelpText(
+        "after",
+        `
 Speech-to-text commands use your configured STT provider to transcribe
 audio and video files. The provider is set via:
 
   $ assistant config set services.stt.provider <provider>
 
-Supported providers: ${supportedProviders}.
+Supported providers: openai-whisper, deepgram, google-gemini, xai.
 
 Examples:
   $ assistant stt transcribe --file /path/to/meeting.wav
   $ assistant stt transcribe --file /path/to/video.mp4 --json`,
-  );
-
-  // ── transcribe ──────────────────────────────────────────────────────
+      );
 
-  sttCmd
-    .command("transcribe")
-    .description("Transcribe an audio or video file to text")
-    .requiredOption("--file <path>", "Absolute path to the audio/video file")
-    .option("--json", "Output structured JSON instead of plain transcript text")
-    .addHelpText(
-      "after",
-      `
+      // ── transcribe ──────────────────────────────────────────────────────
+
+      sttCmd
+        .command("transcribe")
+        .description("Transcribe an audio or video file to text")
+        .requiredOption(
+          "--file <path>",
+          "Absolute path to the audio/video file",
+        )
+        .option(
+          "--json",
+          "Output structured JSON instead of plain transcript text",
+        )
+        .addHelpText(
+          "after",
+          `
 Transcribes an audio or video file using the configured speech-to-text
 provider. Video files automatically have their audio extracted via ffmpeg.
 Large files (>25MB as WAV) are automatically split into chunks and
@@ -225,115 +94,78 @@ Examples:
   $ assistant stt transcribe --file /path/to/recording.wav
   $ assistant stt transcribe --file /path/to/meeting.mp4
   $ assistant stt transcribe --file /path/to/podcast.mp3 --json`,
-    )
-    .action(async (opts: { file: string; json?: boolean }) => {
-      const filePath = opts.file;
-      const jsonOutput = opts.json ?? false;
-
-      // Validate file exists
-      try {
-        await access(filePath);
-      } catch {
-        const msg = `File not found: ${filePath}`;
-        if (jsonOutput) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: msg }) + "\n",
-          );
-        } else {
-          log.error(msg);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      // Validate file extension
-      const ext = extname(filePath).toLowerCase();
-      const isVideo = VIDEO_EXTENSIONS.has(ext);
-      const isAudio = AUDIO_EXTENSIONS.has(ext);
-      if (!isVideo && !isAudio) {
-        const msg = `Unsupported file type: ${ext}. Only audio and video files can be transcribed.`;
-        if (jsonOutput) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: msg }) + "\n",
-          );
-        } else {
-          log.error(msg);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      // Resolve STT provider
-      const transcriber = await resolveBatchTranscriber();
-      if (!transcriber) {
-        const msg =
-          "No speech-to-text provider is configured. Run 'assistant config set services.stt.provider <provider>' to set one up.";
-        if (jsonOutput) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: msg }) + "\n",
-          );
-        } else {
-          log.error(msg);
-        }
-        process.exitCode = 1;
-        return;
-      }
+        )
+        .action(async (opts: { file: string; json?: boolean }) => {
+          const filePath = resolve(opts.file);
+          const jsonOutput = opts.json ?? false;
+
+          // Client-side extension validation (provides clear error before hitting daemon)
+          const ext = extname(filePath).toLowerCase();
+          const isVideo = VIDEO_EXTENSIONS.has(ext);
+          const isAudio = AUDIO_EXTENSIONS.has(ext);
+          if (!isVideo && !isAudio) {
+            const msg = `Unsupported file type: ${ext}. Only audio and video files can be transcribed.`;
+            if (jsonOutput) {
+              process.stdout.write(
+                JSON.stringify({ ok: false, error: msg }) + "\n",
+              );
+            } else {
+              log.error(msg);
+            }
+            process.exitCode = 1;
+            return;
+          }
 
-      let wavPath: string | null = null;
-      try {
-        // Convert to WAV
-        wavPath = await toWav(filePath, isVideo);
+          const r = await cliIpcCall<{
+            transcript: string;
+            provider: string;
+            durationSeconds: number;
+          }>("stt_transcribe_file", { body: { filePath } });
+
+          if (!r.ok) {
+            if (jsonOutput) {
+              process.stdout.write(
+                JSON.stringify({ ok: false, error: r.error }) + "\n",
+              );
+              process.exitCode = 1;
+              return;
+            }
+            return exitFromIpcResult(
+              r as { ok: false; error?: string; statusCode?: number },
+            );
+          }
 
-        const startTime = Date.now();
-        const text = await transcribeWithProvider(wavPath, transcriber);
-        const durationSeconds = (Date.now() - startTime) / 1000;
+          const { transcript, provider, durationSeconds } = r.result!;
+
+          if (!transcript.trim()) {
+            if (jsonOutput) {
+              process.stdout.write(
+                JSON.stringify({
+                  ok: true,
+                  transcript: "",
+                  provider,
+                  durationSeconds,
+                }) + "\n",
+              );
+            } else {
+              process.stdout.write("No speech detected in the audio.\n");
+            }
+            return;
+          }
 
-        if (!text.trim()) {
           if (jsonOutput) {
             process.stdout.write(
               JSON.stringify({
                 ok: true,
-                transcript: "",
-                provider: transcriber.providerId,
+                transcript,
+                provider,
                 durationSeconds,
               }) + "\n",
             );
           } else {
-            process.stdout.write("No speech detected in the audio.\n");
-          }
-          return;
-        }
-
-        if (jsonOutput) {
-          process.stdout.write(
-            JSON.stringify({
-              ok: true,
-              transcript: text,
-              provider: transcriber.providerId,
-              durationSeconds,
-            }) + "\n",
-          );
-        } else {
-          process.stdout.write(text + "\n");
-        }
-      } catch (err) {
-        const msg = `Transcription failed: ${(err as Error).message}`;
-        if (jsonOutput) {
-          process.stdout.write(
-            JSON.stringify({ ok: false, error: msg }) + "\n",
-          );
-        } else {
-          log.error(msg);
-        }
-        process.exitCode = 1;
-      } finally {
-        if (wavPath) {
-          try {
-            await unlink(wavPath);
-          } catch {
-            /* ignore */
+            process.stdout.write(transcript + "\n");
           }
-        }
-      }
-    });
+        });
+    },
+  });
 }

package/src/cli/commands/task.ts

@@ -9,50 +9,18 @@
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
-
-// ── Conversation ID resolution ────────────────────────────────────────
-
-/**
- * Resolve the conversation ID by precedence:
- *   1. Explicit `--conversation-id` flag
- *   2. `__SKILL_CONTEXT_JSON` env var (set by skill sandbox runner)
- *   3. `__CONVERSATION_ID` env var (set by bash tool subprocess)
- *   4. Fail with an actionable error
- */
-function resolveConversationId(explicit?: string): string {
-  if (explicit) return explicit;
-
-  const contextJson = process.env.__SKILL_CONTEXT_JSON;
-  if (contextJson) {
-    try {
-      const parsed = JSON.parse(contextJson);
-      if (parsed.conversationId && typeof parsed.conversationId === "string") {
-        return parsed.conversationId;
-      }
-    } catch {
-      // Fall through
-    }
-  }
-
-  const envConvId = process.env.__CONVERSATION_ID;
-  if (envConvId && typeof envConvId === "string") {
-    return envConvId;
-  }
-
-  throw new Error(
-    "No conversation ID available.\n" +
-      "Provide --conversation-id explicitly (run 'assistant conversations list' to find it),\n" +
-      "or run this command from a skill or bash tool context.",
-  );
-}
+import { resolveConversationId } from "../utils/conversation-id.js";
 
 // ── Registration ──────────────────────────────────────────────────────
 
 export function registerTaskCommand(program: Command): void {
-  const task = program
-    .command("task")
-    .description("Manage task templates and work queue items");
+  registerCommand(program, {
+    name: "task",
+    transport: "ipc",
+    description: "Manage task templates and work queue items",
+    build: (task) => {
 
   task.addHelpText(
     "after",
@@ -100,7 +68,11 @@ Examples:
       }) => {
         let conversationId: string;
         try {
-          conversationId = resolveConversationId(opts.conversationId);
+          conversationId = resolveConversationId({
+            explicit: opts.conversationId,
+            failureHelp:
+              "No conversation ID available.\nProvide --conversation-id explicitly (run 'assistant conversations list' to find it),\nor run this command from a skill or bash tool context.",
+          });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           if (opts.json) {
@@ -794,4 +766,6 @@ Examples:
         }
       },
     );
+    },
+  });
 }

package/src/cli/commands/trust.ts

@@ -8,6 +8,7 @@
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
+import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 
 // -- Types --------------------------------------------------------------------
@@ -25,9 +26,11 @@ interface TrustRule {
 // -- Registration -------------------------------------------------------------
 
 export function registerTrustCommand(program: Command): void {
-  const trust = program
-    .command("trust")
-    .description("View tool trust rules (allow-list patterns for tool use)");
+  registerCommand(program, {
+    name: "trust",
+    transport: "ipc",
+    description: "View tool trust rules (allow-list patterns for tool use)",
+    build: (trust) => {
 
   trust.addHelpText(
     "after",
@@ -139,4 +142,6 @@ Examples:
         );
       }
     });
+    },
+  });
 }