@hasna/economy 0.5.4 → 0.5.6

package/native/Tools/pair-qr.swift

@@ -0,0 +1,223 @@
+// Shows the Economy pairing code as a QR code in the terminal, for the iPhone app's Connect → Scan code.
+// Run it through native/Tools/pair-qr.py. The one-use code is issued inside the owner's Terminal:
+// it is never an argument, never written to a file, and the screen and its
+// scrollback are cleared once the code has been scanned.
+//
+// QR codes come from CoreImage's built-in CIQRCodeGenerator, so no extra tool is needed.
+// `--self-test` renders a synthetic code the same way and decodes it with CoreImage's detector.
+import CoreImage
+import Foundation
+
+/// The same text as Pairing.code(server:key:) in the app.
+func pairingCode(server: String, key: String) -> String {
+    let unreserved = CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~")
+    func escaped(_ text: String) -> String { text.addingPercentEncoding(withAllowedCharacters: unreserved) ?? "" }
+    return "hasna-economy://connect?server=\(escaped(server))&key=\(escaped(key))"
+}
+
+/// The QR modules, row by row from the top, true for dark. One pixel per module from CoreImage.
+func qrModules(_ text: String) -> [[Bool]]? {
+    guard let filter = CIFilter(name: "CIQRCodeGenerator") else { return nil }
+    filter.setValue(Data(text.utf8), forKey: "inputMessage")
+    filter.setValue("M", forKey: "inputCorrectionLevel")
+    guard let image = filter.outputImage else { return nil }
+    let extent = image.extent.integral
+    let width = Int(extent.width)
+    let height = Int(extent.height)
+    var pixels = [UInt8](repeating: 0, count: width * height * 4)
+    CIContext().render(image, toBitmap: &pixels, rowBytes: width * 4, bounds: extent, format: .RGBA8,
+                       colorSpace: CGColorSpaceCreateDeviceRGB())
+    return (0..<height).map { y in (0..<width).map { x in pixels[(y * width + x) * 4] < 128 } }
+}
+
+/// Adds a light margin of `quiet` modules on every side.
+func withQuietZone(_ modules: [[Bool]], _ quiet: Int = 4) -> [[Bool]] {
+    let width = (modules.first?.count ?? 0) + quiet * 2
+    let blank = [Bool](repeating: false, count: width)
+    let pad = [Bool](repeating: false, count: quiet)
+    return Array(repeating: blank, count: quiet) + modules.map { pad + $0 + pad } + Array(repeating: blank, count: quiet)
+}
+
+/// Two module rows per text line with half blocks, black on white whatever the terminal theme.
+func terminalLines(_ modules: [[Bool]]) -> [String] {
+    var rows = modules
+    if rows.count % 2 == 1 { rows.append([Bool](repeating: false, count: rows.first?.count ?? 0)) }
+    return stride(from: 0, to: rows.count, by: 2).map { y in
+        let line = zip(rows[y], rows[y + 1]).map { top, bottom -> String in
+            switch (top, bottom) {
+            case (true, true): "█"
+            case (true, false): "▀"
+            case (false, true): "▄"
+            case (false, false): " "
+            }
+        }.joined()
+        return "\u{1B}[30;107m" + line + "\u{1B}[0m"
+    }
+}
+
+/// Reads the modules back from the terminal lines, to prove they encode exactly the code.
+func modulesFromLines(_ lines: [String]) -> [[Bool]] {
+    lines.flatMap { line -> [[Bool]] in
+        let body = line.replacingOccurrences(of: "\u{1B}[30;107m", with: "").replacingOccurrences(of: "\u{1B}[0m", with: "")
+        let top = body.map { $0 == "█" || $0 == "▀" }
+        let bottom = body.map { $0 == "█" || $0 == "▄" }
+        return [top, bottom]
+    }
+}
+
+/// Decodes a module grid with CoreImage's QR detector, drawn as the terminal shows it.
+func decode(_ modules: [[Bool]]) -> String? {
+    let scale = 8
+    let height = modules.count
+    let width = modules.first?.count ?? 0
+    var pixels = [UInt8](repeating: 255, count: width * scale * height * scale)
+    for (y, row) in modules.enumerated() {
+        for (x, dark) in row.enumerated() where dark {
+            for dy in 0..<scale {
+                for dx in 0..<scale { pixels[(y * scale + dy) * width * scale + x * scale + dx] = 0 }
+            }
+        }
+    }
+    guard let provider = CGDataProvider(data: Data(pixels) as CFData),
+          let cgImage = CGImage(width: width * scale, height: height * scale, bitsPerComponent: 8, bitsPerPixel: 8,
+                                bytesPerRow: width * scale, space: CGColorSpaceCreateDeviceGray(),
+                                bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue),
+                                provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent),
+          let detector = CIDetector(ofType: CIDetectorTypeQRCode, context: nil, options: [CIDetectorAccuracy: CIDetectorAccuracyHigh])
+    else { return nil }
+    return (detector.features(in: CIImage(cgImage: cgImage)).first as? CIQRCodeFeature)?.messageString
+}
+
+/// A QR finder pattern sits in the top-left, top-right and bottom-left corners, never bottom-right.
+func isUpright(_ modules: [[Bool]]) -> Bool {
+    let size = modules.count
+    func finder(_ x: Int, _ y: Int) -> Bool {
+        (0..<7).allSatisfy { i in modules[y][x + i] && modules[y + 6][x + i] && modules[y + i][x] && modules[y + i][x + 6] }
+            && modules[y + 3][x + 3]
+    }
+    guard size >= 21, modules.allSatisfy({ $0.count == size }) else { return false }
+    return finder(0, 0) && finder(size - 7, 0) && finder(0, size - 7) && !finder(size - 7, size - 7)
+}
+
+func fail(_ message: String, _ code: Int32) -> Never {
+    FileHandle.standardError.write(Data((message + "\n").utf8))
+    exit(code)
+}
+
+/// Check the real ancestry as well as the TTY: a captured harness PTY is still a TTY.
+/// This prevents accidental transcript output, not access by other owner processes.
+func ownerTerminal(environment: [String: String], tty: Bool, parent: Int32,
+                   lookup: (Int32) -> (Int32, String)?) -> Bool {
+    guard tty else { return false }
+    for key in ["CODEX_THREAD_ID", "CODEX_INTERNAL_ORIGINATOR_OVERRIDE", "CLAUDECODE", "SUMI_SESSION_ID", "OPENCODE_SESSION_ID"] {
+        if let value = environment[key], !value.isEmpty { return false }
+    }
+    var pid = parent
+    for _ in 0..<12 {
+        guard let (next, executable) = lookup(pid) else { return false }
+        if executable == "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal" { return true }
+        guard ["Python", "python3", "bash", "zsh", "login", "bun", "secrets", "swift", "swift-frontend"]
+                .contains(URL(fileURLWithPath: executable).lastPathComponent), next > 1, next != pid else { return false }
+        pid = next
+    }
+    return false
+}
+
+func parentProcess(_ pid: Int32) -> (Int32, String)? {
+    let process = Process()
+    let output = Pipe()
+    process.executableURL = URL(fileURLWithPath: "/bin/ps")
+    process.arguments = ["-p", String(pid), "-o", "ppid=", "-o", "comm="]
+    process.standardOutput = output
+    process.standardError = FileHandle.nullDevice
+    do { try process.run() } catch { return nil }
+    let data = output.fileHandleForReading.readDataToEndOfFile()
+    process.waitUntilExit()
+    guard process.terminationStatus == 0, data.count <= 4096,
+          let text = String(data: data, encoding: .utf8) else { return nil }
+    let fields = text.trimmingCharacters(in: .whitespacesAndNewlines).split(maxSplits: 1, whereSeparator: { $0.isWhitespace })
+    guard fields.count == 2, let next = Int32(fields[0]) else { return nil }
+    return (next, String(fields[1]))
+}
+
+func selfTest() {
+    let terminal = "/System/Applications/Utilities/Terminal.app/Contents/MacOS/Terminal"
+    guard !ownerTerminal(environment: [:], tty: true, parent: 100, lookup: { _ in (200, "/runtime/codex") }),
+          !ownerTerminal(environment: [:], tty: false, parent: 100, lookup: { _ in (200, terminal) }),
+          !ownerTerminal(environment: ["CODEX_THREAD_ID": "fixture"], tty: true, parent: 100, lookup: { _ in (200, terminal) }),
+          !ownerTerminal(environment: [:], tty: true, parent: 100, lookup: { _ in nil }),
+          ownerTerminal(environment: [:], tty: true, parent: 100, lookup: { pid in
+              pid == 100 ? (200, "/usr/bin/python3") : (300, terminal)
+          }) else { fail("pair-qr self-test: FAIL (owner Terminal boundary)", 1) }
+    // A synthetic key with characters that need escaping; not a credential.
+    let key = "selftest-" + UUID().uuidString + "+/=&"
+    let code = pairingCode(server: "https://api.hasna.com/economy", key: key)
+    guard let modules = qrModules(code) else { fail("pair-qr self-test: FAIL (CoreImage made no QR code)", 1) }
+    let trimmed = trimQuietZone(modules)
+    guard isUpright(trimmed) else { fail("pair-qr self-test: FAIL (the code is mirrored or rotated)", 1) }
+    let lines = terminalLines(withQuietZone(trimmed))
+    guard decode(modulesFromLines(lines)) == code else { fail("pair-qr self-test: FAIL (the terminal rendering does not decode to the code)", 1) }
+    print("pair-qr self-test: PASS (\(trimmed.count)x\(trimmed.count) modules, \(lines.count) terminal lines, decoded to the exact pairing code)")
+}
+
+/// CoreImage adds its own margin; drop it so the finder patterns sit at the edges.
+func trimQuietZone(_ modules: [[Bool]]) -> [[Bool]] {
+    let rows = modules.indices.filter { modules[$0].contains(true) }
+    let columns = (0..<(modules.first?.count ?? 0)).filter { x in modules.contains { $0[x] } }
+    guard let top = rows.first, let bottom = rows.last, let left = columns.first, let right = columns.last else { return modules }
+    return modules[top...bottom].map { Array($0[left...right]) }
+}
+
+/// Clears the screen and the terminal's scrollback.
+let clearSequence = "\u{1B}[2J\u{1B}[3J\u{1B}[H"
+
+/// Ctrl-C, a hang-up or a kill also clear the code before exiting. Kept alive for the whole run.
+var signalSources: [DispatchSourceSignal] = []
+
+func clearOnSignals() {
+    for number in [SIGINT, SIGTERM, SIGHUP] {
+        signal(number, SIG_IGN)
+        let source = DispatchSource.makeSignalSource(signal: number, queue: .global())
+        source.setEventHandler {
+            FileHandle.standardOutput.write(Data(clearSequence.utf8))
+            exit(128 + number)
+        }
+        source.resume()
+        signalSources.append(source)
+    }
+}
+
+func show() {
+    let environment = ProcessInfo.processInfo.environment
+    guard let key = environment["ECONOMY_PAIR_CODE"], !key.isEmpty else { fail("ECONOMY_PAIR_CODE is not set", 2) }
+    unsetenv("ECONOMY_PAIR_CODE")
+    let server = environment["ECONOMY_PAIR_SERVER"] ?? "https://api.hasna.com/economy"
+    guard ownerTerminal(environment: environment, tty: isatty(STDOUT_FILENO) != 0 && isatty(STDIN_FILENO) != 0,
+                        parent: getppid(), lookup: parentProcess) else {
+        fail("Refusing to show a connection code outside the direct owner Terminal path.", 3)
+    }
+    guard let modules = qrModules(pairingCode(server: server, key: key)) else { fail("CoreImage made no QR code", 1) }
+    let lines = terminalLines(withQuietZone(trimQuietZone(modules)))
+    guard key.range(of: "^hec_[A-Za-z0-9_-]{43}$", options: .regularExpression) != nil,
+          server == "https://api.hasna.com/economy" else { fail("Invalid Economy pairing request", 2) }
+    clearOnSignals()
+    let lifetime = max(1, min(290, Int(environment["ECONOMY_PAIR_TTL"] ?? "290") ?? 290))
+    DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(lifetime)) {
+        FileHandle.standardOutput.write(Data(clearSequence.utf8))
+        exit(0)
+    }
+    print("")
+    lines.forEach { print("  " + $0) }
+    print("\n  Economy → Connect → Scan code. Server: \(server)")
+    print("  Press Return when the iPhone has connected; the screen and scrollback are then cleared (Ctrl-C clears too). This screen closes within five minutes.")
+    if let tty = FileHandle(forReadingAtPath: "/dev/tty") {
+        _ = tty.availableData
+    }
+    print(clearSequence, terminator: "")
+}
+
+if CommandLine.arguments.contains("--self-test") {
+    selfTest()
+} else {
+    show()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/economy",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "AI coding cost tracker — CLI + MCP server + REST API for Claude Code, Codex, OpenCode, Cursor, Pi, and Hermes, with legacy Gemini CLI session and Gemini API billing ingestion",
   "repository": {
     "type": "git",
@@ -33,6 +33,8 @@
   "files": [
     "dist",
     "docs",
+    "native/Tools/pair-qr.py",
+    "native/Tools/pair-qr.swift",
     "postinstall.js",
     "LICENSE",
     "README.md",