@hasna/recordings 0.1.27 → 0.1.29

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.27",
+    version: "0.1.29",
     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.27";
+var VERSION = "0.1.29";
 
 // 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.27",
+    version: "0.1.29",
     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.27";
+var VERSION = "0.1.29";
 
 // 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.27";
+export declare const VERSION = "0.1.29";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "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/OpenAIAPIKeyStore.swift

@@ -1,6 +1,8 @@
 import Foundation
 
 enum OpenAIAPIKeyStore {
+    static let defaultLanguage = "en"
+
     static func load(
         homePath: String,
         environment: [String: String] = ProcessInfo.processInfo.environment,
@@ -21,6 +23,23 @@ enum OpenAIAPIKeyStore {
         return ""
     }
 
+    static func loadLanguage(
+        homePath: String,
+        environment: [String: String] = ProcessInfo.processInfo.environment,
+        userDefaultLanguage: String? = UserDefaults.standard.string(forKey: "recordingsLanguage")
+    ) -> String {
+        if let language = firstNonEmpty(environment["RECORDINGS_LANGUAGE"]) {
+            return normalizedStoredLanguage(language)
+        }
+        if let language = firstNonEmpty(userDefaultLanguage) {
+            return normalizedStoredLanguage(language)
+        }
+        if let language = loadConfigValue(homePath: homePath, key: "language", environment: environment) {
+            return normalizedStoredLanguage(language)
+        }
+        return defaultLanguage
+    }
+
     /// Persist the key into ~/.hasna/recordings/config.json so the CLI (which the app
     /// shells out to for final transcription) uses the same key as the app itself.
     static func save(key: String, homePath: String) throws {
@@ -47,25 +66,61 @@ enum OpenAIAPIKeyStore {
         try data.write(to: url, options: .atomic)
     }
 
-    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
-        let url = URL(fileURLWithPath: homePath)
-            .appendingPathComponent(".hasna")
-            .appendingPathComponent("recordings")
-            .appendingPathComponent("config.json")
+    static func saveLanguage(language: String, homePath: String) throws {
+        let normalized = normalizedStoredLanguage(language)
+        var json = loadMutableConfig(homePath: homePath)
 
-        guard let data = try? Data(contentsOf: url),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
-        else { return nil }
+        if apiLanguageHint(for: normalized).isEmpty {
+            json.removeValue(forKey: "language")
+        } else {
+            json["language"] = normalized
+        }
+
+        try writeConfig(json, homePath: homePath)
+    }
+
+    static func apiLanguageHint(for storedLanguage: String) -> String {
+        let normalized = normalizedStoredLanguage(storedLanguage)
+        return normalized == "auto" ? "" : normalized
+    }
 
+    private static func loadConfigKey(homePath: String, environment: [String: String]) -> String? {
         for key in ["openai_api_key", "api_key"] {
-            guard let value = json[key] as? String,
-                  let resolved = resolve(value: value, environment: environment)
-            else { continue }
-            return resolved
+            if let resolved = loadConfigValue(homePath: homePath, key: key, environment: environment) {
+                return resolved
+            }
         }
         return nil
     }
 
+    private static func loadConfigValue(homePath: String, key: String, environment: [String: String]) -> String? {
+        let json = loadMutableConfig(homePath: homePath)
+        guard let value = json[key] as? String else { return nil }
+        return resolve(value: value, environment: environment)
+    }
+
+    private static func loadMutableConfig(homePath: String) -> [String: Any] {
+        let url = configURL(homePath: homePath)
+        guard let data = try? Data(contentsOf: url),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return [:] }
+        return json
+    }
+
+    private static func writeConfig(_ json: [String: Any], homePath: String) throws {
+        let url = configURL(homePath: homePath)
+        try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
+        let data = try JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted, .sortedKeys])
+        try data.write(to: url, options: .atomic)
+    }
+
+    private static func configURL(homePath: String) -> URL {
+        URL(fileURLWithPath: homePath)
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+    }
+
     private static func loadSecretKey(homePath: String) -> String? {
         let root = URL(fileURLWithPath: homePath).appendingPathComponent(".secrets")
         let fileManager = FileManager.default
@@ -127,6 +182,11 @@ enum OpenAIAPIKeyStore {
         return value
     }
 
+    private static func normalizedStoredLanguage(_ language: String) -> String {
+        let trimmed = language.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+        return trimmed.isEmpty ? defaultLanguage : trimmed
+    }
+
     private static func firstNonEmpty(_ values: String?...) -> String? {
         for value in values {
             let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""

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

@@ -133,6 +133,12 @@ public final class RecordingEngine: ObservableObject {
     @Published public var isTranscribing = false
     @Published public var recordingDuration: TimeInterval = 0
     @Published public var liveTranscriptionText = ""
+    @Published public var transcriptionLanguage = OpenAIAPIKeyStore.defaultLanguage {
+        didSet {
+            UserDefaults.standard.set(transcriptionLanguage, forKey: "recordingsLanguage")
+            try? OpenAIAPIKeyStore.saveLanguage(language: transcriptionLanguage, homePath: home)
+        }
+    }
 
     private var nativeRecorder: NativePCMRecorder?
     private var recordingTimer: Timer?
@@ -178,6 +184,7 @@ public final class RecordingEngine: ObservableObject {
            let parsedMode = RecordingMode(rawValue: savedMode) {
             mode = parsedMode
         }
+        transcriptionLanguage = OpenAIAPIKeyStore.loadLanguage(homePath: home)
         useFnKey = UserDefaults.standard.object(forKey: "useFnKey") as? Bool ?? false
         if KeyboardShortcuts.getShortcut(for: .toggleRecording) == nil {
             KeyboardShortcuts.setShortcut(.init(.f5), for: .toggleRecording)
@@ -471,10 +478,11 @@ public final class RecordingEngine: ObservableObject {
     private func startRealtimeStreaming(apiKey: String) {
         let client = RealtimeTranscriptionClient(apiKey: apiKey, homePath: home)
         realtimeClient = client
-        log("realtime streaming task starting")
+        let language = OpenAIAPIKeyStore.apiLanguageHint(for: transcriptionLanguage)
+        log("realtime streaming task starting language=\(language.isEmpty ? "auto" : language)")
 
         streamingTask = Task {
-            await client.startStreaming()
+            await client.startStreaming(language: language)
             self.log("realtime start completed streaming=\(client.isStreaming) error=\(client.error ?? "")")
 
             var lastPeriodicCommitAt = Date.distantPast
@@ -492,7 +500,7 @@ public final class RecordingEngine: ObservableObject {
                 if text != streamingText {
                     await MainActor.run {
                         self.streamingText = text
-                        self.liveTranscriptionText = text
+                        self.liveTranscriptionText = Self.cleanRealtimeArtifactText(text)
                     }
                 }
             }
@@ -533,6 +541,7 @@ public final class RecordingEngine: ObservableObject {
         let audioPath = activeAudioPath
         let pcmStreamPipe = pcmStreamPipe
         let client = realtimeClient
+        let transcriptionLanguage = transcriptionLanguage
         resetRecordingIntent()
         self.pcmStreamPipe = nil
 
@@ -552,7 +561,11 @@ public final class RecordingEngine: ObservableObject {
 
             self.liveTranscriptionText = ""
 
-            if Self.shouldUseRealtimeFastPath(realtimeText: realtimeText, pcmByteCount: self.recordedPCM.count),
+            if Self.shouldUseRealtimeFastPath(
+                realtimeText: streamingResult,
+                pcmByteCount: self.recordedPCM.count,
+                language: transcriptionLanguage
+            ),
                let realtimeText {
                 let releaseToTextMS = Int(Date().timeIntervalSince(stopStartedAt) * 1_000)
                 self.log("using realtime fast path chars=\(realtimeText.count) releaseToTextMs=\(releaseToTextMS)")
@@ -621,11 +634,39 @@ public final class RecordingEngine: ObservableObject {
         return trimmed.isEmpty ? nil : trimmed
     }
 
-    public nonisolated static func shouldUseRealtimeFastPath(realtimeText: String?, pcmByteCount: Int) -> Bool {
+    public nonisolated static func shouldUseRealtimeFastPath(
+        realtimeText: String?,
+        pcmByteCount: Int,
+        language: String = "en"
+    ) -> Bool {
         guard let text = normalizedRealtimeTranscript(realtimeText) else { return false }
+        guard isSafeRealtimeFastPathText(rawText: realtimeText ?? "", cleanedText: text, language: language) else {
+            return false
+        }
         return !shouldFallbackFromPartialRealtime(text: text, pcmByteCount: pcmByteCount)
     }
 
+    public nonisolated static func isSafeRealtimeFastPathText(rawText: String, cleanedText: String, language: String) -> Bool {
+        guard !cleanedText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return false }
+        let languageHint = OpenAIAPIKeyStore.apiLanguageHint(for: language)
+        guard languageHint == "en" else { return true }
+
+        let rawTrimmed = rawText.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !containsCJKArtifact(in: rawTrimmed) else { return false }
+
+        let rawNormalized = rawTrimmed.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression
+        )
+        let cleanedNormalized = cleanedText.replacingOccurrences(
+            of: #"\s+"#,
+            with: " ",
+            options: .regularExpression
+        )
+        return rawNormalized == cleanedNormalized
+    }
+
     public nonisolated static func cleanRealtimeArtifactText(_ text: String) -> String {
         var cleaned = text
             .replacingOccurrences(of: "\n", with: " ")
@@ -653,11 +694,17 @@ public final class RecordingEngine: ObservableObject {
 
     private nonisolated static func removeStandaloneRealtimeArtifacts(from text: String) -> String {
         let artifactTokens: Set<String> = ["어", "음", "um", "umm", "uh", "uhh", "erm", "hmm", "eh"]
+        let englishDominant = latinLetterCount(in: text) >= max(12, cjkLetterCount(in: text) * 3)
         let words = text.split(separator: " ").compactMap { rawWord -> String? in
             let normalized = rawWord
                 .trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
                 .lowercased()
             return artifactTokens.contains(normalized) ? nil : String(rawWord)
+        }.compactMap { word -> String? in
+            guard englishDominant else { return word }
+            let normalized = word.trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines))
+            guard !normalized.isEmpty else { return word }
+            return isMostlyCJKArtifact(normalized) ? nil : word
         }
         return words.joined(separator: " ")
     }
@@ -707,6 +754,36 @@ public final class RecordingEngine: ObservableObject {
         word.trimmingCharacters(in: .punctuationCharacters.union(.whitespacesAndNewlines)).lowercased()
     }
 
+    private nonisolated static func isMostlyCJKArtifact(_ word: String) -> Bool {
+        let cjkCount = word.unicodeScalars.filter(isCJKScalar).count
+        guard cjkCount > 0 else { return false }
+        let letterCount = word.unicodeScalars.filter { CharacterSet.letters.contains($0) }.count
+        return cjkCount >= max(1, letterCount - cjkCount)
+    }
+
+    private nonisolated static func latinLetterCount(in text: String) -> Int {
+        text.unicodeScalars.filter { scalar in
+            (65...90).contains(Int(scalar.value)) || (97...122).contains(Int(scalar.value))
+        }.count
+    }
+
+    private nonisolated static func cjkLetterCount(in text: String) -> Int {
+        text.unicodeScalars.filter(isCJKScalar).count
+    }
+
+    private nonisolated static func containsCJKArtifact(in text: String) -> Bool {
+        cjkLetterCount(in: text) > 0
+    }
+
+    private nonisolated static func isCJKScalar(_ scalar: UnicodeScalar) -> Bool {
+        switch scalar.value {
+        case 0x3040...0x30FF, 0x3400...0x4DBF, 0x4E00...0x9FFF, 0xAC00...0xD7AF:
+            return true
+        default:
+            return false
+        }
+    }
+
     private func finishWithText(_ text: String, curMode: RecordingMode, targetAppBundleIdentifier: String?, targetAppPid: pid_t?, activeProjectId: String?, activeProjectName: String?) {
         log("finishWithText mode=\(curMode.rawValue) chars=\(text.count)")
         if curMode == .command {

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

@@ -33,6 +33,10 @@ public struct SettingsView: View {
                         // Keep the CLI config in sync — final transcription shells out to it.
                         try? OpenAIAPIKeyStore.save(key: openAIAPIKey, homePath: engine.home)
                     }
+                Picker("Language", selection: $engine.transcriptionLanguage) {
+                    Text("English").tag("en")
+                    Text("Auto Detect").tag("auto")
+                }
                 Text("Used for live transcription and the final paste. Stored in ~/.hasna/recordings/config.json.")
                     .foregroundStyle(.secondary)
             }

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

@@ -52,6 +52,32 @@ struct OpenAIAPIKeyStoreTests {
         #expect(key == "referenced-key")
     }
 
+    @Test("Language defaults to English and can be loaded from config")
+    func languageConfig() throws {
+        let home = try makeHome()
+        #expect(OpenAIAPIKeyStore.loadLanguage(homePath: home.path, environment: [:], userDefaultLanguage: nil) == "en")
+
+        try writeConfig(home: home, ["language": "FR"])
+        #expect(OpenAIAPIKeyStore.loadLanguage(homePath: home.path, environment: [:], userDefaultLanguage: nil) == "fr")
+        #expect(OpenAIAPIKeyStore.apiLanguageHint(for: "auto") == "")
+        #expect(OpenAIAPIKeyStore.apiLanguageHint(for: "en") == "en")
+    }
+
+    @Test("Saving language writes the CLI language config")
+    func saveLanguageWritesConfig() throws {
+        let home = try makeHome()
+
+        try OpenAIAPIKeyStore.saveLanguage(language: "en", homePath: home.path)
+
+        let configURL = home
+            .appendingPathComponent(".hasna")
+            .appendingPathComponent("recordings")
+            .appendingPathComponent("config.json")
+        let data = try Data(contentsOf: configURL)
+        let json = try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
+        #expect(json["language"] as? String == "en")
+    }
+
     @Test("Secrets env files are searched recursively")
     func recursiveSecrets() throws {
         let home = try makeHome()

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

@@ -132,6 +132,16 @@ struct RealtimeTranscriptionTests {
         #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(
+            realtimeText: "Actually 리수 Zoom your goal",
+            pcmByteCount: 96_000,
+            language: "en"
+        ) == false)
+        #expect(RecordingEngine.shouldUseRealtimeFastPath(
+            realtimeText: "Actually Zoom your goal",
+            pcmByteCount: 96_000,
+            language: "en"
+        ))
     }
 
     @Test("Realtime artifact cleanup removes duplicated chunks and filler tokens")
@@ -141,4 +151,12 @@ struct RealtimeTranscriptionTests {
         )
         #expect(cleaned == "Okay I don't know if this is working")
     }
+
+    @Test("Realtime artifact cleanup removes CJK tokens from English-dominant text")
+    func realtimeCJKArtifactCleanup() {
+        let cleaned = RecordingEngine.cleanRealtimeArtifactText(
+            "Actually 리수 Zoom your goal and do this work with sabi 度扫 agents actually"
+        )
+        #expect(cleaned == "Actually Zoom your goal and do this work with sabi agents actually")
+    }
 }

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

@@ -63,4 +63,18 @@ struct TranscriptResolutionTests {
         #expect(RecordingEngine.normalizedRealtimeTranscript(" \n ") == nil)
         #expect(RecordingEngine.normalizedRealtimeTranscript(nil) == nil)
     }
+
+    @Test("Unsafe English realtime text is not eligible for fast-path paste")
+    func unsafeRealtimeTextRejectedForFastPath() {
+        #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"
+        ))
+    }
 }