@hasna/recordings 0.1.28 → 0.1.30

package/dist/cli/index.js

@@ -5098,7 +5098,7 @@ var init_pg_migrate = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.28",
+    version: "0.1.30",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -6081,7 +6081,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.28";
+var VERSION = "0.1.30";
 
 // src/cli/storage.ts
 import chalk from "chalk";
@@ -6804,16 +6804,33 @@ appCommand.command("reset-permissions").description("Reset macOS Microphone and
     console.error(chalk2.red("Permission reset is only available on macOS"));
     process.exit(1);
   }
-  const services = ["Microphone", "Accessibility"];
-  for (const service of services) {
-    const result = spawnSync("tccutil", ["reset", service, "com.hasna.recordings"], {
-      stdio: "inherit"
-    });
-    if (result.error) {
-      console.error(chalk2.red(result.error.message));
-      process.exit(1);
-    }
+  resetMacOSPermissions();
+});
+appCommand.command("request-permissions").description("Open Recordings.app and trigger macOS Microphone and Accessibility permission prompts").option("--reset", "Reset existing Microphone and Accessibility decisions before requesting").action((opts) => {
+  if (process.platform !== "darwin") {
+    console.error(chalk2.red("Permission prompts are only available on macOS"));
+    process.exit(1);
+  }
+  const status = getMacOSAppStatus();
+  if (!status.installed) {
+    console.error(chalk2.red("Recordings.app is not installed. Run: recordings app install"));
+    process.exit(1);
   }
+  if (opts.reset) {
+    resetMacOSPermissions();
+  }
+  const result = spawnSync("open", [
+    "-n",
+    status.installed_app_path,
+    "--args",
+    "--request-permissions",
+    "--open-permission-settings"
+  ], { stdio: "inherit" });
+  if (result.error) {
+    console.error(chalk2.red(result.error.message));
+    process.exit(1);
+  }
+  process.exit(result.status ?? 1);
 });
 appCommand.command("log").description("Show the Recordings.app diagnostic log").option("-n, --lines <lines>", "Number of lines to print", "120").action((opts) => {
   const status = getMacOSAppStatus();
@@ -7319,6 +7336,18 @@ function getMacOSAppStatus() {
     log_path: logPath
   };
 }
+function resetMacOSPermissions() {
+  const services = ["Microphone", "Accessibility"];
+  for (const service of services) {
+    const result = spawnSync("tccutil", ["reset", service, "com.hasna.recordings"], {
+      stdio: "inherit"
+    });
+    if (result.error) {
+      console.error(chalk2.red(result.error.message));
+      process.exit(1);
+    }
+  }
+}
 function getCodeSigningInfo(appPath) {
   if (process.platform !== "darwin" || !existsSync4(appPath)) {
     return { cdHash: null, adHoc: false };

package/dist/mcp/index.js

@@ -4920,7 +4920,7 @@ var require_lib2 = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/recordings",
-    version: "0.1.28",
+    version: "0.1.30",
     type: "module",
     description: "Speech-to-text recording tool with MCP and CLI \u2014 records, transcribes, and optionally enhances text using AI",
     repository: {
@@ -9797,7 +9797,7 @@ async function processText(rawText, config, systemPrompt) {
 }
 
 // src/version.ts
-var VERSION = "0.1.28";
+var VERSION = "0.1.30";
 
 // src/db/storage-config.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.28";
+export declare const VERSION = "0.1.30";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "type": "module",
   "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
   "repository": {

package/src/native/Recordings/App/RecordingsApp.swift

@@ -1,4 +1,5 @@
 @preconcurrency import Cocoa
+import AVFoundation
 import SwiftUI
 import KeyboardShortcuts
 import RecordingsLib
@@ -14,6 +15,7 @@ struct RecordingsApp: App {
         AXIsProcessTrustedWithOptions(
             [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
         )
+        Self.handlePermissionRequestArguments()
     }
 
     var body: some Scene {
@@ -49,4 +51,29 @@ struct RecordingsApp: App {
             app.terminate()
         }
     }
+
+    private static func handlePermissionRequestArguments() {
+        let arguments = CommandLine.arguments
+        guard arguments.contains("--request-permissions") else { return }
+
+        NativeAppLog.write("request-permissions argument received")
+        AVCaptureDevice.requestAccess(for: .audio) { granted in
+            NativeAppLog.write("request-permissions microphone granted=\(granted)")
+        }
+
+        let trusted = AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+        )
+        NativeAppLog.write("request-permissions accessibility trusted=\(trusted)")
+
+        guard arguments.contains("--open-permission-settings") else { return }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.8) {
+            if let microphone = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone") {
+                NSWorkspace.shared.open(microphone)
+            }
+            if let accessibility = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
+                NSWorkspace.shared.open(accessibility)
+            }
+        }
+    }
 }

package/src/native/Recordings/RecordingsLib/NativeAppDiagnostics.swift

@@ -1,9 +1,9 @@
 import Foundation
 
-enum NativeAppLog {
+public enum NativeAppLog {
     private static let lock = NSLock()
 
-    static func write(_ message: String, homePath: String = FileManager.default.homeDirectoryForCurrentUser.path) {
+    public static func write(_ message: String, homePath: String = FileManager.default.homeDirectoryForCurrentUser.path) {
         lock.lock()
         defer { lock.unlock() }
 

package/src/native/Recordings/RecordingsLib/RecordingEngine.swift

@@ -558,20 +558,21 @@ public final class RecordingEngine: ObservableObject {
             self.streamingTask = nil
 
             let realtimeText = Self.normalizedRealtimeTranscript(streamingResult)
-
-            self.liveTranscriptionText = ""
-
-            if Self.shouldUseRealtimeFastPath(
+            let fastPathText = Self.realtimeFastPathTranscript(
                 realtimeText: streamingResult,
                 pcmByteCount: self.recordedPCM.count,
                 language: transcriptionLanguage
-            ),
-               let realtimeText {
+            )
+
+            self.liveTranscriptionText = ""
+
+            if let fastPathText {
                 let releaseToTextMS = Int(Date().timeIntervalSince(stopStartedAt) * 1_000)
-                self.log("using realtime fast path chars=\(realtimeText.count) releaseToTextMs=\(releaseToTextMS)")
+                let repaired = Self.wasRealtimeTranscriptRepaired(rawText: streamingResult, cleanedText: fastPathText)
+                self.log("using realtime fast path chars=\(fastPathText.count) repaired=\(repaired) releaseToTextMs=\(releaseToTextMS)")
                 self.isTranscribing = false
                 self.finishWithText(
-                    realtimeText,
+                    fastPathText,
                     curMode: curMode,
                     targetAppBundleIdentifier: targetAppBundleIdentifier,
                     targetAppPid: targetAppPid,
@@ -639,11 +640,23 @@ public final class RecordingEngine: ObservableObject {
         pcmByteCount: Int,
         language: String = "en"
     ) -> Bool {
-        guard let text = normalizedRealtimeTranscript(realtimeText) else { return false }
+        realtimeFastPathTranscript(
+            realtimeText: realtimeText,
+            pcmByteCount: pcmByteCount,
+            language: language
+        ) != nil
+    }
+
+    public nonisolated static func realtimeFastPathTranscript(
+        realtimeText: String?,
+        pcmByteCount: Int,
+        language: String = "en"
+    ) -> String? {
+        guard let text = normalizedRealtimeTranscript(realtimeText) else { return nil }
         guard isSafeRealtimeFastPathText(rawText: realtimeText ?? "", cleanedText: text, language: language) else {
-            return false
+            return nil
         }
-        return !shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount)
+        return shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount) ? nil : text
     }
 
     public nonisolated static func isSafeRealtimeFastPathText(rawText: String, cleanedText: String, language: String) -> Bool {
@@ -652,19 +665,31 @@ public final class RecordingEngine: ObservableObject {
         guard languageHint == "en" else { return true }
 
         let rawTrimmed = rawText.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard !containsCJKArtifact(in: rawTrimmed) else { return false }
+        let rawNormalized = normalizedTranscriptText(rawTrimmed)
+        let cleanedNormalized = normalizedTranscriptText(cleanedText)
+        guard !cleanedNormalized.isEmpty else { return false }
+        guard rawNormalized != cleanedNormalized else { return true }
+        guard cjkLetterCount(in: cleanedNormalized) == 0 else { return false }
 
-        let rawNormalized = rawTrimmed.replacingOccurrences(
-            of: #"\s+"#,
-            with: " ",
-            options: .regularExpression
-        )
-        let cleanedNormalized = cleanedText.replacingOccurrences(
-            of: #"\s+"#,
-            with: " ",
-            options: .regularExpression
-        )
-        return rawNormalized == cleanedNormalized
+        let cleanedWords = canonicalTranscriptWords(cleanedNormalized, droppingArtifacts: false)
+        guard !cleanedWords.isEmpty else { return false }
+
+        let rawWords = canonicalTranscriptWords(rawNormalized, droppingArtifacts: true)
+        guard isSubsequence(cleanedWords, of: rawWords) else { return false }
+
+        let rawCJKCount = cjkLetterCount(in: rawNormalized)
+        if rawCJKCount > 0 {
+            let cleanedLatinCount = latinLetterCount(in: cleanedNormalized)
+            guard cleanedLatinCount >= max(2, rawCJKCount * 2) else { return false }
+            guard rawCJKCount <= max(6, cleanedLatinCount / 3) else { return false }
+        }
+
+        let removedWordCount = max(0, rawWords.count - cleanedWords.count)
+        return removedWordCount <= max(8, cleanedWords.count + 3)
+    }
+
+    public nonisolated static func wasRealtimeTranscriptRepaired(rawText: String, cleanedText: String) -> Bool {
+        normalizedTranscriptText(rawText) != normalizedTranscriptText(cleanedText)
     }
 
     public nonisolated static func cleanRealtimeArtifactText(_ text: String) -> String {
@@ -709,6 +734,55 @@ public final class RecordingEngine: ObservableObject {
         return words.joined(separator: " ")
     }
 
+    private nonisolated static func normalizedTranscriptText(_ text: String) -> String {
+        text
+            .replacingOccurrences(of: "\n", with: " ")
+            .replacingOccurrences(of: "\t", with: " ")
+            .replacingOccurrences(
+                of: #"\s+"#,
+                with: " ",
+                options: .regularExpression
+            )
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private nonisolated static func canonicalTranscriptWords(_ text: String, droppingArtifacts: Bool) -> [String] {
+        text.split(whereSeparator: { $0.isWhitespace || $0.isNewline }).compactMap { rawWord in
+            var normalized = String(rawWord)
+                .trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
+                .lowercased()
+            if droppingArtifacts {
+                normalized = normalized.unicodeScalars.reduce(into: "") { output, scalar in
+                    if !isCJKScalar(scalar) {
+                        output.unicodeScalars.append(scalar)
+                    }
+                }
+            }
+            guard !normalized.isEmpty else { return nil }
+            if droppingArtifacts, isStandaloneRealtimeArtifact(normalized) {
+                return nil
+            }
+            return normalized
+        }
+    }
+
+    private nonisolated static func isSubsequence(_ needle: [String], of haystack: [String]) -> Bool {
+        guard !needle.isEmpty else { return true }
+        var index = 0
+        for word in haystack where word == needle[index] {
+            index += 1
+            if index == needle.count {
+                return true
+            }
+        }
+        return false
+    }
+
+    private nonisolated static func isStandaloneRealtimeArtifact(_ word: String) -> Bool {
+        let artifactTokens: Set<String> = ["어", "음", "um", "umm", "uh", "uhh", "erm", "hmm", "eh"]
+        return artifactTokens.contains(word) || isMostlyCJKArtifact(word)
+    }
+
     private nonisolated static func collapseAdjacentDuplicateWords(in text: String) -> String {
         let words = text.split(separator: " ").map(String.init)
         guard words.count > 1 else { return text }

package/src/native/Recordings/RecordingsTests/RealtimeTranscriptionTests.swift

@@ -126,22 +126,32 @@ struct RealtimeTranscriptionTests {
         #expect(RecordingEngine.shouldFallbackFromPartialRealtime(text: "Hi", pcmByteCount: 12_000) == false)
     }
 
-    @Test("Realtime fast path accepts useful text and rejects empty or suspicious partial output")
+    @Test("Realtime fast path accepts useful and safely repaired text")
     func realtimeFastPathDecision() {
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "  this is a useful transcript  ", pcmByteCount: 96_000))
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 12_000))
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "Hi", pcmByteCount: 96_000) == false)
         #expect(RecordingEngine.shouldUseRealtimeFastPath(realtimeText: "   ", pcmByteCount: 96_000) == false)
-        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+        #expect(RecordingEngine.realtimeFastPathTranscript(
             realtimeText: "Actually 리수 Zoom your goal",
             pcmByteCount: 96_000,
             language: "en"
-        ) == false)
-        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+        ) == "Actually Zoom your goal")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
+            realtimeText: "어 Okay I don't know if this This is working어 Okay I don't know if this This is working",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == "Okay I don't know if this is working")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
             realtimeText: "Actually Zoom your goal",
             pcmByteCount: 96_000,
             language: "en"
-        ))
+        ) == "Actually Zoom your goal")
+        #expect(RecordingEngine.realtimeFastPathTranscript(
+            realtimeText: "리수 度扫 開けたの 어",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == nil)
     }
 
     @Test("Realtime artifact cleanup removes duplicated chunks and filler tokens")

package/src/native/Recordings/RecordingsTests/TranscriptResolutionTests.swift

@@ -64,17 +64,26 @@ struct TranscriptResolutionTests {
         #expect(RecordingEngine.normalizedRealtimeTranscript(nil) == nil)
     }
 
-    @Test("Unsafe English realtime text is not eligible for fast-path paste")
-    func unsafeRealtimeTextRejectedForFastPath() {
+    @Test("English realtime text can be safely repaired before fast-path paste")
+    func realtimeTextRepairedForFastPath() {
         #expect(RecordingEngine.isSafeRealtimeFastPathText(
             rawText: "Actually 리수 Zoom your goal",
             cleanedText: "Actually Zoom your goal",
             language: "en"
-        ) == false)
+        ))
         #expect(RecordingEngine.isSafeRealtimeFastPathText(
             rawText: "Actually Zoom your goal",
             cleanedText: "Actually Zoom your goal",
             language: "en"
         ))
+        #expect(RecordingEngine.isSafeRealtimeFastPathText(
+            rawText: "Actually Zoom your goal",
+            cleanedText: "Actually invented Zoom your goal",
+            language: "en"
+        ) == false)
+        #expect(RecordingEngine.wasRealtimeTranscriptRepaired(
+            rawText: "working어",
+            cleanedText: "working"
+        ))
     }
 }