@iinm/plain-agent 1.7.16 → 1.7.18

package/src/cliInteractive.mjs

@@ -1,6 +1,7 @@
 /**
  * @import { UserEventEmitter, AgentEventEmitter, AgentCommands } from "./agent"
  * @import { ClaudeCodePlugin } from "./claudeCodePlugin.mjs"
+ * @import { VoiceInputConfig, VoiceSession } from "./voiceInput.mjs"
  */
 
 import readline from "node:readline";
@@ -13,8 +14,10 @@ import {
   printMessage,
 } from "./cliFormatter.mjs";
 import { createInterruptTransform } from "./cliInterruptTransform.mjs";
+import { createMuteTransform } from "./cliMuteTransform.mjs";
 import { createPasteHandler } from "./cliPasteTransform.mjs";
 import { notify } from "./utils/notify.mjs";
+import { parseVoiceToggleKey, startVoiceSession } from "./voiceInput.mjs";
 
 const HELP_MESSAGE = [
   "Commands:",
@@ -57,6 +60,7 @@ const HELP_MESSAGE = [
  * @property {boolean} sandbox
  * @property {() => Promise<void>} onStop
  * @property {ClaudeCodePlugin[]} [claudeCodePlugins]
+ * @property {VoiceInputConfig} [voiceInput]
  */
 
 /**
@@ -72,6 +76,7 @@ export function startInteractiveSession({
   sandbox,
   onStop,
   claudeCodePlugins,
+  voiceInput,
 }) {
   /** @type {{ turn: boolean, multiLineBuffer: string[] | null, subagentName: string }} */
   const state = {
@@ -80,6 +85,16 @@ export function startInteractiveSession({
     subagentName: "",
   };
 
+  /**
+   * Active voice input session, or null when not recording.
+   * @type {{ session: VoiceSession, startCursor: number, transcriptLength: number } | null}
+   */
+  let voice = null;
+
+  // Parse the voice toggle key once at startup so misconfiguration fails
+  // loudly instead of silently falling back.
+  const voiceToggle = parseVoiceToggleKey(voiceInput?.toggleKey);
+
   const getCliPrompt = (subagentName = "", flashMessage = "") =>
     [
       "",
@@ -136,7 +151,100 @@ export function startInteractiveSession({
     cli.prompt();
   };
 
+  const stopVoiceSession = async () => {
+    if (!voice) return;
+    const current = voice;
+    voice = null;
+    await current.session.stop();
+    cli.setPrompt(currentCliPrompt);
+    // @ts-expect-error - internal property
+    cli._refreshLine?.();
+  };
+
+  const handleVoiceToggle = () => {
+    // Ignore while the agent is working.
+    if (!state.turn) return;
+
+    if (voice) {
+      stopVoiceSession();
+      return;
+    }
+
+    if (!voiceInput) {
+      cli.setPrompt(
+        getCliPrompt(
+          state.subagentName,
+          styleText(
+            "yellow",
+            `Voice input not configured. Set \`voiceInput\` in your config to enable ${voiceToggle.label}.`,
+          ),
+        ),
+      );
+      cli.prompt(true);
+      return;
+    }
+
+    const startCursor = cli.cursor;
+    const session = startVoiceSession({
+      config: voiceInput,
+      callbacks: {
+        onTranscript: (delta) => {
+          if (!voice) return;
+          const insertAt = voice.startCursor + voice.transcriptLength;
+          // Insert delta at the recording's insertion point. User input is
+          // swallowed while recording, so the buffer around `insertAt` is
+          // stable.
+          const before = cli.line.slice(0, insertAt);
+          const after = cli.line.slice(insertAt);
+          // `line` and `cursor` are declared readonly in the Node typings but
+          // are writable at runtime — the existing code already patches
+          // `_refreshLine` in the same way.
+          const mutableCli = /** @type {{ line: string, cursor: number }} */ (
+            /** @type {unknown} */ (cli)
+          );
+          mutableCli.line = before + delta + after;
+          mutableCli.cursor = insertAt + delta.length;
+          voice.transcriptLength += delta.length;
+          // @ts-expect-error - internal property
+          cli._refreshLine?.();
+        },
+        onError: (err) => {
+          voice = null;
+          cli.setPrompt(
+            getCliPrompt(
+              state.subagentName,
+              styleText("red", `Voice input error: ${err.message}`),
+            ),
+          );
+          cli.prompt(true);
+        },
+        onClose: () => {
+          if (!voice) return;
+          voice = null;
+          cli.setPrompt(currentCliPrompt);
+          // @ts-expect-error - internal property
+          cli._refreshLine?.();
+        },
+      },
+    });
+    voice = { session, startCursor, transcriptLength: 0 };
+    cli.setPrompt(
+      getCliPrompt(
+        state.subagentName,
+        styleText(["red", "bold"], `● REC  (${voiceToggle.label} to stop)`),
+      ),
+    );
+    // @ts-expect-error - internal property
+    cli._refreshLine?.();
+  };
+
   const handleCtrlC = () => {
+    // Stop voice recording first if active.
+    if (voice) {
+      stopVoiceSession();
+      return;
+    }
+
     // Agent turn: pause auto-approve; do not clear input.
     if (!state.turn) {
       agentCommands.pauseAutoApprove();
@@ -192,14 +300,20 @@ export function startInteractiveSession({
   };
 
   // Pre-readline pipeline:
-  //   stdin -> interrupt (Ctrl-C / Ctrl-D) -> paste (bracketed paste) -> readline
+  //   stdin -> interrupt (Ctrl-C / Ctrl-D) -> mute (voice recording) -> paste (bracketed paste) -> readline
   const interrupt = createInterruptTransform({
     onCtrlC: handleCtrlC,
     onCtrlD: handleCtrlD,
+    onVoiceToggle: handleVoiceToggle,
+    voiceToggleByte: voiceToggle.byte,
   });
+  // While a voice session is recording, swallow all stdin bytes other than
+  // Ctrl-C / Ctrl-D / the voice toggle key so transcript insertion stays
+  // consistent.
+  const mute = createMuteTransform({ isMuted: () => voice !== null });
   const paste = createPasteHandler();
 
-  process.stdin.pipe(interrupt).pipe(paste.transform);
+  process.stdin.pipe(interrupt).pipe(mute).pipe(paste.transform);
 
   // Enable bracketed paste mode
   if (process.stdout.isTTY) {

package/src/cliInterruptTransform.mjs

@@ -1,19 +1,31 @@
 import { Transform } from "node:stream";
 
 /**
- * Create a Transform that intercepts Ctrl-C (0x03) and Ctrl-D (0x04). When
- * either byte is seen anywhere in a chunk, the corresponding callback is
- * invoked and the entire chunk is dropped so that downstream consumers (e.g.
+ * Create a Transform that intercepts Ctrl-C (0x03), Ctrl-D (0x04), and an
+ * optional "voice toggle" byte (default Ctrl-O, 0x0f). When one of those
+ * bytes is seen anywhere in a chunk, the corresponding callback is invoked
+ * and the entire chunk is dropped so that downstream consumers (e.g.
  * readline) never observe it. All other input flows through unchanged.
  *
- * If both bytes appear in the same chunk, Ctrl-C is handled first.
+ * Priority when multiple handled bytes appear in the same chunk:
+ * Ctrl-C > Ctrl-D > voice toggle.
  *
  * @param {object} handlers
  * @param {() => void} handlers.onCtrlC - Called when Ctrl-C is detected
  * @param {() => void} handlers.onCtrlD - Called when Ctrl-D is detected
+ * @param {() => void} [handlers.onVoiceToggle]
+ *   Called when the voice toggle byte is detected.
+ * @param {number} [handlers.voiceToggleByte]
+ *   Byte value for the voice toggle key. Defaults to 0x0f (Ctrl-O).
  * @returns {Transform}
  */
-export function createInterruptTransform({ onCtrlC, onCtrlD }) {
+export function createInterruptTransform({
+  onCtrlC,
+  onCtrlD,
+  onVoiceToggle,
+  voiceToggleByte = 0x0f,
+}) {
+  const voiceToggleChar = String.fromCharCode(voiceToggleByte);
   return new Transform({
     transform(chunk, _encoding, callback) {
       const data = chunk.toString("utf8");
@@ -27,6 +39,11 @@ export function createInterruptTransform({ onCtrlC, onCtrlD }) {
         callback();
         return;
       }
+      if (onVoiceToggle && data.includes(voiceToggleChar)) {
+        onVoiceToggle();
+        callback();
+        return;
+      }
       this.push(chunk);
       callback();
     },

package/src/cliMuteTransform.mjs

@@ -0,0 +1,26 @@
+import { Transform } from "node:stream";
+
+/**
+ * Create a Transform that swallows all chunks while `isMuted()` returns true,
+ * and passes them through unchanged while it returns false.
+ *
+ * Intended to sit between `createInterruptTransform` and the paste handler so
+ * that callers can fully silence regular stdin input during special modes
+ * (e.g. while a voice input session is recording) without coupling that
+ * concern to the interrupt-detection logic.
+ *
+ * @param {object} options
+ * @param {() => boolean} options.isMuted
+ *   Called for each incoming chunk; when true the chunk is dropped.
+ * @returns {Transform}
+ */
+export function createMuteTransform({ isMuted }) {
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      if (!isMuted()) {
+        this.push(chunk);
+      }
+      callback();
+    },
+  });
+}

package/src/config.d.ts

@@ -4,6 +4,7 @@ import { AskURLToolOptions } from "./tools/askURL.mjs";
 import { AskWebToolOptions } from "./tools/askWeb.mjs";
 import { ExecCommandSanboxConfig } from "./tools/execCommand";
 import { ClaudeCodePluginRepo } from "./claudeCodePlugin.mjs";
+import { VoiceInputConfig } from "./voiceInput.mjs";
 
 export type AppConfig = {
   model?: string;
@@ -21,6 +22,7 @@ export type AppConfig = {
   };
   mcpServers?: Record<string, MCPServerConfig>;
   notifyCmd?: string;
+  voiceInput?: VoiceInputConfig;
   claudeCodePlugins?: ClaudeCodePluginRepo[];
 };
 

package/src/config.mjs

@@ -98,6 +98,9 @@ export async function loadAppConfig(options = {}) {
         ...(merged.claudeCodePlugins ?? []),
         ...(config.claudeCodePlugins ?? []),
       ],
+      voiceInput: config.voiceInput
+        ? { ...(merged.voiceInput ?? {}), ...config.voiceInput }
+        : merged.voiceInput,
     };
   }
 

package/src/main.mjs

@@ -257,6 +257,7 @@ if (cliArgs.subcommand.type === "install-claude-code-plugins") {
       ...sessionOptions,
       notifyCmd: appConfig.notifyCmd || AGENT_NOTIFY_CMD_DEFAULT,
       claudeCodePlugins: resolvePluginPaths(appConfig.claudeCodePlugins ?? []),
+      voiceInput: appConfig.voiceInput,
     });
   }
 })().catch((err) => {