@hasna/recordings 0.1.3 → 0.1.6

package/src/native/Recordings/Recordings/VoiceShortcuts.swift

@@ -0,0 +1,82 @@
+import SwiftUI
+
+// MARK: - Voice Shortcut
+
+struct VoiceShortcut: Identifiable, Codable {
+    let id: UUID
+    var trigger: String   // e.g. "add disclaimer"
+    var content: String   // text to insert when trigger is spoken
+
+    init(trigger: String, content: String) {
+        self.id = UUID()
+        self.trigger = trigger
+        self.content = content
+    }
+}
+
+// MARK: - Voice Shortcuts Manager
+
+@MainActor
+final class VoiceShortcuts: ObservableObject {
+    @Published var shortcuts: [VoiceShortcut] = []
+
+    private let storageURL: URL = {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        return home.appendingPathComponent(".recordings/voice-shortcuts.json")
+    }()
+
+    init() {
+        load()
+    }
+
+    func add(trigger: String, content: String) {
+        let shortcut = VoiceShortcut(trigger: trigger, content: content)
+        shortcuts.append(shortcut)
+        save()
+    }
+
+    func remove(at offsets: IndexSet) {
+        shortcuts.remove(atOffsets: offsets)
+        save()
+    }
+
+    func update(_ shortcut: VoiceShortcut) {
+        if let index = shortcuts.firstIndex(where: { $0.id == shortcut.id }) {
+            shortcuts[index] = shortcut
+            save()
+        }
+    }
+
+    /// Check if transcribed text matches a voice shortcut trigger.
+    /// Returns the content to paste if matched, nil otherwise.
+    func match(_ text: String) -> String? {
+        let lower = text.lowercased().trimmingCharacters(in: .whitespacesAndNewlines)
+        for shortcut in shortcuts {
+            if lower.contains(shortcut.trigger.lowercased()) {
+                return shortcut.content
+            }
+        }
+        return nil
+    }
+
+    // MARK: - Persistence
+
+    private func save() {
+        do {
+            let data = try JSONEncoder().encode(shortcuts)
+            try data.write(to: storageURL, options: .atomic)
+        } catch {
+            print("Failed to save voice shortcuts: \(error)")
+        }
+    }
+
+    private func load() {
+        guard FileManager.default.fileExists(atPath: storageURL.path) else { return }
+        do {
+            let data = try Data(contentsOf: storageURL)
+            shortcuts = try JSONDecoder().decode([VoiceShortcut].self, from: data)
+        } catch {
+            print("Failed to load voice shortcuts: \(error)")
+        }
+    }
+}

package/src/native/Recordings/build.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Build Recordings.app for macOS 26
+# Usage: ./build.sh [debug|release]
+
+set -euo pipefail
+
+MODE="${1:-release}"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "Building Recordings.app ($MODE)..."
+swift build -c "$MODE"
+
+# Create .app bundle
+BUILD_DIR=".build/$MODE"
+APP_DIR="$BUILD_DIR/Recordings.app"
+CONTENTS="$APP_DIR/Contents"
+MACOS="$CONTENTS/MacOS"
+
+rm -rf "$APP_DIR"
+mkdir -p "$MACOS"
+
+# Copy binary
+cp "$BUILD_DIR/Recordings" "$MACOS/Recordings"
+
+# Copy Info.plist
+cp Recordings/Info.plist "$CONTENTS/Info.plist"
+
+# Copy entitlements (for codesigning)
+if [ -f Recordings/Recordings.entitlements ]; then
+    codesign --force --sign - --entitlements Recordings/Recordings.entitlements "$APP_DIR" 2>/dev/null || true
+fi
+
+echo "✓ Built $APP_DIR"
+echo ""
+echo "To install to ~/.recordings/:"
+echo "  cp -r $APP_DIR ~/.recordings/Recordings.app"
+echo ""
+echo "To run:"
+echo "  open $APP_DIR"

package/src/native/Recordings/test_fn.swift

@@ -0,0 +1,79 @@
+#!/usr/bin/env swift
+// Quick test: can we see fn key events via CGEventTap?
+import Cocoa
+
+print("Listening for ALL key events for 15 seconds...")
+print("Press fn, F5, Option, or any key. Ctrl+C to quit.\n")
+
+let mask: CGEventMask =
+    (1 << CGEventType.flagsChanged.rawValue) |
+    (1 << CGEventType.keyDown.rawValue) |
+    (1 << CGEventType.keyUp.rawValue)
+
+let callback: CGEventTapCallBack = { proxy, type, event, refcon in
+    let keyCode = event.getIntegerValueField(.keyboardEventKeycode)
+    let flags = event.flags
+
+    if type == .flagsChanged {
+        let fn = flags.contains(.maskSecondaryFn) ? " [fn]" : ""
+        let cmd = flags.contains(.maskCommand) ? " [cmd]" : ""
+        let opt = flags.contains(.maskAlternate) ? " [opt]" : ""
+        let ctrl = flags.contains(.maskControl) ? " [ctrl]" : ""
+        let shift = flags.contains(.maskShift) ? " [shift]" : ""
+        print("flagsChanged  keyCode=\(keyCode)\(fn)\(cmd)\(opt)\(ctrl)\(shift)")
+    } else if type == .keyDown {
+        print("keyDown       keyCode=\(keyCode)")
+    } else if type == .keyUp {
+        print("keyUp         keyCode=\(keyCode)")
+    } else if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
+        print("TAP DISABLED — re-enabling")
+        if let refcon {
+            let tap = Unmanaged<AnyObject>.fromOpaque(refcon).takeUnretainedValue() as! CFMachPort
+            CGEvent.tapEnable(tap: tap, enable: true)
+        }
+    }
+
+    return Unmanaged.passRetained(event)
+}
+
+// Try HID-level tap first
+var tap = CGEvent.tapCreate(
+    tap: .cghidEventTap,
+    place: .headInsertEventTap,
+    options: .defaultTap,
+    eventsOfInterest: mask,
+    callback: callback,
+    userInfo: nil
+)
+
+if tap == nil {
+    print("⚠ cghidEventTap failed, trying cgSessionEventTap...")
+    tap = CGEvent.tapCreate(
+        tap: .cgSessionEventTap,
+        place: .headInsertEventTap,
+        options: .defaultTap,
+        eventsOfInterest: mask,
+        callback: callback,
+        userInfo: nil
+    )
+}
+
+guard let tap else {
+    print("❌ FAILED to create event tap. Grant Accessibility permission:")
+    print("   System Settings > Privacy & Security > Accessibility")
+    exit(1)
+}
+
+print("✅ Event tap created successfully\n")
+
+let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
+CFRunLoopAddSource(CFRunLoopGetCurrent(), source, .commonModes)
+CGEvent.tapEnable(tap: tap, enable: true)
+
+// Run for 15 seconds
+DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
+    print("\nDone.")
+    exit(0)
+}
+
+CFRunLoopRun()

package/src/native/Recordings/test_fn2.swift

@@ -0,0 +1,33 @@
+#!/usr/bin/env swift
+// Test: NSEvent.addGlobalMonitorForEvents — does it see fn key?
+import Cocoa
+
+print("Testing NSEvent global monitor for 15 seconds...")
+print("Press fn, Option, any key. Ctrl+C to quit.\n")
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+
+// Monitor flagsChanged (modifier keys including fn)
+NSEvent.addGlobalMonitorForEvents(matching: [.flagsChanged, .keyDown, .keyUp]) { event in
+    if event.type == .flagsChanged {
+        let fn = event.modifierFlags.contains(.function) ? " [fn]" : ""
+        let cmd = event.modifierFlags.contains(.command) ? " [cmd]" : ""
+        let opt = event.modifierFlags.contains(.option) ? " [opt]" : ""
+        let ctrl = event.modifierFlags.contains(.control) ? " [ctrl]" : ""
+        print("flagsChanged  keyCode=\(event.keyCode)\(fn)\(cmd)\(opt)\(ctrl)")
+    } else if event.type == .keyDown {
+        print("keyDown       keyCode=\(event.keyCode)  chars=\(event.characters ?? "")")
+    } else if event.type == .keyUp {
+        print("keyUp         keyCode=\(event.keyCode)")
+    }
+}
+
+print("✅ Global monitor registered\n")
+
+DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
+    print("\nDone.")
+    exit(0)
+}
+
+app.run()

package/src/native/RecordingsHelper.swift

@@ -60,11 +60,47 @@ class AppDelegate: NSObject, NSApplicationDelegate {
 
     // ── Global Hotkey ───────────────────────────────────────────────────────
 
+    /// Check if Accessibility permission is granted. If not, show a dialog and open System Settings.
+    func checkAccessibilityPermission() -> Bool {
+        // First check without prompting
+        let trusted = AXIsProcessTrustedWithOptions(
+            [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): false] as CFDictionary
+        )
+        if trusted { return true }
+
+        // Not trusted — show dialog explaining why we need it
+        let alert = NSAlert()
+        alert.messageText = "Accessibility Permission Required"
+        alert.informativeText = "RecordingsHelper needs Accessibility access to detect the global hotkey (hold Space to record).\n\nClick 'Open Settings' to grant permission, then restart the app."
+        alert.alertStyle = .warning
+        alert.addButton(withTitle: "Open Settings")
+        alert.addButton(withTitle: "Quit")
+
+        let response = alert.runModal()
+        if response == .alertFirstButtonReturn {
+            // Prompt the system dialog AND open System Settings > Accessibility
+            AXIsProcessTrustedWithOptions(
+                [kAXTrustedCheckOptionPrompt.takeUnretainedValue(): true] as CFDictionary
+            )
+            if let url = URL(string: "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility") {
+                NSWorkspace.shared.open(url)
+            }
+        } else {
+            NSApplication.shared.terminate(nil)
+        }
+        return false
+    }
+
     func registerHotkey() {
         // Hold Space for 1+ second to start recording, release to stop.
         // Uses CGEventTap to monitor all keyboard events globally.
         // Normal space presses (< 1 second) pass through untouched.
 
+        // Check Accessibility permission BEFORE attempting event tap
+        if !checkAccessibilityPermission() {
+            return
+        }
+
         let eventMask: CGEventMask = (1 << CGEventType.keyDown.rawValue) | (1 << CGEventType.keyUp.rawValue) | (1 << CGEventType.flagsChanged.rawValue)
 
         guard let tap = CGEvent.tapCreate(

package/src/types/index.ts

@@ -14,6 +14,9 @@ export interface Recording {
   agent_id: string | null;
   project_id: string | null;
   session_id: string | null;
+  goal: string | null;
+  role: string | null;
+  task_list_id: string | null;
   metadata: Record<string, unknown>;
   created_at: string;
 }
@@ -33,6 +36,9 @@ export interface CreateRecordingInput {
   agent_id?: string;
   project_id?: string;
   session_id?: string;
+  goal?: string;
+  role?: string;
+  task_list_id?: string;
   metadata?: Record<string, unknown>;
 }