otoji 0.1.0 → 0.1.43

package/README.md

@@ -1,68 +1,31 @@
-# otoji (音字)
+# otoji
 
-> realtime speech ⇄ text — *音を字に*
+> CLI bridge for **[otoji.org](https://otoji.org)** — wire any terminal's stdio
+> into a voice graph.
 
-`otoji` is a Rust workspace that wires up streaming ASR, LLM-polished transcripts, and TTS behind a single `react-ink`-style terminal UI built on [`ratatui`](https://ratatui.rs).
-
-```text
-mic / file ──► AudioChunk ──► AsrProvider ──► AsrEvent ──► Polisher ──► TUI
-                                                                    └─► transcript.md
-```
-
-## Workspace layout
-
-| Crate | Purpose |
-|---|---|
-| `otoji-core` | Shared types: `AudioChunk`, `AsrEvent`, `Word`, `OtojiError` |
-| `otoji-audio` | Audio sources — `cpal` mic capture (with resampling) and PCM file replay |
-| `otoji-asr` | `AsrProvider` trait + `iflytek_rtasr` (HMAC-SHA1 signa, WebSocket) |
-| `otoji-tts` | `TtsProvider` trait + `iflytek_tts` (HMAC-SHA256 auth, MP3/PCM streaming) |
-| `otoji-polish` | `Polisher` trait + `NoopPolisher` and `AnthropicPolisher` (Claude Haiku 4.5 default) |
-| `otoji-cli` | `otoji` binary — clap subcommands + ratatui TUI |
-
-See [`./docs/`](./docs/README.md) for the architecture rationale and the comparison of RT ASR providers (iFlytek RTASR / CoLi / SenseVoice / Whisper / Deepgram).
-
-## Build
-
-```bash
-cargo build --release
-```
-
-## Usage
+A zero-dependency launcher for the **CLI pipe** node. Text arriving at a pipe
+node in the graph is written to stdout (one line per message); each line you
+type (or pipe in) on stdin is sent into the graph's pipe node(s). It connects to
+the signaling relay over a plain WebSocket — no WebRTC, no native build.
 
 ```bash
-# 1) Live mic → RTASR → polished TUI
-export IFLYTEK_APP_ID=...
-export IFLYTEK_API_KEY=...
-export ANTHROPIC_API_KEY=...   # optional, enables LLM polish layer
-cargo run -p otoji-cli -- listen
-
-# 2) Replay a 16kHz mono PCM file in real time
-cargo run -p otoji-cli -- file 16k_10.pcm
-
-# 3) Synthesize speech via iFlytek TTS
-export IFLYTEK_TTS_API_KEY=...
-export IFLYTEK_TTS_API_SECRET=...
-cargo run -p otoji-cli -- speak "你好，世界" --out hello.mp3
+# Copy the target from the pipe node in the graph (host/room/nodeId):
+npx otoji node otoji.org/keen-gibbon-4a0d/pipe-ab12
+
+# Just a room code targets every pipe node in that room:
+otoji node keen-gibbon-4a0d            # interactive
+otoji node my-room | grep ERROR        # consume transcripts downstream
+some-producer | otoji node my-room     # feed text into the graph
+otoji node my-room -d                  # -d: log activity to stderr
 ```
 
-## TUI
-
-The transcript view shows:
-
-- `[seg_id]` confirmed segments in **white bold** (polished) or **gray** (raw, awaiting polish)
-- The current partial hypothesis as `░ ...` in dark gray italic
-- A header with provider state and counts
-
-Press `q` / `Esc` / `Ctrl-C` to quit.
-
-## Roadmap
+`$OTOJI_ROOM` sets the default target; `$OTOJI_SIGNAL` overrides the signaling
+endpoint (defaults to `wss://<host>/signal`). Requires a global `WebSocket`
+(Node 22+, Bun, or Deno).
 
-- [ ] `otoji-asr/coli.rs` — CoLi ASR via ListenHub
-- [ ] `otoji-asr/sensevoice.rs` — FunASR self-host bridge
-- [ ] `otoji-tts/edge_tts.rs` — Microsoft Edge TTS as a free fallback
-- [ ] `otoji-cli record` — write transcripts to `*.md` next to the source audio
-- [ ] Bench harness (CER / latency / cost) under `crates/otoji-bench`
+For the on-device speech models (ASR/TTS) as Node/Bun bindings, see
+[`@otoji/core`](https://www.npmjs.com/package/@otoji/core). Full project:
+<https://github.com/snomiao/otoji>.
 
 ## License
 

package/otoji-node.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// otoji node — bridge a terminal's stdio to a "CLI pipe" node in an otoji graph.
+//
+//   npx otoji node <host/room/nodeId> [-d]    (also: otoji-node <...>, node cli/otoji-node.mjs <...>)
+//     <host/room/nodeId>  e.g. otoji.org/blue-otter-7x2k/pipe-ab12 (copy it from the
+//                         pipe node in the graph). host and nodeId are optional:
+//                         just a room code targets all pipe nodes in the room.
+//     -d                  debug: log activity to stderr
+//
+// Text arriving at a pipe node in the graph is written to stdout (one line per
+// message); each line read from stdin is sent into the graph's pipe node(s).
+// So you can wire CLI tools into the graph, e.g.:
+//
+//   otoji node my-room | grep foo
+//   some-producer | otoji node my-room
+//   otoji node my-room -d            # interactive, with debug
+//
+// Connects to the signaling relay over a plain WebSocket (no WebRTC needed).
+// Requires a global WebSocket (Node 22+, Bun, or Deno).
+
+import { createInterface } from "node:readline";
+
+const args = process.argv.slice(2);
+const debug = args.includes("-d") || args.includes("--debug");
+let pos = args.filter((a) => !a.startsWith("-"));
+if (pos[0] === "node") pos = pos.slice(1); // allow `otoji node <...>` (leading subcommand)
+const target = (pos[0] || process.env.OTOJI_ROOM || "").trim();
+
+// Parse <host/room/nodeId> | <room/nodeId> | <room> | full URL.
+const toks = target.replace(/^https?:\/\//, "").split("/").filter(Boolean);
+let host = "otoji.org";
+let parts = toks;
+// First token is a host if it looks like one (has a dot, a :port, or is localhost).
+if (toks[0] && (/[.:]/.test(toks[0]) || toks[0] === "localhost")) { host = toks[0]; parts = toks.slice(1); }
+const room = parts[0];
+const nodeId = parts[1] || null; // null = all pipe nodes in the room
+const proto = /^(localhost|127\.|0\.0\.0\.0)/.test(host) ? "ws" : "wss"; // local dev = no TLS
+const signal = (process.env.OTOJI_SIGNAL || `${proto}://${host}/signal`).replace(/\/+$/, "");
+const log = (...a) => debug && console.error("[otoji node]", ...a);
+
+if (!room) {
+  console.error("usage: otoji node <host/room/nodeId> [-d]   (or set $OTOJI_ROOM)");
+  process.exit(2);
+}
+if (typeof WebSocket === "undefined") {
+  console.error("otoji node needs a global WebSocket — run with Node 22+, Bun, or Deno.");
+  process.exit(1);
+}
+
+const deviceId = "cli-" + Math.random().toString(36).slice(2, 10);
+const url = `${signal}/${encodeURIComponent(room)}?name=cli&deviceId=${deviceId}&role=general&hasMic=false`;
+log("connecting", url);
+
+let ws;
+let ping;
+let stopped = false;
+const outbox = []; // stdin lines awaiting an open socket (so early/reconnect input isn't lost)
+
+function flush() {
+  while (ws && ws.readyState === 1 /* OPEN */ && outbox.length) {
+    const text = outbox.shift();
+    try { ws.send(JSON.stringify({ type: "pipe", node: nodeId || "*", text, src: "cli" })); } catch { outbox.unshift(text); break; }
+  }
+}
+
+function connect() {
+  ws = new WebSocket(url);
+
+  ws.onopen = () => {
+    log("connected to room", room);
+    ping = setInterval(() => { try { ws.send(JSON.stringify({ type: "ping" })); } catch {} }, 10000);
+    flush(); // send anything queued before the socket opened
+  };
+
+  ws.onmessage = (ev) => {
+    let m;
+    try { m = JSON.parse(typeof ev.data === "string" ? ev.data : ""); } catch { return; }
+    // Text from a graph pipe node -> stdout (only our bound node, if one was given).
+    if (m && m.type === "pipe" && m.src === "node" && typeof m.text === "string") {
+      if (nodeId && m.node !== nodeId) return;
+      process.stdout.write(m.text + "\n");
+      log("graph →", m.text);
+    }
+  };
+
+  ws.onclose = () => {
+    clearInterval(ping);
+    if (stopped) return;
+    log("disconnected — reconnecting in 1s");
+    setTimeout(connect, 1000); // simple reconnect
+  };
+  ws.onerror = (e) => log("ws error", e?.message ?? e);
+}
+
+connect();
+
+// stdin lines -> graph pipe node(s). node "*" = all pipe nodes in the room. The
+// line content is relayed as-is (no trimming); queued until the socket is open.
+const rl = createInterface({ input: process.stdin, terminal: false });
+rl.on("line", (line) => {
+  outbox.push(line);
+  log("→ graph", line);
+  flush();
+});
+rl.on("close", () => { stopped = true; try { ws?.close(); } catch {} process.exit(0); });

package/package.json

@@ -1,48 +1,37 @@
 {
   "name": "otoji",
-  "version": "0.1.0",
-  "description": "音字 — realtime speech ⇄ text. Node/Bun bindings for the otoji Rust crate (SenseVoice ASR + Anthropic polish).",
+  "version": "0.1.43",
+  "description": "otoji CLI — bridge a terminal's stdio into an otoji voice graph at otoji.org. Zero-dep launcher: `npx otoji node <room>`.",
   "license": "MIT",
+  "author": "snomiao <snomiao@gmail.com>",
+  "homepage": "https://otoji.org",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/snomiao/otoji.git"
+    "url": "git+https://github.com/snomiao/otoji.git",
+    "directory": "cli"
   },
-  "main": "index.js",
-  "types": "index.d.ts",
-  "files": [
-    "index.js",
-    "index.d.ts",
-    "*.node"
-  ],
-  "napi": {
-    "name": "otoji",
-    "triples": {
-      "defaults": true,
-      "additional": [
-        "aarch64-apple-darwin",
-        "x86_64-apple-darwin",
-        "x86_64-unknown-linux-gnu",
-        "aarch64-unknown-linux-gnu"
-      ]
-    }
+  "bugs": {
+    "url": "https://github.com/snomiao/otoji/issues"
   },
-  "scripts": {
-    "build": "napi build --platform --release --features node --cargo-flags=--lib",
-    "build:debug": "napi build --platform --features node --cargo-flags=--lib",
-    "prepublishOnly": "napi prepublish -t npm",
-    "version": "napi version"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "^2.18.4"
+  "keywords": [
+    "otoji",
+    "cli",
+    "stdio",
+    "pipe",
+    "voice",
+    "transcript",
+    "speech-to-text",
+    "webrtc"
+  ],
+  "type": "module",
+  "bin": {
+    "otoji": "otoji-node.mjs"
   },
+  "files": [
+    "otoji-node.mjs",
+    "README.md"
+  ],
   "engines": {
-    "node": ">= 18"
-  },
-  "optionalDependencies": {
-    "otoji-win32-x64-msvc": "0.1.0",
-    "otoji-darwin-x64": "0.1.0",
-    "otoji-linux-x64-gnu": "0.1.0",
-    "otoji-darwin-arm64": "0.1.0",
-    "otoji-linux-arm64-gnu": "0.1.0"
+    "node": ">=22"
   }
-}
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Snowstar Miao
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.d.ts

@@ -1,24 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/* auto-generated by NAPI-RS */
-
-export interface PolishOptions {
-  apiKey: string
-  model?: string
-  raw: string
-  prev?: string
-}
-export declare function polishText(opts: PolishOptions): Promise<string>
-export interface TranscribeOptions {
-  /** Directory containing `model.int8.onnx` and `tokens.txt`. */
-  modelDir: string
-  /**
-   * 16-bit-mono PCM samples as f32 in [-1.0, 1.0]. Sample rate is fixed
-   * to 16 kHz to match the SenseVoice model.
-   */
-  samples: Float32Array
-  /** "auto" | "zh" | "en" | "ja" | "ko" | "yue". */
-  language?: string
-}
-export declare function transcribePcm(opts: TranscribeOptions): Promise<unknown>

package/index.js

@@ -1,316 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-
-/* auto-generated by NAPI-RS */
-
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
-
-const { platform, arch } = process
-
-let nativeBinding = null
-let localFileExisted = false
-let loadError = null
-
-function isMusl() {
-  // For Node 10
-  if (!process.report || typeof process.report.getReport !== 'function') {
-    try {
-      const lddPath = require('child_process').execSync('which ldd').toString().trim()
-      return readFileSync(lddPath, 'utf8').includes('musl')
-    } catch (e) {
-      return true
-    }
-  } else {
-    const { glibcVersionRuntime } = process.report.getReport().header
-    return !glibcVersionRuntime
-  }
-}
-
-switch (platform) {
-  case 'android':
-    switch (arch) {
-      case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'otoji.android-arm64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.android-arm64.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-android-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'otoji.android-arm-eabi.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.android-arm-eabi.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Android ${arch}`)
-    }
-    break
-  case 'win32':
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(
-          join(__dirname, 'otoji.win32-x64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.win32-x64-msvc.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-win32-x64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'ia32':
-        localFileExisted = existsSync(
-          join(__dirname, 'otoji.win32-ia32-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.win32-ia32-msvc.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-win32-ia32-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'otoji.win32-arm64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.win32-arm64-msvc.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-win32-arm64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`)
-    }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'otoji.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./otoji.darwin-universal.node')
-      } else {
-        nativeBinding = require('@snomiao/otoji-darwin-universal')
-      }
-      break
-    } catch {}
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'otoji.darwin-x64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.darwin-x64.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-darwin-x64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'otoji.darwin-arm64.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.darwin-arm64.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-darwin-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`)
-    }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
-    }
-    localFileExisted = existsSync(join(__dirname, 'otoji.freebsd-x64.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./otoji.freebsd-x64.node')
-      } else {
-        nativeBinding = require('@snomiao/otoji-freebsd-x64')
-      }
-    } catch (e) {
-      loadError = e
-    }
-    break
-  case 'linux':
-    switch (arch) {
-      case 'x64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-x64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-x64-musl.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-x64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-x64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-x64-gnu.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-x64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-arm64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-arm64-musl.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-arm64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-arm64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-arm64-gnu.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-arm64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-arm-musleabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-arm-musleabihf.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-arm-musleabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-arm-gnueabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-arm-gnueabihf.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-arm-gnueabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'riscv64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-riscv64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-riscv64-musl.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-riscv64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'otoji.linux-riscv64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./otoji.linux-riscv64-gnu.node')
-            } else {
-              nativeBinding = require('@snomiao/otoji-linux-riscv64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 's390x':
-        localFileExisted = existsSync(
-          join(__dirname, 'otoji.linux-s390x-gnu.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./otoji.linux-s390x-gnu.node')
-          } else {
-            nativeBinding = require('@snomiao/otoji-linux-s390x-gnu')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`)
-    }
-    break
-  default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
-}
-
-if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
-  }
-  throw new Error(`Failed to load native binding`)
-}
-
-const { polishText, transcribePcm } = nativeBinding
-
-module.exports.polishText = polishText
-module.exports.transcribePcm = transcribePcm