@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/computer-access/companion/observation-macos-permission.js

@@ -0,0 +1,26 @@
+/** Pure Swift permission gate; injected effects keep native tests free of TCC requests. */
+export const MACOS_OBSERVATION_PERMISSION_SCRIPT = String.raw `
+func waitForMacObservationPermission(
+  isTrusted: () -> Bool,
+  requestPermission: () -> Void,
+  now: () -> Double,
+  wait: (Double) -> Void,
+  reportRequired: () -> Void,
+  reportTimeout: () -> Void
+) -> Bool {
+  if isTrusted() { return true }
+  let deadline = now() + 120
+  requestPermission()
+  reportRequired()
+  while true {
+    let remaining = deadline - now()
+    let permissionWaitExpired = remaining <= 0
+    if permissionWaitExpired {
+      reportTimeout()
+      return false
+    }
+    wait(min(2, remaining))
+    if isTrusted() { return true }
+  }
+}
+`;

package/dist/src/computer-access/companion/observation-macos.d.ts

@@ -0,0 +1 @@
+export declare const MACOS_OBSERVATION_SCRIPT: string;

package/dist/src/computer-access/companion/observation-macos.js

@@ -0,0 +1,189 @@
+/** Swift/AppKit event helper. Missing developer tools or Accessibility grant is reported explicitly. */
+import { OBSERVATION_CAPTURE_POLICY as policy } from "./observation-capture-policy.js";
+import { MACOS_OBSERVATION_PERMISSION_SCRIPT } from "./observation-macos-permission.js";
+export const MACOS_OBSERVATION_SCRIPT = String.raw `
+import AppKit
+import ApplicationServices
+func emit(_ value: [String: Any]) {
+  if let data = try? JSONSerialization.data(withJSONObject: value), let text = String(data: data, encoding: .utf8) {
+    print(text); fflush(stdout)
+  }
+}
+func status(_ state: String, _ reason: String) { emit(["type":"status","state":state,"reason":reason]) }
+${MACOS_OBSERVATION_PERMISSION_SCRIPT}
+guard waitForMacObservationPermission(
+  isTrusted: { AXIsProcessTrusted() },
+  requestPermission: {
+    let options = [kAXTrustedCheckOptionPrompt.takeUnretainedValue() as String: true] as CFDictionary
+    _ = AXIsProcessTrustedWithOptions(options)
+  },
+  now: { ProcessInfo.processInfo.systemUptime },
+  wait: { Thread.sleep(forTimeInterval: $0) },
+  reportRequired: { status("permission_required","macos_accessibility_permission_required") },
+  reportTimeout: { status("permission_required","macos_accessibility_permission_timeout") }
+) else { exit(0) }
+let exclusions = Set(((ProcessInfo.processInfo.environment["ABOT_OBSERVATION_EXCLUSIONS"] ?? "[]").data(using:.utf8).flatMap { try? JSONSerialization.jsonObject(with:$0) as? [String] } ?? []).map { $0.lowercased() })
+func attr(_ element: AXUIElement, _ name: String) -> CFTypeRef? {
+  var value: CFTypeRef?
+  return AXUIElementCopyAttributeValue(element,name as CFString,&value) == .success ? value : nil
+}
+func window(_ app: NSRunningApplication) -> AXUIElement? {
+  let root = AXUIElementCreateApplication(app.processIdentifier)
+  guard let value = attr(root,kAXFocusedWindowAttribute) else { return nil }
+  guard CFGetTypeID(value) == AXUIElementGetTypeID() else { return nil }
+  return unsafeBitCast(value,to:AXUIElement.self)
+}
+func document(_ app: NSRunningApplication, _ root: AXUIElement) -> AXUIElement? {
+  guard let value=attr(AXUIElementCreateApplication(app.processIdentifier),kAXFocusedUIElementAttribute), CFGetTypeID(value)==AXUIElementGetTypeID() else { return nil }
+  var item=unsafeBitCast(value,to:AXUIElement.self)
+  var found: AXUIElement?
+  for _ in 0..<32 {
+    if CFEqual(item,root) { return found }
+    if found == nil, ["AXWebArea","AXDocument"].contains(attr(item,kAXRoleAttribute) as? String ?? "") { found=item }
+    guard let parent=attr(item,kAXParentAttribute), CFGetTypeID(parent)==AXUIElementGetTypeID() else { return nil }
+    item=unsafeBitCast(parent,to:AXUIElement.self)
+  }
+  return nil
+}
+func bounds(_ element: AXUIElement) -> CGRect? {
+  guard let position=attr(element,kAXPositionAttribute), CFGetTypeID(position)==AXValueGetTypeID(), let size=attr(element,kAXSizeAttribute), CFGetTypeID(size)==AXValueGetTypeID() else { return nil }
+  var point=CGPoint.zero, dimensions=CGSize.zero
+  guard AXValueGetValue(unsafeBitCast(position,to:AXValue.self),.cgPoint,&point), AXValueGetValue(unsafeBitCast(size,to:AXValue.self),.cgSize,&dimensions), dimensions.width>0, dimensions.height>0 else { return nil }
+  return CGRect(origin:point,size:dimensions)
+}
+func key(_ app: NSRunningApplication, _ window: AXUIElement) -> String {
+  let documentId=document(app,window).map { String(CFHash($0)) } ?? ""
+  return "\(app.processIdentifier):\(CFHash(window)):\(attr(window,kAXTitleAttribute) as? String ?? ""):\(attr(window,kAXDocumentAttribute) as? String ?? ""):\(documentId)"
+}
+var quiet: Timer?
+var maximum: Timer?
+var lastCapture = -Double(${policy.minimumIntervalMs}) / 1000
+var burstStarted = 0.0
+var burstCaptures = 0
+var noisePaused = false
+var edited = false
+var editKey: String?
+var observer: AXObserver?
+var observedPid: pid_t = 0
+var watchedElements=[AXUIElement]()
+var sessionActive = true
+func locked() -> Bool {
+  guard sessionActive else { return true }
+  guard let session = CGSessionCopyCurrentDictionary() as? [String: Any] else { return true }
+  if session["CGSSessionScreenIsLocked"] as? Bool == true { return true }
+  return session[kCGSessionOnConsoleKey as String] as? Bool != true
+}
+func changed(_ edit: Bool, switched: Bool = false) {
+  if edit || switched { noisePaused=false; burstCaptures=0; burstStarted=ProcessInfo.processInfo.systemUptime }
+  edited = edited || edit
+  if edit, let app=NSWorkspace.shared.frontmostApplication, let root=window(app) { editKey=key(app,root) }
+  quiet?.invalidate()
+  quiet = Timer.scheduledTimer(withTimeInterval:noisePaused ? ${policy.resumeQuietMs / 1000} : 1.2,repeats:false) { _ in capture() }
+  if !noisePaused && maximum == nil { maximum = Timer.scheduledTimer(withTimeInterval:5,repeats:false) { _ in capture() } }
+}
+let callback: AXObserverCallback = { _, element, notification, _ in
+  var pid: pid_t=0
+  guard AXUIElementGetPid(element,&pid) == .success, pid == NSWorkspace.shared.frontmostApplication?.processIdentifier else { return }
+  let switched = notification as String == kAXFocusedWindowChangedNotification
+  if switched { changed(false,switched:true); return }
+  let valueChanged = notification as String == kAXValueChangedNotification
+  if noisePaused && !valueChanged { changed(false); return }
+  let role = attr(element,kAXRoleAttribute) as? String ?? ""
+  let editable = [kAXTextFieldRole,kAXTextAreaRole].contains(role) && attr(element,kAXSubroleAttribute) as? String != "AXSecureTextField"
+  if noisePaused && !editable { changed(false); return }
+  guard let app=NSWorkspace.shared.frontmostApplication, let currentWindow=window(app) else { return }
+  var ancestor: AXUIElement?=element
+  var belongs=false
+  for _ in 0..<32 {
+    guard let current=ancestor else { break }
+    if CFEqual(current,currentWindow) { belongs=true; break }
+    guard let parent=attr(current,kAXParentAttribute), CFGetTypeID(parent)==AXUIElementGetTypeID() else { break }
+    ancestor=unsafeBitCast(parent,to:AXUIElement.self)
+  }
+  if !belongs { changed(false); return }
+  changed(valueChanged && editable)
+}
+func bind(_ app: NSRunningApplication) {
+  if observedPid == app.processIdentifier { return }
+  if let old = observer { CFRunLoopRemoveSource(CFRunLoopGetCurrent(),AXObserverGetRunLoopSource(old),.defaultMode) }
+  observer = nil; observedPid = app.processIdentifier
+  watchedElements=[]
+  guard AXObserverCreate(observedPid,callback,&observer) == .success, let current = observer else { return }
+  let root = AXUIElementCreateApplication(observedPid)
+  for event in [kAXFocusedWindowChangedNotification,kAXFocusedUIElementChangedNotification,kAXTitleChangedNotification,kAXValueChangedNotification,kAXSelectedTextChangedNotification,kAXUIElementDestroyedNotification] {
+    AXObserverAddNotification(current,root,event as CFString,nil)
+  }
+  CFRunLoopAddSource(CFRunLoopGetCurrent(),AXObserverGetRunLoopSource(current),.defaultMode)
+}
+func capture() {
+  guard AXIsProcessTrusted() else { status("permission_required","macos_accessibility_permission_revoked"); exit(0) }
+  quiet?.invalidate(); maximum?.invalidate(); quiet=nil; maximum=nil
+  let now=ProcessInfo.processInfo.systemUptime
+  if noisePaused { noisePaused=false; burstCaptures=0 }
+  if now-lastCapture < ${policy.minimumIntervalMs / 1000} {
+    quiet=Timer.scheduledTimer(withTimeInterval:${policy.minimumIntervalMs / 1000}-(now-lastCapture),repeats:false) { _ in capture() }; return
+  }
+  if now-burstStarted > ${policy.burstWindowMs / 1000} { burstStarted=now; burstCaptures=0 }
+  if !edited { burstCaptures += 1 }
+  if burstCaptures > ${policy.burstLimit} {
+    noisePaused=true; status("paused","continuous_activity")
+    quiet=Timer.scheduledTimer(withTimeInterval:${policy.resumeQuietMs / 1000},repeats:false) { _ in capture() }; return
+  }
+  lastCapture=now
+  let wasEdited=edited; edited=false
+  if locked() { status("paused","screen_locked_or_inactive_session"); return }
+  guard let app=NSWorkspace.shared.frontmostApplication else { return }
+  let appName=app.bundleIdentifier ?? app.localizedName ?? "unknown"
+  if exclusions.contains(appName.lowercased()) || exclusions.contains((app.localizedName ?? "").lowercased()) { status("paused","application_excluded"); return }
+  if appName == "com.apple.loginwindow" { status("paused","screen_locked_or_inactive_session"); return }
+  bind(app)
+  guard let root=window(app) else { status("partial","focused_window_unavailable"); return }
+  let before=key(app,root)
+  let kind = wasEdited && editKey == before ? "edit" : "view"
+  let contentRoot=document(app,root)
+  let windowBounds=bounds(root)
+  var queue=[contentRoot ?? root], parts=[String](), seen=Set<String>(), count=0, length=0
+  let start=Date()
+  if let current=observer {
+    for item in watchedElements {
+      AXObserverRemoveNotification(current,item,kAXValueChangedNotification as CFString)
+      AXObserverRemoveNotification(current,item,kAXTitleChangedNotification as CFString)
+    }
+  }
+  watchedElements=[]
+  while !queue.isEmpty && count<600 && length<24000 && Date().timeIntervalSince(start)<0.4 {
+    let item=queue.removeFirst(); count += 1
+    if attr(item,kAXSubroleAttribute) as? String == "AXSecureTextField" { continue }
+    if attr(item,"AXHidden") as? Bool == true { continue }
+    if contentRoot == nil, ["AXWebArea","AXDocument"].contains(attr(item,kAXRoleAttribute) as? String ?? "") { continue }
+    if let current=observer {
+      AXObserverAddNotification(current,item,kAXValueChangedNotification as CFString,nil)
+      AXObserverAddNotification(current,item,kAXTitleChangedNotification as CFString,nil)
+      watchedElements.append(item)
+    }
+    let children=attr(item,kAXChildrenAttribute) as? [AXUIElement] ?? []
+    if children.isEmpty, let visible=bounds(item), let frame=windowBounds, visible.intersects(frame) {
+      let role=attr(item,kAXRoleAttribute) as? String ?? ""
+      if [kAXStaticTextRole,kAXTextFieldRole,kAXTextAreaRole].contains(role), let text=attr(item,kAXValueAttribute) as? String, !text.isEmpty, seen.insert(text).inserted {
+        parts.append(text); length += text.count
+      }
+    }
+    queue.append(contentsOf:children.prefix(max(0,600-queue.count)))
+  }
+  guard !locked(), let afterApp=NSWorkspace.shared.frontmostApplication, afterApp.processIdentifier == app.processIdentifier, let afterWindow=window(afterApp), key(afterApp,afterWindow)==before else { return }
+  var source:[String:Any] = ["app":appName,"processId":Int(app.processIdentifier),"windowId":String(CFHash(root)),"title":attr(root,kAXTitleAttribute) as? String ?? ""]
+  if let contentRoot=contentRoot { source["documentId"]=String(CFHash(contentRoot)) }
+  else if let document=attr(root,kAXDocumentAttribute) as? String { source["documentId"]=document }
+  let content=String(parts.joined(separator:"\n").prefix(24000))
+  emit(["type":"snapshot","source":source,"content":content,"kind":kind,"extraction":"ax","coverage":content.isEmpty ? "metadata_only":"partial","coverageReason":"visible_accessibility_subset","beforeKey":before,"afterKey":before])
+  status("partial","ax_application_coverage")
+}
+let center=NSWorkspace.shared.notificationCenter
+center.addObserver(forName:NSWorkspace.didActivateApplicationNotification,object:nil,queue:.main) { _ in changed(false,switched:true) }
+center.addObserver(forName:NSWorkspace.sessionDidResignActiveNotification,object:nil,queue:.main) { _ in sessionActive=false; changed(false) }
+center.addObserver(forName:NSWorkspace.sessionDidBecomeActiveNotification,object:nil,queue:.main) { _ in sessionActive=true; changed(false) }
+DistributedNotificationCenter.default().addObserver(forName:NSNotification.Name("com.apple.screenIsLocked"),object:nil,queue:.main) { _ in sessionActive=false; changed(false) }
+DistributedNotificationCenter.default().addObserver(forName:NSNotification.Name("com.apple.screenIsUnlocked"),object:nil,queue:.main) { _ in sessionActive=true; changed(false) }
+status("partial","ax_application_coverage"); changed(false)
+RunLoop.main.run()
+`;

package/dist/src/computer-access/companion/observation-process.d.ts

@@ -0,0 +1,16 @@
+import { spawn } from "node:child_process";
+import type { PassiveCollectorEvent } from "../../shared/passive-observation.js";
+export type DesktopCollector = {
+    close(): void;
+};
+export declare function desktopCollectorCommand(platform: string): {
+    file: string;
+    args: string[];
+    input?: string;
+} | undefined;
+export declare function startDesktopCollector(options: {
+    excludedApplications: readonly string[];
+    onEvent(event: PassiveCollectorEvent): void;
+    platform?: string;
+    spawnProcess?: typeof spawn;
+}): DesktopCollector;

package/dist/src/computer-access/companion/observation-process.js

@@ -0,0 +1,154 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { ObservationFilter } from "./observation-filter.js";
+import { LINUX_OBSERVATION_SCRIPT } from "./observation-linux.js";
+import { MACOS_OBSERVATION_SCRIPT } from "./observation-macos.js";
+import { WINDOWS_OBSERVATION_SCRIPT } from "./observation-windows.js";
+import { OBSERVATION_WIRE_LIMIT } from "./observation-protocol.js";
+function isCollectorFailureStatus(state) {
+    return ["unavailable", "permission_required", "failed"].includes(state);
+}
+export function desktopCollectorCommand(platform) {
+    if (platform === "win32")
+        return {
+            file: "powershell.exe",
+            args: [
+                "-NoLogo",
+                "-NoProfile",
+                "-NonInteractive",
+                "-EncodedCommand",
+                Buffer.from(WINDOWS_OBSERVATION_SCRIPT, "utf16le").toString("base64"),
+            ],
+        };
+    if (platform === "darwin")
+        return {
+            file: "/usr/bin/swift",
+            args: ["-"],
+            input: MACOS_OBSERVATION_SCRIPT,
+        };
+    if (platform === "linux")
+        return { file: "python3", args: ["-u", "-c", LINUX_OBSERVATION_SCRIPT] };
+    return undefined;
+}
+export function startDesktopCollector(options) {
+    const command = desktopCollectorCommand(options.platform ?? process.platform);
+    let child;
+    let closed = false;
+    let received = Buffer.alloc(0);
+    let terminalStatus = false;
+    const filter = new ObservationFilter(options.excludedApplications);
+    const close = () => {
+        closed = true;
+        if (!child?.pid)
+            return;
+        // POSIX language launchers can spawn an interpreter; stop the entire owned process group.
+        if (process.platform !== "win32") {
+            try {
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch {
+                child.kill();
+            }
+            return;
+        }
+        child.kill();
+    };
+    if (!command) {
+        options.onEvent({
+            type: "status",
+            state: "unavailable",
+            reason: "platform_unsupported",
+        });
+        return { close };
+    }
+    if (process.platform === "darwin") {
+        try {
+            const developerDirectory = execFileSync("/usr/bin/xcode-select", ["-p"], {
+                encoding: "utf8",
+                timeout: 1000,
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+            if (!existsSync(developerDirectory))
+                throw new Error("swift_unavailable");
+        }
+        catch {
+            options.onEvent({
+                type: "status",
+                state: "unavailable",
+                reason: "macos_swift_tools_unavailable",
+            });
+            return { close };
+        }
+    }
+    options.onEvent({ type: "status", state: "starting" });
+    child = (options.spawnProcess ?? spawn)(command.file, command.args, {
+        windowsHide: true,
+        detached: process.platform !== "win32",
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            ABOT_OBSERVATION_EXCLUSIONS: JSON.stringify(options.excludedApplications),
+        },
+    });
+    child.stdin?.on("error", () => { });
+    child.stdin?.end(command.input);
+    // Compiler/dependency diagnostics can contain local paths. Never forward them into model or general logs.
+    child.stderr?.resume();
+    child.stdout?.on("data", (chunk) => {
+        if (closed)
+            return;
+        received = Buffer.concat([received, chunk]);
+        if (received.length > OBSERVATION_WIRE_LIMIT * 2) {
+            options.onEvent({
+                type: "status",
+                state: "failed",
+                reason: "collector_output_limit",
+            });
+            close();
+            return;
+        }
+        let boundary = received.indexOf(10);
+        while (boundary >= 0) {
+            try {
+                const event = filter.accept(JSON.parse(received.subarray(0, boundary).toString()));
+                if (event?.type === "status")
+                    terminalStatus = isCollectorFailureStatus(event.state);
+                if (event)
+                    options.onEvent(event);
+            }
+            catch {
+                options.onEvent({
+                    type: "status",
+                    state: "failed",
+                    reason: "collector_protocol_invalid",
+                });
+                close();
+                return;
+            }
+            received = received.subarray(boundary + 1);
+            boundary = received.indexOf(10);
+        }
+    });
+    child.once("error", () => {
+        if (closed)
+            return;
+        options.onEvent({
+            type: "status",
+            state: "unavailable",
+            reason: "collector_dependency_unavailable",
+        });
+        close();
+    });
+    child.once("exit", (code) => {
+        if (closed)
+            return;
+        if (!terminalStatus)
+            options.onEvent({
+                type: "status",
+                state: "unavailable",
+                reason: code === 0 ? "collector_stopped" : "collector_start_failed",
+            });
+        close();
+    });
+    return { close };
+}

package/dist/src/computer-access/companion/observation-protocol.d.ts

@@ -0,0 +1,16 @@
+import type { PassiveCollectorEvent } from "../../shared/passive-observation.js";
+export declare const OBSERVATION_CAPABILITY = "passive-observations-v1";
+export declare const OBSERVATION_LEASE_MS = 15000;
+export declare const OBSERVATION_RENEW_MS = 5000;
+export declare const OBSERVATION_CONTENT_LIMIT = 24000;
+export declare const OBSERVATION_WIRE_LIMIT: number;
+export type ObservationControl = Readonly<{
+    type: "observe_start" | "observe_renew" | "observe_stop";
+    leaseId: string;
+    ownerId: string;
+    excludedApplications?: readonly string[];
+}>;
+export declare function isObservationOwner(value: unknown): value is string;
+export declare function isApplicationExclusionList(value: unknown): value is string[];
+export declare function isObservationControl(value: unknown): value is ObservationControl;
+export declare function isPassiveCollectorEvent(value: unknown): value is PassiveCollectorEvent;

package/dist/src/computer-access/companion/observation-protocol.js

@@ -0,0 +1,95 @@
+import { isHostIdentifier, isHostRecord } from "./protocol.js";
+export const OBSERVATION_CAPABILITY = "passive-observations-v1";
+export const OBSERVATION_LEASE_MS = 15_000;
+export const OBSERVATION_RENEW_MS = 5_000;
+export const OBSERVATION_CONTENT_LIMIT = 24_000;
+export const OBSERVATION_WIRE_LIMIT = 64 * 1024;
+function isBoundedText(value, maximum) {
+    return typeof value === "string" && value.length <= maximum;
+}
+export function isObservationOwner(value) {
+    if (!isBoundedText(value, 128))
+        return false;
+    return value.length > 0 && !/[\x00-\x1f]/u.test(value);
+}
+export function isApplicationExclusionList(value) {
+    if (!Array.isArray(value) || value.length > 128)
+        return false;
+    return value.every((item) => isObservationOwner(item));
+}
+export function isObservationControl(value) {
+    if (!isHostRecord(value))
+        return false;
+    if (!["observe_start", "observe_renew", "observe_stop"].includes(String(value.type)))
+        return false;
+    if (!isHostIdentifier(value.leaseId))
+        return false;
+    if (!isObservationOwner(value.ownerId))
+        return false;
+    if (value.excludedApplications === undefined)
+        return true;
+    return isApplicationExclusionList(value.excludedApplications);
+}
+const STATES = [
+    "starting",
+    "collecting",
+    "partial",
+    "unavailable",
+    "permission_required",
+    "paused",
+    "stopped",
+    "disconnected",
+    "failed",
+];
+export function isPassiveCollectorEvent(value) {
+    if (!isHostRecord(value))
+        return false;
+    if (value.type === "status") {
+        if (!STATES.includes(String(value.state)))
+            return false;
+        return value.reason === undefined || isBoundedText(value.reason, 512);
+    }
+    if (value.type !== "observation")
+        return false;
+    const observation = value.observation;
+    if (!isHostRecord(observation))
+        return false;
+    if (!isHostIdentifier(observation.id))
+        return false;
+    if (observation.revisitsObservationId !== undefined &&
+        !isHostIdentifier(observation.revisitsObservationId))
+        return false;
+    if (!isBoundedText(observation.timestamp, 40))
+        return false;
+    if (!Number.isFinite(Date.parse(observation.timestamp)))
+        return false;
+    if (!Number.isSafeInteger(observation.sequence) ||
+        Number(observation.sequence) < 1)
+        return false;
+    if (!isBoundedText(observation.content, OBSERVATION_CONTENT_LIMIT))
+        return false;
+    if (!["view", "edit", "activity"].includes(String(observation.kind)))
+        return false;
+    if (!["uia", "ax", "atspi"].includes(String(observation.extraction)))
+        return false;
+    if (!["complete", "partial", "metadata_only"].includes(String(observation.coverage)))
+        return false;
+    if (observation.coverageReason !== undefined &&
+        !isBoundedText(observation.coverageReason, 512))
+        return false;
+    const source = observation.source;
+    if (!isHostRecord(source))
+        return false;
+    if (!isObservationOwner(source.app))
+        return false;
+    if (!isBoundedText(source.windowId, 256) || !source.windowId)
+        return false;
+    if (source.processId !== undefined &&
+        (!Number.isSafeInteger(source.processId) || Number(source.processId) < 0))
+        return false;
+    for (const key of ["documentId", "title", "url"]) {
+        if (source[key] !== undefined && !isBoundedText(source[key], 4096))
+            return false;
+    }
+    return true;
+}

package/dist/src/computer-access/companion/observation-redaction.d.ts

@@ -0,0 +1,9 @@
+import type { PassiveObservationSource } from "../../shared/passive-observation.js";
+/**
+ * Mask the entire field when a known secret indicator is present, including
+ * surrounding useful text. No value boundaries or source-language grammar are
+ * inferred. Unlabelled arbitrary secrets and unknown encodings remain outside
+ * detection; this is not a guarantee that unchanged text contains no secrets.
+ */
+export declare function redactObservationText(input: string): string;
+export declare function redactObservationSource(source: PassiveObservationSource, sourceKey: string): PassiveObservationSource;

package/dist/src/computer-access/companion/observation-redaction.js

@@ -0,0 +1,140 @@
+const REDACTED = "[REDACTED]";
+const CREDENTIAL_KEY_SOURCE = String.raw `(?:[A-Za-z][A-Za-z0-9_-]*\.)*(?:[A-Za-z][A-Za-z0-9]*[-_])*(?:password|passwd|pwd|api[_ -]?key|access[_ -]?token|refresh[_ -]?token|client[_ -]?secret|secret[_ -]?access[_ -]?key|recovery[_ -]?code)`;
+const credentialIndicator = new RegExp(String.raw `(?<![\p{L}\p{N}_.-])(?:-{1,2})?(?:${CREDENTIAL_KEY_SOURCE}|(?:proxy-)?authorization)[\s"'\\]*[:=]`, "iu");
+/** Detection only: normalize ASCII encodings once, without interpreting a language. */
+function detectionText(input) {
+    const percentDecoded = input.replace(/%([0-7][0-9a-f])/giu, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+    return percentDecoded.replace(/\\(?:u00|x|U000000)([0-7][0-9a-fA-F])/gu, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+function hasPrivateKeyIndicator(text) {
+    return /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/u.test(text);
+}
+function hasUrlCredentials(text) {
+    return /\b[a-z][a-z0-9+.-]*(?::|%3a)(?:\/|%2f){2}[^\s/?#<>]*(?:@|%40)/iu.test(text);
+}
+function hasAuthorizationCredentials(text) {
+    for (const match of text.matchAll(/\b(Bearer|Basic)[ \t]+([A-Za-z0-9._~+/-]+={0,2})/giu)) {
+        if (match[1].toLowerCase() === "bearer")
+            return true;
+        const value = match[2];
+        if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(value))
+            continue;
+        if (value.length < 8)
+            continue;
+        if (Buffer.from(value, "base64").toString("utf8").includes(":"))
+            return true;
+    }
+    return false;
+}
+function isAwsAccessKeyValue(value, atEnd) {
+    if (/^[A-Z0-9]{16}$/u.test(value))
+        return true;
+    if (!atEnd)
+        return false;
+    return /^[A-Z0-9]{4,15}$/u.test(value);
+}
+function isRecognizedProviderToken(prefix, value, atEnd) {
+    if (prefix === "AKIA" || prefix === "ASIA")
+        return isAwsAccessKeyValue(value, atEnd);
+    if (value.length >= 20)
+        return true;
+    const partialMinimum = prefix === "sk-" ? 8 : 1;
+    return atEnd && value.length >= partialMinimum;
+}
+function hasProviderToken(text) {
+    const provider = /\b(sk-(?:proj-|svcacct-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA|ASIA)([A-Za-z0-9_-]+)/gu;
+    for (const match of text.matchAll(provider)) {
+        const atEnd = match.index + match[0].length === text.length;
+        if (isRecognizedProviderToken(match[1], match[2], atEnd))
+            return true;
+    }
+    return false;
+}
+function compactJoseSegmentCount(header) {
+    try {
+        const value = JSON.parse(Buffer.from(header, "base64url").toString("utf8"));
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return undefined;
+        const fields = value;
+        if (typeof fields.alg !== "string")
+            return undefined;
+        return typeof fields.enc === "string" ? 5 : 3;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasCompactJoseToken(text) {
+    const jose = /\b([A-Za-z0-9_-]+)(?:\.[A-Za-z0-9_-]*)+/gu;
+    for (const match of text.matchAll(jose)) {
+        const parts = match[0].split(".");
+        const capturedAtEnd = match.index + match[0].length === text.length;
+        for (let index = 0; index < parts.length - 1; index += 1) {
+            const expected = compactJoseSegmentCount(parts[index]);
+            if (expected === undefined)
+                continue;
+            if (expected === 3 && parts[index + 1] === "")
+                continue;
+            if (parts.length - index >= expected)
+                return true;
+            if (capturedAtEnd)
+                return true;
+        }
+    }
+    return false;
+}
+function hasSecretIndicator(text) {
+    if (credentialIndicator.test(text))
+        return true;
+    if (hasPrivateKeyIndicator(text))
+        return true;
+    if (hasUrlCredentials(text))
+        return true;
+    if (hasAuthorizationCredentials(text))
+        return true;
+    if (hasProviderToken(text))
+        return true;
+    return hasCompactJoseToken(text);
+}
+/**
+ * Mask the entire field when a known secret indicator is present, including
+ * surrounding useful text. No value boundaries or source-language grammar are
+ * inferred. Unlabelled arbitrary secrets and unknown encodings remain outside
+ * detection; this is not a guarantee that unchanged text contains no secrets.
+ */
+export function redactObservationText(input) {
+    if (hasSecretIndicator(input))
+        return REDACTED;
+    if (hasSecretIndicator(detectionText(input)))
+        return REDACTED;
+    return input;
+}
+export function redactObservationSource(source, sourceKey) {
+    const redacted = {
+        app: redactObservationText(source.app).slice(0, 128),
+        windowId: redactObservationText(source.windowId).slice(0, 256),
+        ...(source.processId === undefined ? {} : { processId: source.processId }),
+        ...(source.documentId === undefined
+            ? {}
+            : {
+                documentId: redactObservationText(source.documentId).slice(0, 4096),
+            }),
+        ...(source.title === undefined
+            ? {}
+            : { title: redactObservationText(source.title).slice(0, 4096) }),
+        ...(source.url === undefined
+            ? {}
+            : { url: redactObservationText(source.url).slice(0, 4096) }),
+    };
+    const hasSourceRedaction = [
+        "app",
+        "windowId",
+        "documentId",
+        "title",
+        "url",
+    ].some((key) => redacted[key] !==
+        source[key]);
+    if (!hasSourceRedaction)
+        return redacted;
+    return { ...redacted, documentId: `redacted-source:${sourceKey}` };
+}

package/dist/src/computer-access/companion/observation-windows.d.ts

@@ -0,0 +1 @@
+export declare const WINDOWS_OBSERVATION_SCRIPT: string;