@acpfx/mic-file 0.2.2 → 0.2.4

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024-2026 acpfx contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# @acpfx/mic-file
+
+Plays back a WAV file as if it were microphone input. Useful for testing and development without a live microphone.
+
+## Usage
+
+This package is a pipeline node for [@acpfx/cli](../orchestrator/README.md). See the CLI package for installation and usage.
+
+## Manifest
+
+- **Consumes:** `control.interrupt`
+- **Emits:** `audio.chunk`, `audio.level`, `lifecycle.ready`, `lifecycle.done`
+
+## Settings
+
+| Name | Type | Default | Description |
+|------|------|---------|-------------|
+| `path` | string | **(required)** | Path to WAV file to play back |
+| `realtime` | boolean | | Play back at real-time speed |
+| `chunkMs` | number | | Chunk duration in milliseconds |
+
+## Pipeline Example
+
+```yaml
+nodes:
+  mic:
+    use: "@acpfx/mic-file"
+    settings: { path: ./test-audio.wav, realtime: true }
+    outputs: [stt]
+```
+
+## License
+
+ISC

package/dist/index.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { resolve } from "node:path";
+
+// ../node-sdk/src/index.ts
+import { createInterface } from "node:readline";
+
+// ../core/src/config.ts
+import { parse as parseYaml } from "yaml";
+
+// ../core/src/manifest.ts
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { z as z2 } from "zod";
+
+// ../core/src/acpfx-flags.ts
+import { z } from "zod";
+var SetupCheckResponseSchema = z.object({
+  needed: z.boolean(),
+  description: z.string().optional()
+});
+var SetupProgressSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("progress"),
+    message: z.string(),
+    pct: z.number().optional()
+  }),
+  z.object({ type: z.literal("complete"), message: z.string() }),
+  z.object({ type: z.literal("error"), message: z.string() })
+]);
+var UnsupportedFlagResponseSchema = z.object({
+  unsupported: z.boolean(),
+  flag: z.string()
+});
+
+// ../core/src/manifest.ts
+var ArgumentTypeSchema = z2.enum(["string", "number", "boolean"]);
+var ManifestArgumentSchema = z2.object({
+  type: ArgumentTypeSchema,
+  default: z2.unknown().optional(),
+  description: z2.string().optional(),
+  required: z2.boolean().optional(),
+  enum: z2.array(z2.unknown()).optional()
+});
+var ManifestEnvFieldSchema = z2.object({
+  required: z2.boolean().optional(),
+  description: z2.string().optional()
+});
+var NodeManifestSchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional(),
+  consumes: z2.array(z2.string()),
+  emits: z2.array(z2.string()),
+  arguments: z2.record(z2.string(), ManifestArgumentSchema).optional(),
+  additional_arguments: z2.boolean().optional(),
+  env: z2.record(z2.string(), ManifestEnvFieldSchema).optional()
+});
+function handleAcpfxFlags(manifestPath) {
+  const acpfxFlag = process.argv.find((a) => a.startsWith("--acpfx-"));
+  const legacyManifest = process.argv.includes("--manifest");
+  if (!acpfxFlag && !legacyManifest) return;
+  const flag = acpfxFlag ?? "--acpfx-manifest";
+  switch (flag) {
+    case "--acpfx-manifest":
+      printManifest(manifestPath);
+      break;
+    case "--acpfx-setup-check":
+      process.stdout.write(JSON.stringify({ needed: false }) + "\n");
+      process.exit(0);
+      break;
+    default:
+      process.stdout.write(
+        JSON.stringify({ unsupported: true, flag }) + "\n"
+      );
+      process.exit(0);
+  }
+}
+function handleManifestFlag(manifestPath) {
+  handleAcpfxFlags(manifestPath);
+}
+function printManifest(manifestPath) {
+  if (!manifestPath) {
+    const script = process.argv[1];
+    const scriptDir = dirname(script);
+    const scriptBase = script.replace(/\.[^.]+$/, "");
+    const colocated = `${scriptBase}.manifest.json`;
+    try {
+      readFileSync(colocated);
+      manifestPath = colocated;
+    } catch {
+      manifestPath = join(scriptDir, "manifest.json");
+    }
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf8");
+    process.stdout.write(content.trim() + "\n");
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`Failed to read manifest: ${err}
+`);
+    process.exit(1);
+  }
+}
+
+// ../node-sdk/src/index.ts
+var NODE_NAME = process.env.ACPFX_NODE_NAME ?? "unknown";
+function emit(event) {
+  process.stdout.write(JSON.stringify(event) + "\n");
+}
+function log(level, message) {
+  emit({ type: "log", level, component: NODE_NAME, message });
+}
+log.info = (message) => log("info", message);
+log.warn = (message) => log("warn", message);
+log.error = (message) => log("error", message);
+log.debug = (message) => log("debug", message);
+function onEvent(handler) {
+  const rl2 = createInterface({ input: process.stdin });
+  rl2.on("line", (line) => {
+    if (!line.trim()) return;
+    try {
+      const event = JSON.parse(line);
+      handler(event);
+    } catch {
+    }
+  });
+  return rl2;
+}
+
+// src/index.ts
+handleManifestFlag();
+var settings = JSON.parse(
+  process.env.ACPFX_SETTINGS || "{}"
+);
+if (!settings.path) {
+  log.error("settings.path is required");
+  process.exit(1);
+}
+var CHUNK_MS = settings.chunkMs ?? 100;
+var REALTIME = settings.realtime ?? true;
+var BYTES_PER_SAMPLE = 2;
+var TRACK_ID = "mic";
+var interrupted = false;
+var rl = onEvent((event) => {
+  if (event.type === "control.interrupt") {
+    interrupted = true;
+  }
+});
+rl.on("close", () => {
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  interrupted = true;
+  process.exit(0);
+});
+function parseWavHeader(data) {
+  let offset = 12;
+  let sampleRate = 16e3;
+  let channels = 1;
+  let bitsPerSample = 16;
+  let dataOffset = 44;
+  while (offset + 8 <= data.length) {
+    const chunkId = data.toString("ascii", offset, offset + 4);
+    const chunkSize = data.readUInt32LE(offset + 4);
+    if (chunkId === "fmt ") {
+      channels = data.readUInt16LE(offset + 10);
+      sampleRate = data.readUInt32LE(offset + 12);
+      bitsPerSample = data.readUInt16LE(offset + 22);
+    } else if (chunkId === "data") {
+      dataOffset = offset + 8;
+      break;
+    }
+    offset += 8 + chunkSize;
+    if (chunkSize % 2 !== 0) offset += 1;
+  }
+  return { sampleRate, channels, bitsPerSample, dataOffset };
+}
+function computeLevel(pcm) {
+  const samples = pcm.length / BYTES_PER_SAMPLE;
+  if (samples === 0) return { rms: 0, peak: 0, dbfs: -Infinity };
+  let sumSq = 0;
+  let peak = 0;
+  for (let i = 0; i < pcm.length; i += BYTES_PER_SAMPLE) {
+    const sample = pcm.readInt16LE(i);
+    sumSq += sample * sample;
+    const abs = Math.abs(sample);
+    if (abs > peak) peak = abs;
+  }
+  const rms = Math.sqrt(sumSq / samples);
+  const dbfs = rms > 0 ? 20 * Math.log10(rms / 32768) : -Infinity;
+  return { rms: Math.round(rms), peak, dbfs: Math.round(dbfs * 10) / 10 };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function main() {
+  const filePath = resolve(settings.path);
+  const fileData = readFileSync2(filePath);
+  let sampleRate = 16e3;
+  let channels = 1;
+  let pcmData;
+  if (fileData.length > 44 && fileData.toString("ascii", 0, 4) === "RIFF" && fileData.toString("ascii", 8, 12) === "WAVE") {
+    const wavInfo = parseWavHeader(fileData);
+    sampleRate = wavInfo.sampleRate;
+    channels = wavInfo.channels;
+    pcmData = fileData.subarray(wavInfo.dataOffset);
+  } else {
+    pcmData = fileData;
+  }
+  const bytesPerFrame = channels * BYTES_PER_SAMPLE;
+  const chunkSize = Math.floor(sampleRate * channels * BYTES_PER_SAMPLE * CHUNK_MS / 1e3);
+  emit({ type: "lifecycle.ready", component: "mic-file" });
+  let offset = 0;
+  while (offset < pcmData.length && !interrupted) {
+    const end = Math.min(offset + chunkSize, pcmData.length);
+    const chunk = pcmData.subarray(offset, end);
+    const durationMs = Math.round(chunk.length / (sampleRate * bytesPerFrame) * 1e3);
+    emit({
+      type: "audio.chunk",
+      trackId: TRACK_ID,
+      format: "pcm_s16le",
+      sampleRate,
+      channels,
+      data: Buffer.from(chunk).toString("base64"),
+      durationMs
+    });
+    const level = computeLevel(chunk);
+    emit({
+      type: "audio.level",
+      trackId: TRACK_ID,
+      rms: level.rms,
+      peak: level.peak,
+      dbfs: level.dbfs
+    });
+    offset = end;
+    if (REALTIME && offset < pcmData.length) {
+      await sleep(durationMs);
+    }
+  }
+  emit({ type: "lifecycle.done", component: "mic-file" });
+  process.exit(0);
+}
+main().catch((err) => {
+  log.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});

package/dist/manifest.json

@@ -0,0 +1 @@
+{"name":"mic-file","description":"Plays back a WAV file as if it were mic input","consumes":["control.interrupt"],"emits":["audio.chunk","audio.level","lifecycle.ready","lifecycle.done"],"arguments":{"path":{"type":"string","required":true,"description":"Path to WAV file to play back"},"realtime":{"type":"boolean","description":"Whether to play back at real-time speed"},"chunkMs":{"type":"number","description":"Chunk duration in milliseconds"}}}

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@acpfx/mic-file",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "bin": {
     "acpfx-mic-file": "./dist/index.js"
   },
   "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "manifest.yaml"
+  ],
   "dependencies": {
     "@acpfx/core": "0.4.0",
     "@acpfx/node-sdk": "0.3.0"
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external"
+    "build": "esbuild src/index.ts --bundle --banner:js=\"#!/usr/bin/env node\" --platform=node --format=esm --outfile=dist/index.js --packages=external && node ../../scripts/copy-manifest.js"
   }
 }

package/CHANGELOG.md

@@ -1,38 +0,0 @@
-# @acpfx/mic-file
-
-## 0.2.2
-
-### Patch Changes
-
-- Updated dependencies [0e6838e]
-  - @acpfx/core@0.4.0
-  - @acpfx/node-sdk@0.3.0
-
-## 0.2.1
-
-### Patch Changes
-
-- Updated dependencies [79c6694]
-- Updated dependencies [a0320a1]
-  - @acpfx/core@0.3.0
-  - @acpfx/node-sdk@0.2.1
-
-## 0.2.0
-
-### Minor Changes
-
-- d757640: Initial release: type-safe contracts, Rust orchestrator, manifest-driven event filtering
-
-  - Rust schema crate as canonical event type source of truth with codegen to TypeScript + Zod
-  - Node manifests (manifest.yaml) declaring consumes/emits contracts
-  - Orchestrator event filtering: nodes only receive declared events
-  - Rust orchestrator with ratatui TUI (--ui flag)
-  - node-sdk with structured logging helpers
-  - CI/CD with GitHub Actions and changesets
-  - Platform-specific npm packages for Rust binaries (esbuild-style distribution)
-
-### Patch Changes
-
-- Updated dependencies [d757640]
-  - @acpfx/core@0.2.0
-  - @acpfx/node-sdk@0.2.0

package/src/index.ts

@@ -1,189 +0,0 @@
-/**
- * mic-file node — reads a WAV file and emits audio.chunk events with real-time pacing.
- * Also emits audio.level events with computed RMS energy.
- *
- * Settings (via ACPFX_SETTINGS):
- *   path: string       — path to WAV file
- *   realtime?: boolean  — pace at real-time rate (default: true)
- *   chunkMs?: number    — chunk duration in ms (default: 100)
- */
-
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { emit, log, onEvent, handleManifestFlag } from "@acpfx/node-sdk";
-
-handleManifestFlag();
-
-type Settings = {
-  path: string;
-  realtime?: boolean;
-  chunkMs?: number;
-};
-
-const settings: Settings = JSON.parse(
-  process.env.ACPFX_SETTINGS || "{}",
-);
-
-if (!settings.path) {
-  log.error("settings.path is required");
-  process.exit(1);
-}
-
-const CHUNK_MS = settings.chunkMs ?? 100;
-const REALTIME = settings.realtime ?? true;
-const BYTES_PER_SAMPLE = 2; // 16-bit PCM
-const TRACK_ID = "mic";
-
-let interrupted = false;
-
-// Handle control.interrupt from stdin
-const rl = onEvent((event) => {
-  if (event.type === "control.interrupt") {
-    interrupted = true;
-  }
-});
-
-rl.on("close", () => {
-  process.exit(0);
-});
-
-process.on("SIGTERM", () => {
-  interrupted = true;
-  process.exit(0);
-});
-
-// --- WAV parsing ---
-
-type WavInfo = {
-  sampleRate: number;
-  channels: number;
-  bitsPerSample: number;
-  dataOffset: number;
-};
-
-function parseWavHeader(data: Buffer): WavInfo {
-  let offset = 12;
-  let sampleRate = 16000;
-  let channels = 1;
-  let bitsPerSample = 16;
-  let dataOffset = 44;
-
-  while (offset + 8 <= data.length) {
-    const chunkId = data.toString("ascii", offset, offset + 4);
-    const chunkSize = data.readUInt32LE(offset + 4);
-
-    if (chunkId === "fmt ") {
-      channels = data.readUInt16LE(offset + 10);
-      sampleRate = data.readUInt32LE(offset + 12);
-      bitsPerSample = data.readUInt16LE(offset + 22);
-    } else if (chunkId === "data") {
-      dataOffset = offset + 8;
-      break;
-    }
-
-    offset += 8 + chunkSize;
-    if (chunkSize % 2 !== 0) offset += 1;
-  }
-
-  return { sampleRate, channels, bitsPerSample, dataOffset };
-}
-
-// --- Audio level computation ---
-
-function computeLevel(pcm: Buffer): { rms: number; peak: number; dbfs: number } {
-  const samples = pcm.length / BYTES_PER_SAMPLE;
-  if (samples === 0) return { rms: 0, peak: 0, dbfs: -Infinity };
-
-  let sumSq = 0;
-  let peak = 0;
-  for (let i = 0; i < pcm.length; i += BYTES_PER_SAMPLE) {
-    const sample = pcm.readInt16LE(i);
-    sumSq += sample * sample;
-    const abs = Math.abs(sample);
-    if (abs > peak) peak = abs;
-  }
-
-  const rms = Math.sqrt(sumSq / samples);
-  const dbfs = rms > 0 ? 20 * Math.log10(rms / 32768) : -Infinity;
-
-  return { rms: Math.round(rms), peak, dbfs: Math.round(dbfs * 10) / 10 };
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// --- Main ---
-
-async function main() {
-  const filePath = resolve(settings.path);
-  const fileData = readFileSync(filePath);
-
-  let sampleRate = 16000;
-  let channels = 1;
-  let pcmData: Buffer;
-
-  // Parse WAV header if present
-  if (
-    fileData.length > 44 &&
-    fileData.toString("ascii", 0, 4) === "RIFF" &&
-    fileData.toString("ascii", 8, 12) === "WAVE"
-  ) {
-    const wavInfo = parseWavHeader(fileData);
-    sampleRate = wavInfo.sampleRate;
-    channels = wavInfo.channels;
-    pcmData = fileData.subarray(wavInfo.dataOffset);
-  } else {
-    pcmData = fileData;
-  }
-
-  const bytesPerFrame = channels * BYTES_PER_SAMPLE;
-  const chunkSize = Math.floor((sampleRate * channels * BYTES_PER_SAMPLE * CHUNK_MS) / 1000);
-
-  // Emit lifecycle.ready
-  emit({ type: "lifecycle.ready", component: "mic-file" });
-
-  let offset = 0;
-  while (offset < pcmData.length && !interrupted) {
-    const end = Math.min(offset + chunkSize, pcmData.length);
-    const chunk = pcmData.subarray(offset, end);
-    const durationMs = Math.round((chunk.length / (sampleRate * bytesPerFrame)) * 1000);
-
-    // Emit audio.chunk
-    emit({
-      type: "audio.chunk",
-      trackId: TRACK_ID,
-      format: "pcm_s16le",
-      sampleRate,
-      channels,
-      data: Buffer.from(chunk).toString("base64"),
-      durationMs,
-    });
-
-    // Emit audio.level
-    const level = computeLevel(chunk);
-    emit({
-      type: "audio.level",
-      trackId: TRACK_ID,
-      rms: level.rms,
-      peak: level.peak,
-      dbfs: level.dbfs,
-    });
-
-    offset = end;
-
-    // Pace at real-time rate
-    if (REALTIME && offset < pcmData.length) {
-      await sleep(durationMs);
-    }
-  }
-
-  // Emit lifecycle.done
-  emit({ type: "lifecycle.done", component: "mic-file" });
-  process.exit(0);
-}
-
-main().catch((err) => {
-  log.error(`Fatal: ${err.message}`);
-  process.exit(1);
-});