@hasna/recordings 0.1.4 → 0.1.6

package/LICENSE

@@ -1,21 +1,170 @@
-MIT License
-
-Copyright (c) 2026 Hasna
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship made available under
+the License, as indicated by a copyright notice that is included in
+or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean, as submitted to the Licensor for inclusion
+in the Work by the copyright owner or by an individual or Legal Entity
+authorized to submit on behalf of the copyright owner. For the purposes
+of this definition, "submitted" means any form of electronic, verbal,
+or written communication sent to the Licensor or its representatives,
+including but not limited to communication on electronic mailing lists,
+source code control systems, and issue tracking systems that are managed
+by, or on behalf of, the Licensor for the purpose of recording and
+discussing the Work, but excluding communication that is conspicuously
+marked or designated in writing by the copyright owner as "Not a
+Contribution."
+
+"Contributor" shall mean Licensor and any Legal Entity on behalf of
+whom a Contribution has been received by the Licensor and included
+within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent contributions
+Licensors can make available under this License.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works
+a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, You must include a readable copy of the attribution
+notices contained within such NOTICE file, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own license statement for Your modifications and
+may provide additional grant of rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or exemplary damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or all other
+commercial damages or losses), even if such Contributor has been
+advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may offer only
+conditions consistent with this License.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2024 hasna.com
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/recordings",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "description": "Speech-to-text recording tool with MCP and CLI — records, transcribes, and optionally enhances text using AI",
   "main": "dist/index.js",
@@ -38,9 +38,9 @@
     "typescript": "^5.8.2"
   },
   "publishConfig": {
-    "access": "restricted",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": "Hasna <andrei@hasna.com>"
 }

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)
+        }
+    }
+}