@neuralmux/omp-superwhisper 1.0.1

package/extensions/host.ts

@@ -0,0 +1,237 @@
+/**
+ * HostOps — abstraction over host-specific Superwhisper operations.
+ *
+ * Two implementations:
+ *   DirectHostOps  – runs on macOS, talks to Superwhisper via filesystem + open
+ *   BridgeHostOps  – runs inside a container, proxies to a host daemon via HTTP
+ *
+ * Selection is automatic:
+ *   - If SUPERWHISPER_BRIDGE_URL is set → BridgeHostOps
+ *   - Otherwise → DirectHostOps
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, unlinkSync } from "node:fs"
+import { $ } from "bun"
+import type { InboxPayload } from "./inbox"
+import { deliverAgentPayload } from "./inbox"
+import { waitForResponse, type WaitResult } from "./poll"
+import { MESSAGE_DIR } from "./constants"
+
+// ---------------------------------------------------------------------------
+// Public interface
+// ---------------------------------------------------------------------------
+
+export interface HostOps {
+  /** Detect the Superwhisper deeplink scheme and whether the app is running. */
+  detect(): Promise<{ scheme: string; running: boolean }>
+
+  /** Deliver an inbox payload (update or dismiss). */
+  deliverPayload(payload: InboxPayload, scheme: string): Promise<boolean>
+
+  /** Write per-session message file. */
+  writeMessage(sessionId: string, content: string): Promise<void>
+
+  /** Read per-session message file; null if missing. */
+  readMessage(sessionId: string): Promise<string | null>
+
+  /** Remove per-session message file. */
+  deleteMessage(sessionId: string): Promise<void>
+
+  /**
+   * Wait for Superwhisper to write a response file.
+   * Returns { kind: "response", text } | { kind: "empty" } |
+   *         { kind: "timeout" } | { kind: "cancelled" }
+   */
+  waitForResponse(sessionId: string, signal?: AbortSignal): Promise<WaitResult>
+
+  /** Remove per-session response file. */
+  deleteResponse(sessionId: string): Promise<void>
+
+  /** Is this session disabled for Superwhisper notifications? */
+  isSessionDisabled(sessionId: string): Promise<boolean>
+
+  /** Enable or disable Superwhisper for this session. */
+  setSessionDisabled(sessionId: string, disabled: boolean): Promise<void>
+}
+
+// ---------------------------------------------------------------------------
+// Direct (on-host) implementation
+// ---------------------------------------------------------------------------
+
+class DirectHostOps implements HostOps {
+  private scheme: string | null = null
+
+  async detect(): Promise<{ scheme: string; running: boolean }> {
+    const envScheme = process.env.SUPERWHISPER_SCHEME
+    if (envScheme) {
+      this.scheme = envScheme
+    } else if (!this.scheme) {
+      try {
+        await $`pgrep -f DerivedData.*superwhisper.app`.quiet()
+        this.scheme = "superwhisper-debug"
+      } catch {
+        this.scheme = "superwhisper"
+      }
+    }
+    const running = await this.checkRunning()
+    return { scheme: this.scheme, running }
+  }
+
+  private async checkRunning(): Promise<boolean> {
+    try {
+      await $`pgrep -x superwhisper`.quiet()
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  async deliverPayload(payload: InboxPayload, scheme: string): Promise<boolean> {
+    return deliverAgentPayload(payload, scheme)
+  }
+
+  async writeMessage(sessionId: string, content: string): Promise<void> {
+    mkdirSync(MESSAGE_DIR, { recursive: true })
+    writeFileSync(`${MESSAGE_DIR}/${sessionId}-message.txt`, content)
+  }
+
+  async readMessage(sessionId: string): Promise<string | null> {
+    try {
+      return readFileSync(`${MESSAGE_DIR}/${sessionId}-message.txt`, "utf8")
+    } catch {
+      return null
+    }
+  }
+
+  async deleteMessage(sessionId: string): Promise<void> {
+    try { unlinkSync(`${MESSAGE_DIR}/${sessionId}-message.txt`) } catch {}
+  }
+
+  async waitForResponse(sessionId: string, signal?: AbortSignal): Promise<WaitResult> {
+    const path = `${MESSAGE_DIR}/${sessionId}-response.txt`
+    return waitForResponse(path, { signal })
+  }
+
+  async deleteResponse(sessionId: string): Promise<void> {
+    try { unlinkSync(`${MESSAGE_DIR}/${sessionId}-response.txt`) } catch {}
+  }
+
+  async isSessionDisabled(sessionId: string): Promise<boolean> {
+    return existsSync(`${MESSAGE_DIR}/disabled-${sessionId}`)
+  }
+
+  async setSessionDisabled(sessionId: string, disabled: boolean): Promise<void> {
+    mkdirSync(MESSAGE_DIR, { recursive: true })
+    const flag = `${MESSAGE_DIR}/disabled-${sessionId}`
+    if (disabled) {
+      writeFileSync(flag, "")
+    } else {
+      try { unlinkSync(flag) } catch {}
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Bridge (container → host daemon) implementation
+// ---------------------------------------------------------------------------
+
+class BridgeHostOps implements HostOps {
+  private url: string
+  private cachedScheme: string | null = null
+
+  constructor(bridgeUrl: string) {
+    this.url = bridgeUrl.replace(/\/+$/, "")
+  }
+
+  async detect(): Promise<{ scheme: string; running: boolean }> {
+    const res = await fetch(`${this.url}/health`)
+    const data = await res.json() as { scheme: string; running: boolean }
+    this.cachedScheme = data.scheme
+    return { scheme: data.scheme, running: data.running }
+  }
+
+  async deliverPayload(payload: InboxPayload, _scheme: string): Promise<boolean> {
+    const res = await fetch(`${this.url}/inbox`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload),
+    })
+    const data = await res.json() as { ok: boolean }
+    return data.ok === true
+  }
+
+  async writeMessage(sessionId: string, content: string): Promise<void> {
+    await fetch(`${this.url}/session/${encodeURIComponent(sessionId)}/message`, {
+      method: "PUT",
+      headers: { "content-type": "text/plain" },
+      body: content,
+    })
+  }
+
+  async readMessage(sessionId: string): Promise<string | null> {
+    const res = await fetch(
+      `${this.url}/session/${encodeURIComponent(sessionId)}/message`,
+    )
+    return res.status === 200 ? await res.text() : null
+  }
+
+  async deleteMessage(sessionId: string): Promise<void> {
+    await fetch(`${this.url}/session/${encodeURIComponent(sessionId)}/message`, {
+      method: "DELETE",
+    })
+  }
+
+  async waitForResponse(sessionId: string, signal?: AbortSignal): Promise<WaitResult> {
+    const res = await fetch(
+      `${this.url}/session/${encodeURIComponent(sessionId)}/response?timeout=1800000`,
+      { signal },
+    )
+    return (await res.json()) as WaitResult
+  }
+
+  async deleteResponse(sessionId: string): Promise<void> {
+    await fetch(`${this.url}/session/${encodeURIComponent(sessionId)}/response`, {
+      method: "DELETE",
+    })
+  }
+
+  async isSessionDisabled(sessionId: string): Promise<boolean> {
+    const res = await fetch(
+      `${this.url}/session/${encodeURIComponent(sessionId)}/disabled`,
+    )
+    const data = await res.json() as { disabled: boolean }
+    return data.disabled === true
+  }
+
+  async setSessionDisabled(sessionId: string, disabled: boolean): Promise<void> {
+    await fetch(
+      `${this.url}/session/${encodeURIComponent(sessionId)}/disabled`,
+      { method: disabled ? "PUT" : "DELETE" },
+    )
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+let _hostOps: HostOps | null = null
+
+export function createHostOps(): HostOps {
+  const bridgeUrl = process.env.SUPERWHISPER_BRIDGE_URL
+  if (bridgeUrl) {
+    return new BridgeHostOps(bridgeUrl)
+  }
+  return new DirectHostOps()
+}
+
+/** Singleton accessor — creates on first call, returns cached thereafter. */
+export function getHostOps(): HostOps {
+  if (!_hostOps) _hostOps = createHostOps()
+  return _hostOps
+}
+
+/** Reset singleton (useful for testing). */
+export function __resetHostOpsForTest(): void {
+  _hostOps = null
+}

package/extensions/inbox.ts

@@ -0,0 +1,83 @@
+import { mkdirSync, writeFileSync, renameSync, unlinkSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { $ } from "bun"
+
+export interface InboxPayload {
+  kind: "update" | "dismiss"
+  sessionId?: string
+  requestId?: string
+  agent?: string
+  status?: string
+  summary?: string
+  message?: string
+  messageFile?: string
+  responseFile?: string
+  cwd?: string
+  project?: string
+  branch?: string
+  title?: string
+  hookPid?: number
+}
+
+let INBOX_DIR = join(
+  homedir(),
+  "Library/Application Support/superwhisper/agent/inbox",
+)
+
+export function __setInboxDirForTest(dir: string): void {
+  INBOX_DIR = dir
+}
+
+export function writeInboxPayload(payload: InboxPayload): boolean {
+  try {
+    mkdirSync(INBOX_DIR, { recursive: true })
+  } catch {
+    return false
+  }
+
+  const id = crypto.randomUUID()
+  const tmpPath = join(INBOX_DIR, `${id}.json.tmp`)
+  const finalPath = join(INBOX_DIR, `${id}.json`)
+
+  try {
+    writeFileSync(tmpPath, JSON.stringify(payload))
+    renameSync(tmpPath, finalPath)
+    return true
+  } catch {
+    try {
+      unlinkSync(tmpPath)
+    } catch {}
+    return false
+  }
+}
+
+export async function isSuperwhisperRunning(): Promise<boolean> {
+  try {
+    await $`pgrep -x superwhisper`.quiet()
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function fireAgentWake(scheme: string): Promise<void> {
+  const url = `${scheme}://agent-wake`
+  try {
+    await $`open ${url}`.quiet()
+  } catch {
+    // wake is best-effort
+  }
+}
+
+export async function deliverAgentPayload(
+  payload: InboxPayload,
+  scheme: string,
+): Promise<boolean> {
+  const wrote = writeInboxPayload(payload)
+  const running = await isSuperwhisperRunning()
+  if (!running) {
+    await fireAgentWake(scheme)
+  }
+  return wrote
+}

package/extensions/message.ts

@@ -0,0 +1,56 @@
+/**
+ * Extract the last assistant text from an agent_end message list.
+ * Returns "" if no assistant message or no text content.
+ */
+export function extractLastAssistantText(messages: any[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]
+    if (m?.role !== "assistant") continue
+    const content = Array.isArray(m.content) ? m.content : []
+    const text = content
+      .filter((c: any) => c?.type === "text")
+      .map((c: any) => c.text || "")
+      .join("\n")
+      .trim()
+    if (text) return text
+    return ""
+  }
+  return ""
+}
+
+/**
+ * The last assistant message — used to inspect stopReason / tool calls.
+ */
+export function getLastAssistant(messages: any[]): any | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]
+    if (m?.role === "assistant") return m
+  }
+  return undefined
+}
+
+/**
+ * Determine if the turn truly ended (vs. the model wanting to call more tools).
+ * OMP marks completed turns with stopReason "stop"; "toolUse" means the loop
+ * is about to run tools and isn't actually done.
+ */
+export function isEndTurn(message: any | undefined): boolean {
+  if (!message) return false
+  return message.stopReason === "stop"
+}
+
+export function extractSummary(text: string): string {
+  if (!text) return ""
+
+  const maxLength = 200
+
+  if (text.length <= maxLength) return text
+
+  const sentenceEnd = text.substring(0, maxLength).lastIndexOf(". ")
+  if (sentenceEnd > 100) return text.substring(0, sentenceEnd + 1)
+
+  const wordEnd = text.substring(0, maxLength).lastIndexOf(" ")
+  if (wordEnd > 150) return text.substring(0, wordEnd) + "..."
+
+  return text.substring(0, maxLength) + "..."
+}

package/extensions/poll.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, watch } from "node:fs"
+import { dirname, basename } from "node:path"
+import { POLL_INTERVAL_MS, POLL_TIMEOUT_MS } from "./constants"
+
+export type WaitResult =
+  | { kind: "response"; text: string }
+  | { kind: "empty" }
+  | { kind: "cancelled" }
+  | { kind: "timeout" }
+
+export interface WaitOptions {
+  timeoutMs?: number
+  intervalMs?: number
+  signal?: AbortSignal
+}
+
+const EMPTY_GRACE_MS = 2_000
+
+/**
+ * Wait for a response file to appear and contain text. Uses `fs.watch` on the
+ * parent directory so it reacts within milliseconds, with a periodic fallback
+ * for filesystems where watch events are flaky.
+ *
+ * - File missing for the full timeout → `timeout`
+ * - File created and stays empty for EMPTY_GRACE_MS → `empty` (Superwhisper X / double-ESC)
+ * - File created with text → `response`
+ * - `signal` aborts → `cancelled`
+ *
+ * The grace period prevents a race where Superwhisper creates an empty
+ * placeholder file before writing the transcription.
+ */
+export function waitForResponse(
+  path: string,
+  options: WaitOptions = {},
+): Promise<WaitResult> {
+  const timeoutMs = options.timeoutMs ?? POLL_TIMEOUT_MS
+  const intervalMs = options.intervalMs ?? POLL_INTERVAL_MS
+  const { signal } = options
+
+  const dir = dirname(path)
+  const file = basename(path)
+
+  function tryReadText(): string | null {
+    try {
+      if (!existsSync(path)) return null
+      const raw = readFileSync(path, "utf8")
+      return raw
+    } catch {
+      return null
+    }
+  }
+
+  return new Promise<WaitResult>((resolve) => {
+    if (signal?.aborted) {
+      resolve({ kind: "cancelled" })
+      return
+    }
+
+    let settled = false
+    let watcher: ReturnType<typeof watch> | undefined
+    let intervalId: ReturnType<typeof setInterval> | undefined
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+    let abortHandler: (() => void) | undefined
+    let emptySeenAt: number | null = null
+
+    const finish = (result: WaitResult) => {
+      if (settled) return
+      settled = true
+      try {
+        watcher?.close()
+      } catch {}
+      if (intervalId) clearInterval(intervalId)
+      if (timeoutId) clearTimeout(timeoutId)
+      if (abortHandler && signal) signal.removeEventListener("abort", abortHandler)
+      resolve(result)
+    }
+
+    const check = () => {
+      if (settled) return
+      const text = tryReadText()
+      if (text === null) {
+        emptySeenAt = null
+        return
+      }
+      const trimmed = text.trim()
+      if (trimmed.length > 0) {
+        finish({ kind: "response", text: trimmed })
+        return
+      }
+      if (emptySeenAt === null) {
+        emptySeenAt = Date.now()
+      } else if (Date.now() - emptySeenAt >= EMPTY_GRACE_MS) {
+        finish({ kind: "empty" })
+      }
+    }
+
+    check()
+
+    try {
+      watcher = watch(dir, { persistent: false }, (_eventType, filename) => {
+        if (filename === file) check()
+      })
+    } catch {
+      // dir missing or watch unsupported — interval is enough
+    }
+
+    intervalId = setInterval(check, intervalMs)
+    timeoutId = setTimeout(() => finish({ kind: "timeout" }), timeoutMs)
+
+    if (signal) {
+      abortHandler = () => finish({ kind: "cancelled" })
+      signal.addEventListener("abort", abortHandler, { once: true })
+    }
+  })
+}