poke-gate 0.0.2 → 0.0.4

package/clients/Poke macOS Gate/Poke macOS Gate/GateService.swift

@@ -0,0 +1,241 @@
+import Foundation
+import Combine
+import ScreenCaptureKit
+
+@MainActor
+class GateService: ObservableObject {
+    enum Status: String {
+        case stopped = "Stopped"
+        case starting = "Starting…"
+        case connected = "Connected"
+        case disconnected = "Disconnected"
+        case error = "Error"
+    }
+
+    @Published var status: Status = .stopped
+    @Published var logs: [String] = []
+    @Published var userName: String? = nil
+
+    private var hasAutoStarted = false
+    private var process: Process?
+    private var outputPipe: Pipe?
+    private var shouldRestart = true
+    private let maxLogs = 200
+
+    var apiKey: String {
+        get { loadAPIKey() ?? "" }
+        set { saveAPIKey(newValue) }
+    }
+
+    var hasAPIKey: Bool {
+        let key = loadAPIKey()
+        return key != nil && !key!.isEmpty
+    }
+
+    func autoStartIfNeeded() {
+        guard !hasAutoStarted else { return }
+        hasAutoStarted = true
+        requestScreenCapturePermission()
+        if hasAPIKey {
+            start()
+        }
+    }
+
+    private func requestScreenCapturePermission() {
+        Task {
+            do {
+                _ = try await SCShareableContent.current
+            } catch {
+                appendLog("Screen capture permission not granted yet.")
+            }
+        }
+    }
+
+    func start() {
+        guard hasAPIKey else {
+            status = .error
+            appendLog("No API key configured.")
+            return
+        }
+        shouldRestart = true
+        fetchUserName()
+        launchProcess()
+    }
+
+    private func fetchUserName() {
+        guard let key = loadAPIKey() else { return }
+        Task {
+            let url = URL(string: "https://poke.com/api/v1/user/profile")!
+            var request = URLRequest(url: url)
+            request.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")
+            do {
+                let (data, response) = try await URLSession.shared.data(for: request)
+                guard let httpResp = response as? HTTPURLResponse, httpResp.statusCode == 200 else { return }
+                if let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                   let fullName = json["name"] as? String ?? json["email"] as? String {
+                    let firstName = fullName.components(separatedBy: CharacterSet.whitespaces.union(CharacterSet(charactersIn: "@"))).first ?? fullName
+                    self.userName = firstName
+                }
+            } catch {}
+        }
+    }
+
+    func stop() {
+        shouldRestart = false
+        killProcess()
+        status = .stopped
+    }
+
+    func restart() {
+        stop()
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            self.start()
+        }
+    }
+
+    private func shellPath() -> String {
+        let loginShell = ProcessInfo.processInfo.environment["SHELL"] ?? "/bin/zsh"
+        let pathProc = Process()
+        let pathPipe = Pipe()
+        pathProc.executableURL = URL(fileURLWithPath: loginShell)
+        pathProc.arguments = ["-ilc", "echo $PATH"]
+        pathProc.standardOutput = pathPipe
+        pathProc.standardError = FileHandle.nullDevice
+        pathProc.environment = ["HOME": NSHomeDirectory()]
+        try? pathProc.run()
+        pathProc.waitUntilExit()
+        let data = pathPipe.fileHandleForReading.readDataToEndOfFile()
+        return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+    }
+
+    private func launchProcess() {
+        killProcess()
+
+        status = .starting
+        appendLog("Starting poke-gate…")
+
+        let fullPath = shellPath()
+
+        let proc = Process()
+        let pipe = Pipe()
+
+        proc.executableURL = URL(fileURLWithPath: "/bin/zsh")
+        proc.arguments = ["-c", "npx -y poke-gate --verbose"]
+        proc.environment = ProcessInfo.processInfo.environment.merging(
+            [
+                "POKE_API_KEY": loadAPIKey() ?? "",
+                "PATH": fullPath,
+            ],
+            uniquingKeysWith: { _, new in new }
+        )
+        proc.standardOutput = pipe
+        proc.standardError = pipe
+        proc.currentDirectoryURL = FileManager.default.homeDirectoryForCurrentUser
+
+        let handle = pipe.fileHandleForReading
+        handle.readabilityHandler = { [weak self] fh in
+            let data = fh.availableData
+            guard !data.isEmpty, let line = String(data: data, encoding: .utf8) else { return }
+            DispatchQueue.main.async {
+                self?.handleOutput(line)
+            }
+        }
+
+        proc.terminationHandler = { [weak self] proc in
+            DispatchQueue.main.async {
+                self?.handleTermination(exitCode: proc.terminationStatus)
+            }
+        }
+
+        do {
+            try proc.run()
+            self.process = proc
+            self.outputPipe = pipe
+        } catch {
+            status = .error
+            appendLog("Failed to start: \(error.localizedDescription)")
+        }
+    }
+
+    private func killProcess() {
+        if let proc = process, proc.isRunning {
+            proc.terminate()
+        }
+        outputPipe?.fileHandleForReading.readabilityHandler = nil
+        process = nil
+        outputPipe = nil
+    }
+
+    private func handleOutput(_ raw: String) {
+        for line in raw.components(separatedBy: .newlines) where !line.isEmpty {
+            appendLog(line)
+
+            if line.contains("Tunnel connected") || line.contains("Ready") {
+                status = .connected
+            } else if line.contains("Tunnel disconnected") || line.contains("Reconnecting") {
+                status = .disconnected
+            } else if line.contains("Failed to connect") || line.contains("error") {
+                if status != .connected {
+                    status = .error
+                }
+            }
+        }
+    }
+
+    private func handleTermination(exitCode: Int32) {
+        appendLog("Process exited with code \(exitCode)")
+        if shouldRestart {
+            status = .disconnected
+            appendLog("Restarting in 2 seconds…")
+            DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
+                if self.shouldRestart {
+                    self.launchProcess()
+                }
+            }
+        } else {
+            status = .stopped
+        }
+    }
+
+    private func appendLog(_ line: String) {
+        let ts = DateFormatter.localizedString(from: Date(), dateStyle: .none, timeStyle: .medium)
+        logs.append("[\(ts)] \(line)")
+        if logs.count > maxLogs {
+            logs.removeFirst(logs.count - maxLogs)
+        }
+    }
+
+    // MARK: - Config
+
+    private var configURL: URL {
+        let configDir: URL
+        if let xdg = ProcessInfo.processInfo.environment["XDG_CONFIG_HOME"] {
+            configDir = URL(fileURLWithPath: xdg)
+        } else {
+            configDir = FileManager.default.homeDirectoryForCurrentUser
+                .appendingPathComponent(".config")
+        }
+        return configDir
+            .appendingPathComponent("poke-gate")
+            .appendingPathComponent("config.json")
+    }
+
+    private func loadAPIKey() -> String? {
+        guard let data = try? Data(contentsOf: configURL),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let key = json["apiKey"] as? String else {
+            return nil
+        }
+        return key
+    }
+
+    private func saveAPIKey(_ key: String) {
+        let dir = configURL.deletingLastPathComponent()
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let json: [String: Any] = ["apiKey": key]
+        if let data = try? JSONSerialization.data(withJSONObject: json, options: [.prettyPrinted]) {
+            try? data.write(to: configURL)
+        }
+        objectWillChange.send()
+    }
+}

package/clients/Poke macOS Gate/Poke macOS Gate/Info.plist

@@ -0,0 +1,8 @@
+<?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/>
+</dict>
+</plist>

package/clients/Poke macOS Gate/Poke macOS Gate/Item.swift

@@ -0,0 +1,2 @@
+// Unused — kept for Xcode project reference compatibility
+import Foundation

package/clients/Poke macOS Gate/Poke macOS Gate/LogsView.swift

@@ -0,0 +1,47 @@
+import SwiftUI
+
+struct LogsView: View {
+    @ObservedObject var service: GateService
+
+    var body: some View {
+        VStack(spacing: 0) {
+            HStack {
+                Text("Logs")
+                    .font(.headline)
+                Spacer()
+                Button("Clear") {
+                    service.logs.removeAll()
+                }
+                .buttonStyle(.plain)
+                .foregroundStyle(.secondary)
+                .font(.caption)
+            }
+            .padding(.horizontal, 12)
+            .padding(.vertical, 8)
+
+            Divider()
+
+            ScrollViewReader { proxy in
+                ScrollView {
+                    LazyVStack(alignment: .leading, spacing: 2) {
+                        ForEach(Array(service.logs.enumerated()), id: \.offset) { index, line in
+                            Text(line)
+                                .font(.system(.caption, design: .monospaced))
+                                .foregroundStyle(.primary)
+                                .textSelection(.enabled)
+                                .id(index)
+                        }
+                    }
+                    .padding(.horizontal, 12)
+                    .padding(.vertical, 8)
+                }
+                .onChange(of: service.logs.count) { _, _ in
+                    if let last = service.logs.indices.last {
+                        proxy.scrollTo(last, anchor: .bottom)
+                    }
+                }
+            }
+        }
+        .frame(width: 480, height: 320)
+    }
+}

package/clients/Poke macOS Gate/Poke macOS Gate/Poke_macOS_GateApp.swift

@@ -0,0 +1,140 @@
+import SwiftUI
+
+@main
+struct Poke_macOS_GateApp: App {
+    @StateObject private var service = GateService()
+
+    var body: some Scene {
+        MenuBarExtra {
+            MenuBarContent(service: service)
+                .onAppear { service.autoStartIfNeeded() }
+        } label: {
+            Image(systemName: menuBarIcon)
+        }
+
+        Window("Logs", id: "logs") {
+            LogsView(service: service)
+        }
+        .defaultSize(width: 480, height: 320)
+
+        Window("Settings", id: "settings") {
+            SettingsView(service: service)
+        }
+        .windowResizability(.contentSize)
+    }
+
+    private var menuBarIcon: String {
+        switch service.status {
+        case .connected: "door.left.hand.open"
+        case .starting, .disconnected: "door.left.hand.closed"
+        case .error: "exclamationmark.triangle"
+        case .stopped: "door.left.hand.closed"
+        }
+    }
+}
+
+struct MenuBarContent: View {
+    @ObservedObject var service: GateService
+    @Environment(\.openWindow) private var openWindow
+
+    var body: some View {
+        Label(statusText, systemImage: statusIcon)
+            .foregroundStyle(statusColor)
+
+        if service.status == .connected {
+            Text("This machine is now accessible via Poke.")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+            Text("Ask your Poke to run commands or read files.")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        } else if service.status == .starting {
+            Text("Establishing connection…")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        } else if service.status == .error {
+            Text("Check Settings or view Logs for details.")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+
+        Divider()
+
+        Button("View Logs…") {
+            NSApp.activate(ignoringOtherApps: true)
+            openWindow(id: "logs")
+        }
+
+        Button("Settings…") {
+            NSApp.activate(ignoringOtherApps: true)
+            openWindow(id: "settings")
+        }
+
+        Divider()
+
+        if service.status == .connected || service.status == .starting || service.status == .disconnected {
+            Button("Restart") {
+                service.restart()
+            }
+        } else {
+            Button("Start") {
+                service.start()
+            }
+        }
+
+        Divider()
+
+        Button("Quit Poke Gate") {
+            service.stop()
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                NSApp.terminate(nil)
+            }
+        }
+        .keyboardShortcut("q")
+
+        Divider()
+
+        Text("Poke Gate v0.0.3")
+            .font(.caption)
+            .foregroundStyle(.secondary)
+        Text("Community project — not affiliated with Poke")
+            .font(.caption2)
+            .foregroundStyle(.secondary)
+        Button("GitHub") {
+            NSWorkspace.shared.open(URL(string: "https://github.com/f/poke-gate")!)
+        }
+        .font(.caption)
+    }
+
+    private var statusText: String {
+        switch service.status {
+        case .connected:
+            if let name = service.userName {
+                return "Connected to your Poke, \(name)"
+            }
+            return "Connected to your Poke"
+        case .starting: return "Connecting…"
+        case .disconnected: return "Reconnecting…"
+        case .error: return "Connection error"
+        case .stopped: return "Stopped"
+        }
+    }
+
+    private var statusIcon: String {
+        switch service.status {
+        case .connected: "circle.fill"
+        case .starting, .disconnected: "circle.dotted"
+        case .error: "exclamationmark.circle.fill"
+        case .stopped: "circle"
+        }
+    }
+
+    private var statusColor: Color {
+        switch service.status {
+        case .connected: .green
+        case .starting, .disconnected: .yellow
+        case .error: .red
+        case .stopped: .secondary
+        }
+    }
+}

package/clients/Poke macOS Gate/Poke macOS Gate/SettingsView.swift

@@ -0,0 +1,50 @@
+import SwiftUI
+
+struct SettingsView: View {
+    @ObservedObject var service: GateService
+    @State private var apiKeyInput: String = ""
+    @Environment(\.dismiss) private var dismiss
+
+    var body: some View {
+        VStack(spacing: 16) {
+            Text("Poke Gate Settings")
+                .font(.headline)
+
+            VStack(alignment: .leading, spacing: 8) {
+                Text("API Key")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+
+                SecureField("Paste your API key", text: $apiKeyInput)
+                    .textFieldStyle(.roundedBorder)
+
+                Link("Get your key at poke.com/kitchen/api-keys",
+                     destination: URL(string: "https://poke.com/kitchen/api-keys")!)
+                    .font(.caption)
+                    .foregroundStyle(.blue)
+            }
+
+            HStack {
+                Button("Cancel") {
+                    dismiss()
+                }
+                .keyboardShortcut(.cancelAction)
+
+                Spacer()
+
+                Button("Save") {
+                    service.apiKey = apiKeyInput
+                    dismiss()
+                    service.restart()
+                }
+                .keyboardShortcut(.defaultAction)
+                .disabled(apiKeyInput.isEmpty)
+            }
+        }
+        .padding(20)
+        .frame(width: 360)
+        .onAppear {
+            apiKeyInput = service.apiKey
+        }
+    }
+}