@hasna/recordings 0.1.4 → 0.1.7

package/src/cli/index.ts

@@ -485,24 +485,27 @@ program
     const { existsSync: fileExists } = require("node:fs") as typeof import("node:fs");
     const home = getHome();
 
-    const appPath = pathJoin(home, ".recordings", "RecordingsHelper.app");
+    const appPath = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app");
+    const oldAppPath = pathJoin(home, ".recordings", "RecordingsHelper.app");
 
-    if (!fileExists(appPath)) {
+    if (!fileExists(appPath) && !fileExists(oldAppPath)) {
       console.error(chalk.red("RecordingsHelper.app not found. Run: recordings shortcut --install"));
       process.exit(1);
     }
 
+    const resolvedAppPath = fileExists(appPath) ? appPath : oldAppPath;
+
     // Kill existing instance
     try { execSync("pkill -f RecordingsHelper", { stdio: "pipe" }); } catch { /* not running */ }
 
     // Launch
-    execSync(`open "${appPath}"`, { stdio: "pipe" });
+    execSync(`open "${resolvedAppPath}"`, { stdio: "pipe" });
     console.log(chalk.green("Recordings helper launched — press F5 to record"));
 
     if (opts.login) {
       try {
         execSync(
-          `osascript -e 'tell application "System Events" to make login item at end with properties {path:"${appPath}", hidden:true}'`,
+          `osascript -e 'tell application "System Events" to make login item at end with properties {path:"${resolvedAppPath}", hidden:true}'`,
           { stdio: "pipe" }
         );
         console.log(chalk.green("Added to Login Items — will start on boot"));
@@ -688,7 +691,7 @@ program
     const { homedir: getHome } = require("node:os") as typeof import("node:os");
     const home = getHome();
 
-    const scriptDir = pathJoin(home, ".recordings");
+    const scriptDir = pathJoin(home, ".hasna", "recordings");
     mkdirSync(scriptDir, { recursive: true });
 
     const scriptPath = pathJoin(scriptDir, "record-toggle.sh");
@@ -747,7 +750,7 @@ fi
       // Install the native menu bar app — no config needed, just works with F5
       const { execSync: exec } = require("node:child_process") as typeof import("node:child_process");
 
-      const appPath = pathJoin(home, ".recordings", "RecordingsHelper.app");
+      const appPath = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app");
       const srcSwift = pathJoin(__dirname, "..", "native", "RecordingsHelper.swift");
       const distApp = pathJoin(__dirname, "..", "RecordingsHelper.app");
 
@@ -757,10 +760,10 @@ fi
       } else if (fileExists(srcSwift)) {
         // Compile from source
         console.log(chalk.blue("Compiling native helper app..."));
-        const appDir = pathJoin(home, ".recordings", "RecordingsHelper.app", "Contents", "MacOS");
+        const appDir = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app", "Contents", "MacOS");
         mkdirSync(appDir, { recursive: true });
 
-        const plistDir = pathJoin(home, ".recordings", "RecordingsHelper.app", "Contents");
+        const plistDir = pathJoin(home, ".hasna", "recordings", "RecordingsHelper.app", "Contents");
         const plist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>

package/src/lib/config.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, mkdirSync, cpSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import type { RecordingsConfig } from "../types/index.js";
@@ -67,7 +67,9 @@ export function loadConfig(configPath?: string): RecordingsConfig {
   if (process.env.RECORDINGS_LANGUAGE) {
     config.language = process.env.RECORDINGS_LANGUAGE;
   }
-  if (process.env.RECORDINGS_DB_PATH) {
+  if (process.env.HASNA_RECORDINGS_DB_PATH) {
+    config.db_path = process.env.HASNA_RECORDINGS_DB_PATH;
+  } else if (process.env.RECORDINGS_DB_PATH) {
     config.db_path = process.env.RECORDINGS_DB_PATH;
   }
   if (process.env.RECORDINGS_AUDIO_DIR) {
@@ -115,7 +117,7 @@ function findConfigFile(): string | null {
 }
 
 export function getDataDir(): string {
-  // Check for .recordings in cwd hierarchy
+  // Check for .recordings in cwd hierarchy (project-local)
   let dir = process.cwd();
   const root = "/";
   while (dir !== root) {
@@ -125,8 +127,23 @@ export function getDataDir(): string {
     if (parent === dir) break;
     dir = parent;
   }
-  // Fall back to ~/.recordings
-  return join(homedir(), ".recordings");
+
+  // Global: ~/.hasna/recordings (with backward compat from ~/.recordings)
+  const home = homedir();
+  const newDir = join(home, ".hasna", "recordings");
+  const oldDir = join(home, ".recordings");
+
+  // Auto-migrate from old location if new dir doesn't exist yet
+  if (!existsSync(newDir) && existsSync(oldDir)) {
+    try {
+      mkdirSync(join(home, ".hasna"), { recursive: true });
+      cpSync(oldDir, newDir, { recursive: true });
+    } catch {
+      // Fall through to use new dir
+    }
+  }
+
+  return newDir;
 }
 
 function loadSecretKey(keyName: string): string {

package/src/native/Recordings/Package.resolved

@@ -0,0 +1,15 @@
+{
+  "originHash" : "a6c896b6f831f2130914352c7417e95b036b1f02a1ff70318f1f4e5aa8966e9b",
+  "pins" : [
+    {
+      "identity" : "keyboardshortcuts",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/sindresorhus/KeyboardShortcuts",
+      "state" : {
+        "revision" : "1aef85578fdd4f9eaeeb8d53b7b4fc31bf08fe27",
+        "version" : "2.4.0"
+      }
+    }
+  ],
+  "version" : 3
+}

package/src/native/Recordings/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version: 6.2
+
+import PackageDescription
+
+let package = Package(
+    name: "Recordings",
+    platforms: [
+        .macOS(.v26)
+    ],
+    dependencies: [
+        .package(url: "https://github.com/sindresorhus/KeyboardShortcuts", from: "2.0.0")
+    ],
+    targets: [
+        .executableTarget(
+            name: "Recordings",
+            dependencies: ["KeyboardShortcuts"],
+            path: "Recordings",
+            exclude: ["Info.plist", "Recordings.entitlements"]
+        )
+    ]
+)

package/src/native/Recordings/Recordings/FnKeyMonitor.swift

@@ -0,0 +1,122 @@
+import Cocoa
+
+/// Monitors the fn/Globe key using CGEventTap.
+/// Based on the proven pattern from CustomWispr (open-source WisprFlow alternative).
+/// User must set System Settings > Keyboard > "Press fn key to: Do Nothing" for this to work.
+final class FnKeyMonitor: @unchecked Sendable {
+    var onFnKeyDown: (() -> Void)?
+    var onFnKeyUp: (() -> Void)?
+
+    private var eventTap: CFMachPort?
+    private var runLoopSource: CFRunLoopSource?
+    private var healthCheckTimer: Timer?
+    private var fnIsDown = false
+
+    private static let fnKeyCode: UInt16 = 63
+    private static let fnFlagMask: UInt64 = 0x800000
+
+    /// Start monitoring. Returns true if successful.
+    func start() -> Bool {
+        guard eventTap == nil else {
+            fputs("[FnKeyMonitor] Already running\n", stderr)
+            return true
+        }
+
+        fputs("[FnKeyMonitor] Creating event tap...\n", stderr)
+        let eventMask: CGEventMask = (1 << CGEventType.flagsChanged.rawValue)
+
+        // passRetained so the callback reference stays alive
+        let selfPtr = Unmanaged.passRetained(self).toOpaque()
+
+        guard let tap = CGEvent.tapCreate(
+            tap: .cgSessionEventTap,
+            place: .headInsertEventTap,
+            options: .defaultTap,
+            eventsOfInterest: eventMask,
+            callback: { (proxy, type, event, refcon) -> Unmanaged<CGEvent>? in
+                guard let refcon = refcon else { return Unmanaged.passRetained(event) }
+                let monitor = Unmanaged<FnKeyMonitor>.fromOpaque(refcon).takeUnretainedValue()
+                return monitor.handleEvent(type: type, event: event)
+            },
+            userInfo: selfPtr
+        ) else {
+            Unmanaged<FnKeyMonitor>.fromOpaque(selfPtr).release()
+            return false
+        }
+
+        self.eventTap = tap
+
+        let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+        self.runLoopSource = source
+        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .commonModes)
+        CGEvent.tapEnable(tap: tap, enable: true)
+        fputs("[FnKeyMonitor] Event tap created and enabled OK\n", stderr)
+
+        // Health check: macOS silently disables taps — re-enable every 3 seconds
+        healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 3.0, repeats: true) { [weak self] _ in
+            guard let self = self, let tap = self.eventTap else { return }
+            if !CGEvent.tapIsEnabled(tap: tap) {
+                fputs("[FnKeyMonitor] Tap was disabled, re-enabling\n", stderr)
+                CGEvent.tapEnable(tap: tap, enable: true)
+            }
+        }
+
+        return true
+    }
+
+    func stop() {
+        healthCheckTimer?.invalidate()
+        healthCheckTimer = nil
+
+        if let tap = eventTap {
+            CGEvent.tapEnable(tap: tap, enable: false)
+        }
+        if let source = runLoopSource {
+            CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, .commonModes)
+        }
+        eventTap = nil
+        runLoopSource = nil
+        fnIsDown = false
+    }
+
+    private func handleEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
+        // Re-enable if macOS disabled the tap
+        if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
+            if let tap = eventTap {
+                CGEvent.tapEnable(tap: tap, enable: true)
+            }
+            return Unmanaged.passRetained(event)
+        }
+
+        let keyCode = UInt16(event.getIntegerValueField(.keyboardEventKeycode))
+
+        // Only handle fn key (keyCode 63)
+        guard keyCode == FnKeyMonitor.fnKeyCode else {
+            return Unmanaged.passRetained(event)
+        }
+
+        let flags = event.flags.rawValue
+        let fnPressed = (flags & FnKeyMonitor.fnFlagMask) != 0
+
+        fputs("[FnKeyMonitor] flagsChanged keyCode=\(keyCode) flags=0x\(String(flags, radix: 16)) fnPressed=\(fnPressed) fnIsDown=\(fnIsDown)\n", stderr)
+
+        if fnPressed && !fnIsDown {
+            // fn just pressed
+            fnIsDown = true
+            fputs("[FnKeyMonitor] fn DOWN — starting recording\n", stderr)
+            DispatchQueue.main.async { [weak self] in
+                self?.onFnKeyDown?()
+            }
+            return nil // Swallow — prevents emoji picker / language switch
+        } else if !fnPressed && fnIsDown {
+            // fn released
+            fnIsDown = false
+            DispatchQueue.main.async { [weak self] in
+                self?.onFnKeyUp?()
+            }
+            return nil // Swallow release too
+        }
+
+        return Unmanaged.passRetained(event)
+    }
+}

package/src/native/Recordings/Recordings/Info.plist

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>LSUIElement</key>
+    <true/>
+    <key>CFBundleName</key>
+    <string>Recordings</string>
+    <key>CFBundleDisplayName</key>
+    <string>Recordings</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.hasna.recordings</string>
+    <key>CFBundleVersion</key>
+    <string>1</string>
+    <key>CFBundleShortVersionString</key>
+    <string>0.1.0</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>26.0</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>Recordings needs microphone access to record and transcribe your speech.</string>
+</dict>
+</plist>

package/src/native/Recordings/Recordings/MenuBarPopover.swift

@@ -0,0 +1,188 @@
+import SwiftUI
+import KeyboardShortcuts
+
+struct MenuBarPopover: View {
+    @ObservedObject var engine: RecordingEngine
+    @ObservedObject var shortcuts: VoiceShortcuts
+
+    var body: some View {
+        VStack(spacing: 0) {
+            header.padding(.horizontal, 16).padding(.top, 12).padding(.bottom, 8)
+            Divider()
+            modeSelector.padding(.horizontal, 16).padding(.vertical, 10)
+            shortcutRow.padding(.horizontal, 16).padding(.bottom, 8)
+            Divider()
+            recordingArea.padding(.horizontal, 16).padding(.vertical, 12)
+            Divider()
+            recentList.frame(maxHeight: 180)
+            Divider()
+            footer.padding(.horizontal, 16).padding(.vertical, 8)
+        }
+    }
+
+    // MARK: - Header
+
+    private var header: some View {
+        HStack {
+            Image(systemName: "mic.fill").font(.title3).foregroundStyle(.tint)
+            Text("Recordings").font(.headline)
+            Spacer()
+            Toggle(isOn: $engine.isWhisperMode) {
+                Label("Whisper", systemImage: "speaker.wave.1.fill").font(.caption)
+            }
+            .toggleStyle(.button).buttonStyle(.bordered).controlSize(.small)
+        }
+    }
+
+    // MARK: - Mode Selector
+
+    private var modeSelector: some View {
+        HStack(spacing: 8) {
+            modeBtn(.pushToTalk)
+            modeBtn(.dictation)
+            modeBtn(.command)
+        }
+    }
+
+    @ViewBuilder
+    private func modeBtn(_ m: RecordingMode) -> some View {
+        if engine.mode == m {
+            Button { engine.mode = m } label: {
+                Label(m.rawValue, systemImage: m.icon).font(.caption)
+                    .foregroundStyle(.white).frame(maxWidth: .infinity)
+            }.buttonStyle(.borderedProminent).controlSize(.small)
+        } else {
+            Button { engine.mode = m } label: {
+                Label(m.rawValue, systemImage: m.icon).font(.caption)
+                    .frame(maxWidth: .infinity)
+            }.buttonStyle(.bordered).controlSize(.small)
+        }
+    }
+
+    // MARK: - Shortcut Row
+
+    private var shortcutRow: some View {
+        VStack(spacing: 6) {
+            // fn key toggle
+            HStack {
+                Toggle(isOn: $engine.useFnKey) {
+                    HStack(spacing: 4) {
+                        Text("fn").font(.system(.caption, design: .monospaced)).bold()
+                        Text("Globe key").font(.caption).foregroundStyle(.secondary)
+                    }
+                }
+                .toggleStyle(.switch).controlSize(.small)
+            }
+
+            // Custom shortcut
+            HStack(spacing: 8) {
+                Text("Custom").font(.caption).foregroundStyle(.secondary)
+                Spacer()
+                let current = KeyboardShortcuts.getShortcut(for: .toggleRecording)
+                Text(current?.description ?? "None")
+                    .font(.system(.caption, design: .monospaced))
+                    .padding(.horizontal, 8).padding(.vertical, 3)
+                    .background(.quaternary, in: RoundedRectangle(cornerRadius: 5))
+
+                SettingsLink {
+                    Text("Set").font(.caption2)
+                }.buttonStyle(.bordered).controlSize(.mini)
+            }
+        }
+    }
+
+    // MARK: - Recording Area
+
+    private var recordingArea: some View {
+        VStack(spacing: 8) {
+            if engine.isRecording {
+                HStack(spacing: 12) {
+                    Circle().fill(.red).frame(width: 10, height: 10)
+                    Text(fmt(engine.recordingDuration))
+                        .font(.system(.title2, design: .monospaced))
+                    Spacer()
+                    Button("Stop") { engine.stopAndTranscribe() }
+                        .buttonStyle(.borderedProminent).tint(.red).controlSize(.small)
+                }
+                .padding(12).glassEffect(.regular.tint(.red))
+            } else if engine.isTranscribing {
+                HStack(spacing: 8) {
+                    ProgressView().controlSize(.small)
+                    Text("Transcribing...").font(.subheadline).foregroundStyle(.secondary)
+                }
+                .frame(maxWidth: .infinity).padding(12).glassEffect(.regular)
+            } else {
+                VStack(spacing: 10) {
+                    Button { engine.startRecording() } label: {
+                        Label("Record", systemImage: "mic.circle.fill").font(.title3)
+                    }.buttonStyle(.borderedProminent).controlSize(.large)
+
+                    Text(engine.mode.hint)
+                        .font(.callout).foregroundStyle(.primary.opacity(0.7))
+                        .multilineTextAlignment(.center)
+                        .fixedSize(horizontal: false, vertical: true)
+                }
+                .frame(maxWidth: .infinity).padding(14).glassEffect(.clear)
+            }
+
+            Text(engine.statusMessage)
+                .font(.caption2).foregroundStyle(.secondary)
+                .lineLimit(2).truncationMode(.tail)
+                .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+
+    // MARK: - Recent
+
+    private var recentList: some View {
+        Group {
+            if engine.recentTranscriptions.isEmpty {
+                VStack { Spacer()
+                    Text("No recent transcriptions").font(.caption).foregroundStyle(.quaternary)
+                    Spacer()
+                }.frame(maxWidth: .infinity)
+            } else {
+                ScrollView {
+                    LazyVStack(alignment: .leading, spacing: 4) {
+                        ForEach(engine.recentTranscriptions.indices, id: \.self) { i in
+                            TranscriptionRow(item: engine.recentTranscriptions[i])
+                        }
+                    }.padding(.horizontal, 16).padding(.vertical, 6)
+                }
+            }
+        }
+    }
+
+    // MARK: - Footer
+
+    private var footer: some View {
+        HStack {
+            SettingsLink { Image(systemName: "gear") }.buttonStyle(.borderless)
+            Spacer()
+            Button("Quit") { NSApplication.shared.terminate(nil) }
+                .buttonStyle(.borderless).foregroundStyle(.secondary)
+        }
+    }
+
+    private func fmt(_ t: TimeInterval) -> String {
+        String(format: "%d:%02d", Int(t) / 60, Int(t) % 60)
+    }
+}
+
+struct TranscriptionRow: View {
+    let item: TranscriptionResult
+    var body: some View {
+        HStack(alignment: .top, spacing: 8) {
+            Text(item.displayText).font(.caption).lineLimit(2)
+                .frame(maxWidth: .infinity, alignment: .leading)
+            Text({ let s = Date().timeIntervalSince(item.timestamp)
+                return s < 60 ? "now" : s < 3600 ? "\(Int(s/60))m" : "\(Int(s/3600))h"
+            }()).font(.caption2).foregroundStyle(.tertiary)
+        }
+        .padding(.vertical, 4).contentShape(Rectangle())
+        .onTapGesture {
+            NSPasteboard.general.clearContents()
+            NSPasteboard.general.setString(item.displayText, forType: .string)
+        }
+    }
+}