adsinagents 0.1.0

package/native/build.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Compile AdLine native helpers (statusline + frontmost) with swiftc.
+# Usage: build.sh [OUT_DIR]   (default: ./build)
+# Exits 3 if swiftc is unavailable so callers can fall back to the Node statusline.
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+OUT="${1:-$HERE/build}"
+
+if ! xcrun --find swiftc >/dev/null 2>&1 && ! command -v swiftc >/dev/null 2>&1; then
+  echo "swiftc not found (install Xcode Command Line Tools: xcode-select --install)" >&2
+  exit 3
+fi
+
+mkdir -p "$OUT"
+
+echo "Compiling adsinagents-statusline..." >&2
+swiftc -O "$HERE/statusline.swift" -o "$OUT/adsinagents-statusline"
+
+echo "Compiling frontmost..." >&2
+swiftc -O "$HERE/frontmost.swift" -o "$OUT/frontmost"
+
+echo "Built: $OUT/adsinagents-statusline, $OUT/frontmost" >&2

package/native/frontmost.swift

@@ -0,0 +1,51 @@
+// AdLine frontmost probe — prints the frontmost app bundle id, screen-lock
+// state, and display-awake state as one JSON line, then exits. Used by the
+// daemon's focus poller (≤ 1 Hz) to decide terminal-focus for viewability.
+//
+// Output: {"bundleId":"com.googlecode.iterm2","locked":false,"screenAwake":true}
+// Falls back gracefully: unknown fields default to safe values.
+
+import Foundation
+import AppKit
+import CoreGraphics
+
+func frontmostBundleId() -> String {
+    if let app = NSWorkspace.shared.frontmostApplication {
+        return app.bundleIdentifier ?? ""
+    }
+    return ""
+}
+
+/// Screen locked? CGSessionCopyCurrentDictionary exposes CGSSessionScreenIsLocked.
+func screenLocked() -> Bool {
+    guard let dict = CGSessionCopyCurrentDictionary() as? [String: Any] else {
+        return false
+    }
+    if let locked = dict["CGSSessionScreenIsLocked"] as? Int {
+        return locked == 1
+    }
+    if let locked = dict["CGSSessionScreenIsLocked"] as? Bool {
+        return locked
+    }
+    return false
+}
+
+/// Display asleep? If the display is off we should not count impressions.
+func displayAwake() -> Bool {
+    // CGDisplayIsActive on the main display. True when awake/active.
+    let main = CGMainDisplayID()
+    return CGDisplayIsActive(main) != 0 && CGDisplayIsAsleep(main) == 0
+}
+
+let payload: [String: Any] = [
+    "bundleId": frontmostBundleId(),
+    "locked": screenLocked(),
+    "screenAwake": displayAwake(),
+]
+
+if let data = try? JSONSerialization.data(withJSONObject: payload),
+   let str = String(data: data, encoding: .utf8) {
+    print(str)
+} else {
+    print("{\"bundleId\":\"\",\"locked\":false,\"screenAwake\":true}")
+}

package/native/statusline.swift

@@ -0,0 +1,120 @@
+// AdsInAgents statusline — native macOS build. Reads two small JSON files + stdin,
+// prints one status line, exits. Target: < 5ms wall (vs ~50ms for Node).
+//
+// HARD CONSTRAINTS:
+//   - Zero network. Zero deps beyond Foundation.
+//   - Never throw to the terminal: any failure => print prior (or empty), exit 0.
+//
+// Reads:
+//   - ~/.adsinagents/current-ad.json   (Ad, written by daemon)
+//   - ~/.adsinagents/daemon-state.json (DaemonState)
+//   - stdin                            (Claude Code session JSON, only used to
+//                                       feed the chained prior statusline)
+// Env:
+//   - ADSINAGENTS_PRIOR_STATUSLINE     (optional shell cmd to chain)
+//   - TERM_PROGRAM / FORCE_HYPERLINK   (OSC 8 capability)
+//   - ADSINAGENTS_HOME                 (override ~/.adsinagents, for tests)
+
+import Foundation
+
+let STATE_STALE_MS: Double = 30_000
+
+func adlineDir() -> String {
+    if let override = ProcessInfo.processInfo.environment["ADSINAGENTS_HOME"], !override.isEmpty {
+        return override
+    }
+    let home = ProcessInfo.processInfo.environment["HOME"] ?? NSHomeDirectory()
+    return home + "/.adsinagents"
+}
+
+func readJSON(_ path: String) -> [String: Any]? {
+    guard let data = FileManager.default.contents(atPath: path) else { return nil }
+    return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
+}
+
+func readStdin() -> String {
+    let data = FileHandle.standardInput.readDataToEndOfFile()
+    return String(data: data, encoding: .utf8) ?? ""
+}
+
+func supportsOSC8() -> Bool {
+    let env = ProcessInfo.processInfo.environment
+    if env["FORCE_HYPERLINK"] == "1" { return true }
+    if env["TERM_PROGRAM"] == "Apple_Terminal" { return false }
+    return true
+}
+
+/// Run the user's pre-existing statusline command, feeding it the session JSON.
+func priorStatusline(_ stdinJSON: String) -> String {
+    guard let cmd = ProcessInfo.processInfo.environment["ADSINAGENTS_PRIOR_STATUSLINE"],
+          !cmd.isEmpty else { return "" }
+    let proc = Process()
+    proc.executableURL = URL(fileURLWithPath: "/bin/sh")
+    proc.arguments = ["-c", cmd]
+    let outPipe = Pipe()
+    let inPipe = Pipe()
+    proc.standardOutput = outPipe
+    proc.standardError = FileHandle.nullDevice
+    proc.standardInput = inPipe
+    do {
+        try proc.run()
+        if let d = stdinJSON.data(using: .utf8) { inPipe.fileHandleForWriting.write(d) }
+        inPipe.fileHandleForWriting.closeFile()
+        let out = outPipe.fileHandleForReading.readDataToEndOfFile()
+        proc.waitUntilExit()
+        return (String(data: out, encoding: .utf8) ?? "")
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+    } catch {
+        return ""
+    }
+}
+
+func osc8(_ url: String, _ text: String) -> String {
+    return "\u{1b}]8;;\(url)\u{07}\(text)\u{1b}]8;;\u{07}"
+}
+
+func emit(_ line: String) {
+    print(line)
+}
+
+// --- main ---
+
+let stdinJSON = readStdin()
+let prior = priorStatusline(stdinJSON)
+
+func printPriorAndExit() -> Never {
+    emit(prior)
+    exit(0)
+}
+
+let dir = adlineDir()
+guard let state = readJSON(dir + "/daemon-state.json") else { printPriorAndExit() }
+
+let updatedAt = (state["updatedAt"] as? Double) ?? (state["updatedAt"] as? Int).map(Double.init) ?? 0
+let nowMs = Date().timeIntervalSince1970 * 1000
+let stale = (nowMs - updatedAt) > STATE_STALE_MS
+let disabled = (state["disabled"] as? Bool) ?? false
+let adVisible = (state["adVisible"] as? Bool) ?? false
+let port = (state["port"] as? Int) ?? (state["port"] as? Double).map(Int.init) ?? 0
+
+if stale || disabled || !adVisible { printPriorAndExit() }
+
+guard let ad = readJSON(dir + "/current-ad.json"),
+      let id = ad["id"] as? String,
+      let text = ad["text"] as? String,
+      !id.isEmpty, !text.isEmpty else { printPriorAndExit() }
+
+let brand = (ad["brandName"] as? String) ?? ""
+let label = brand.isEmpty ? text : "\(text) — \(brand)"
+let core = "\u{2736} \(label) \u{2197}" // ✶ … ↗
+let clickURL = "http://127.0.0.1:\(port)/click/\(id)"
+let linked = supportsOSC8() ? osc8(clickURL, core) : core
+let segment = "Ad: \(linked) · sponsored"
+
+let final: String
+if prior.isEmpty {
+    final = segment
+} else {
+    final = "\(prior) \u{2502} \(segment)" // │
+}
+emit(final)

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "adsinagents",
+  "version": "0.1.0",
+  "description": "Get paid while you build. A terminal-native ad layer for Claude Code that pays you for every verified impression.",
+  "homepage": "https://adsinagents.com",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "adsinagents": "./cli/dist/index.js",
+    "adsinagents-daemon": "./daemon/dist/main.js",
+    "adsinagents-statusline": "./statusline/dist/index.js"
+  },
+  "files": [
+    "cli",
+    "daemon",
+    "statusline",
+    "native",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^11.7.0"
+  }
+}