screenhand 0.2.0 → 0.3.1

package/dist/src/native/bridge-client.js

@@ -16,6 +16,7 @@
 // along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
+import fs from "node:fs";
 import path from "node:path";
 import { createInterface } from "node:readline";
 /**
@@ -26,8 +27,12 @@ const METHOD_TIMEOUTS = {
     "app.launch": 30_000,
     "cg.captureScreen": 15_000,
     "cg.captureWindow": 15_000,
+    "cg.captureWindowBuffer": 15_000,
+    "cg.typeText": 30_000, // L2-66 fix: long text keystroke simulation needs more time
     "vision.ocr": 20_000,
+    "vision.ocrRegion": 20_000,
     "vision.findText": 20_000,
+    "ax.getMenuBar": 30_000,
 };
 /**
  * Resolves the correct native bridge binary path for the current platform.
@@ -35,10 +40,24 @@ const METHOD_TIMEOUTS = {
 function defaultBinaryPath() {
     // import.meta.dirname is Node 20+; for Node 18 derive from import.meta.url
     const base = import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname);
-    if (process.platform === "win32") {
+    const platform = process.platform;
+    const arch = process.arch;
+    const isWindows = platform === "win32";
+    const binaryName = isWindows ? "windows-bridge.exe" : "macos-bridge";
+    // 1. Check prebuilt binary shipped via npm (bin/<platform>-<arch>/)
+    const prebuilt = path.resolve(base, `../../bin/${platform}-${arch}/${binaryName}`);
+    if (fs.existsSync(prebuilt)) {
+        return prebuilt;
+    }
+    // 2. Fall back to local dev build paths
+    if (isWindows) {
         return path.resolve(base, "../../native/windows-bridge/bin/Release/net8.0-windows/windows-bridge.exe");
     }
-    // macOS (default)
+    // macOS — try arch-specific path first, then generic release
+    const archSpecific = path.resolve(base, `../../native/macos-bridge/.build/${arch}-apple-macosx/release/macos-bridge`);
+    if (fs.existsSync(archSpecific)) {
+        return archSpecific;
+    }
     return path.resolve(base, "../../native/macos-bridge/.build/release/macos-bridge");
 }
 /**
@@ -54,7 +73,27 @@ export class BridgeClient extends EventEmitter {
     pending = new Map();
     binaryPath;
     restarting = false;
+    /** Resolves when the current restart completes (callers can await it) */
+    restartPromise = null;
     started = false;
+    consecutiveTimeouts = 0;
+    consecutiveRestarts = 0;
+    lastRestartAt = 0;
+    /** Serializes stdin writes to prevent interleaving of large payloads */
+    writeQueue = Promise.resolve();
+    /** Max concurrent bridge requests to prevent DoS */
+    maxConcurrent = 20;
+    activeRequests = 0;
+    /** Force-restart bridge after this many consecutive RPC timeouts */
+    static MAX_CONSECUTIVE_TIMEOUTS = 3;
+    /** Give up restarting after this many consecutive restart failures */
+    static MAX_CONSECUTIVE_RESTARTS = 8;
+    /** Reset restart counter if bridge stays alive for this long */
+    static RESTART_HEALTH_WINDOW_MS = 15_000;
+    /** Base delay between restart attempts (doubles each retry) */
+    static RESTART_BASE_DELAY_MS = 500;
+    /** After hitting max restarts, pause for this long before allowing retries */
+    static RESTART_COOLDOWN_MS = 60_000;
     constructor(binaryPath) {
         super();
         this.binaryPath = binaryPath ?? defaultBinaryPath();
@@ -64,25 +103,102 @@ export class BridgeClient extends EventEmitter {
             return;
         await this.spawn();
         this.started = true;
+        // Verify bridge is responsive before returning
+        try {
+            const pingOk = await Promise.race([
+                this._sendRaw("ping", undefined, 5_000).then(() => true),
+                new Promise((r) => setTimeout(() => r(false), 5_000)),
+            ]);
+            if (!pingOk) {
+                const stderrContext = this.recentStderr.length > 0
+                    ? `\nBridge stderr:\n  ${this.recentStderr.slice(-5).join("\n  ")}`
+                    : "";
+                console.error(`[BridgeClient] Bridge did not respond to initial ping.${stderrContext}\n` +
+                    `Check: System Settings > Privacy & Security > Accessibility permissions for your terminal app.`);
+            }
+        }
+        catch {
+            // Non-fatal — bridge may still respond to subsequent calls
+        }
     }
     async stop() {
         this.started = false;
-        if (this.process) {
-            this.process.kill();
-            this.process = null;
+        this.killProcess();
+        this.rejectAllPending("Bridge stopped");
+    }
+    async call(method, params, timeoutMs) {
+        // Wait for a slot instead of immediately rejecting — handles bursts from
+        // intelligence wrapper + perception generating multiple bridge calls per tool
+        if (this.activeRequests >= this.maxConcurrent) {
+            const waitStart = Date.now();
+            while (this.activeRequests >= this.maxConcurrent) {
+                if (Date.now() - waitStart > 5_000) {
+                    throw new Error("Bridge overloaded: too many concurrent requests (waited 5s)");
+                }
+                await new Promise(r => setTimeout(r, 50));
+            }
         }
-        // Reject all pending
-        for (const [id, pending] of this.pending) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error("Bridge stopped"));
-            this.pending.delete(id);
+        this.activeRequests++;
+        try {
+            return await this._callInner(method, params, timeoutMs);
+        }
+        finally {
+            this.activeRequests--;
         }
     }
-    async call(method, params, timeoutMs) {
+    /**
+     * Low-level send: writes a JSON-RPC request and waits for response.
+     * Does NOT check restart state or process liveness — used inside restart()
+     * to avoid deadlock (this.call → _callInner awaits restartPromise = deadlock).
+     */
+    async _sendRaw(method, params, timeoutMs) {
+        const effectiveTimeout = timeoutMs ?? METHOD_TIMEOUTS[method] ?? 10_000;
+        if (!this.process || !this.process.stdin?.writable) {
+            throw new Error("Bridge process not available for raw send");
+        }
+        const id = this.nextId++;
+        const request = { id, method };
+        if (params)
+            request.params = params;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Bridge call "${method}" timed out after ${effectiveTimeout}ms`));
+            }, effectiveTimeout);
+            this.pending.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            const line = JSON.stringify(request);
+            this.writeQueue = this.writeQueue.then(() => {
+                return new Promise((writeResolve) => {
+                    try {
+                        this.process.stdin.write(line + "\n", () => writeResolve());
+                    }
+                    catch {
+                        this.pending.delete(id);
+                        clearTimeout(timer);
+                        reject(new Error(`Bridge stdin write failed for "${method}"`));
+                        writeResolve();
+                    }
+                });
+            });
+        });
+    }
+    async _callInner(method, params, timeoutMs) {
         const effectiveTimeout = timeoutMs ?? METHOD_TIMEOUTS[method] ?? 10_000;
+        // Wait for any in-progress restart before proceeding
+        if (this.restarting && this.restartPromise) {
+            await this.restartPromise;
+        }
         if (!this.process || this.process.exitCode !== null) {
             await this.restart();
         }
+        // Guard: restart may have failed, no usable process
+        if (!this.process || !this.process.stdin?.writable) {
+            throw new Error(`Bridge unavailable after ${this.consecutiveRestarts} restart attempts`);
+        }
         const id = this.nextId++;
         const request = { id, method };
         if (params) {
@@ -91,15 +207,34 @@ export class BridgeClient extends EventEmitter {
         return new Promise((resolve, reject) => {
             const timer = setTimeout(() => {
                 this.pending.delete(id);
+                this.consecutiveTimeouts++;
                 reject(new Error(`Bridge call "${method}" timed out after ${effectiveTimeout}ms`));
+                // Force restart if bridge appears stalled
+                if (this.consecutiveTimeouts >= BridgeClient.MAX_CONSECUTIVE_TIMEOUTS) {
+                    this.consecutiveTimeouts = 0;
+                    this.restart().catch(() => { });
+                }
             }, effectiveTimeout);
             this.pending.set(id, {
                 resolve: resolve,
                 reject,
                 timer,
             });
-            const line = JSON.stringify(request) + "\n";
-            this.process.stdin.write(line);
+            const line = JSON.stringify(request);
+            // Serialize stdin writes to prevent interleaving of large payloads
+            this.writeQueue = this.writeQueue.then(() => {
+                return new Promise((writeResolve) => {
+                    try {
+                        this.process.stdin.write(line + "\n", () => writeResolve());
+                    }
+                    catch {
+                        this.pending.delete(id);
+                        clearTimeout(timer);
+                        reject(new Error(`Bridge stdin write failed for "${method}"`));
+                        writeResolve();
+                    }
+                });
+            });
         });
     }
     async ping() {
@@ -108,19 +243,30 @@ export class BridgeClient extends EventEmitter {
     async checkPermissions() {
         return this.call("check_permissions");
     }
+    /** Recent stderr lines from the bridge process (kept for diagnostics) */
+    recentStderr = [];
+    static MAX_STDERR_LINES = 20;
+    /** Get recent stderr output for diagnostics */
+    getRecentStderr() {
+        return [...this.recentStderr];
+    }
     async spawn() {
         const child = spawn(this.binaryPath, [], {
             stdio: ["pipe", "pipe", "pipe"],
         });
+        // Track which process this is so stale event handlers don't trigger restarts
+        const spawnedProcess = child;
         child.on("error", (err) => {
             this.emit("error", err);
-            if (this.started) {
+            // Only auto-restart if this is still the active process
+            if (this.started && this.process === spawnedProcess) {
                 this.restart().catch(() => { });
             }
         });
         child.on("exit", (code) => {
             this.emit("exit", code);
-            if (this.started && !this.restarting) {
+            // Only auto-restart if this is still the active process and not mid-restart
+            if (this.started && !this.restarting && this.process === spawnedProcess) {
                 this.restart().catch(() => { });
             }
         });
@@ -129,9 +275,16 @@ export class BridgeClient extends EventEmitter {
         rl.on("line", (line) => {
             this.handleLine(line);
         });
-        // Log stderr
+        // Capture stderr for diagnostics and emit
         child.stderr?.on("data", (data) => {
-            this.emit("stderr", data.toString());
+            const text = data.toString();
+            this.emit("stderr", text);
+            for (const line of text.split("\n").filter(Boolean)) {
+                this.recentStderr.push(line);
+                if (this.recentStderr.length > BridgeClient.MAX_STDERR_LINES) {
+                    this.recentStderr.shift();
+                }
+            }
         });
         this.process = child;
     }
@@ -154,6 +307,11 @@ export class BridgeClient extends EventEmitter {
             return;
         this.pending.delete(response.id);
         clearTimeout(pending.timer);
+        // Any response (success or error) means bridge is alive — reset crash counters
+        this.consecutiveTimeouts = 0;
+        if (this.consecutiveRestarts > 0) {
+            this.consecutiveRestarts = 0;
+        }
         if (response.error) {
             pending.reject(new Error(response.error.message));
         }
@@ -161,27 +319,91 @@ export class BridgeClient extends EventEmitter {
             pending.resolve(response.result);
         }
     }
-    async restart() {
-        if (this.restarting)
-            return;
-        this.restarting = true;
-        // Reject all pending requests
+    /** Reject all pending requests with the given reason. */
+    rejectAllPending(reason) {
         for (const [id, pending] of this.pending) {
             clearTimeout(pending.timer);
-            pending.reject(new Error("Bridge process crashed, restarting"));
+            pending.reject(new Error(reason));
             this.pending.delete(id);
         }
-        try {
-            if (this.process) {
-                this.process.kill();
-                this.process = null;
+    }
+    /** Kill the current process and null the reference. */
+    killProcess() {
+        if (this.process) {
+            try {
+                this.process.kill("SIGKILL");
             }
-            await this.spawn();
-            this.emit("restart");
+            catch { /* already dead */ }
+            this.process = null;
         }
-        finally {
-            this.restarting = false;
+    }
+    async restart() {
+        // If restart already in progress, wait for it instead of returning early.
+        // Without this, concurrent callers see this.process=null and throw "Bridge unavailable".
+        if (this.restarting) {
+            if (this.restartPromise)
+                await this.restartPromise;
+            return;
         }
+        this.restarting = true;
+        const doRestart = async () => {
+            this.rejectAllPending("Bridge process crashed, restarting");
+            try {
+                // Reset restart counter if bridge was healthy for a while
+                if (Date.now() - this.lastRestartAt > BridgeClient.RESTART_HEALTH_WINDOW_MS) {
+                    this.consecutiveRestarts = 0;
+                }
+                this.consecutiveRestarts++;
+                this.lastRestartAt = Date.now();
+                // Too many consecutive restarts — enter cooldown instead of permanent death
+                if (this.consecutiveRestarts > BridgeClient.MAX_CONSECUTIVE_RESTARTS) {
+                    this.emit("error", new Error(`Bridge restart limit reached (${BridgeClient.MAX_CONSECUTIVE_RESTARTS} consecutive failures). ` +
+                        `Cooling down for ${BridgeClient.RESTART_COOLDOWN_MS / 1000}s before retrying.`));
+                    // Wait for cooldown period, then reset and allow retry
+                    await new Promise((r) => setTimeout(r, BridgeClient.RESTART_COOLDOWN_MS));
+                    this.consecutiveRestarts = 1; // Reset but count this as attempt #1
+                }
+                // Exponential backoff: 500ms, 1s, 2s, 4s, 8s
+                const delay = BridgeClient.RESTART_BASE_DELAY_MS * Math.pow(2, this.consecutiveRestarts - 1);
+                this.killProcess();
+                // Wait for backoff delay — let old process fully die
+                await new Promise((r) => setTimeout(r, Math.min(delay, 8_000)));
+                await this.spawn();
+                // Verify the new process is responsive
+                // NOTE: call _sendRaw directly instead of this.call() to avoid deadlock —
+                // this.call() → _callInner() awaits this.restartPromise, which IS this function.
+                const pingTimeout = 5_000;
+                const pingOk = await Promise.race([
+                    this._sendRaw("ping", undefined, pingTimeout).then(() => true),
+                    new Promise((r) => setTimeout(() => r(false), pingTimeout)),
+                ]);
+                if (!pingOk) {
+                    const stderrContext = this.recentStderr.length > 0
+                        ? `\nBridge stderr:\n  ${this.recentStderr.slice(-5).join("\n  ")}`
+                        : "";
+                    throw new Error(`Native bridge did not respond to ping within 5s.${stderrContext}\n` +
+                        `Possible causes:\n` +
+                        `  1. Accessibility permissions not granted — open System Settings > Privacy & Security > Accessibility and add your terminal app\n` +
+                        `  2. Bridge binary may be corrupted — run: npm run build:native\n` +
+                        `  3. Another bridge process may be stuck — check: pgrep macos-bridge`);
+                }
+                // Healthy restart — reset counters (bridge is alive and responsive)
+                this.consecutiveTimeouts = 0;
+                this.consecutiveRestarts = 0;
+                this.emit("restart");
+            }
+            catch (err) {
+                // Spawn failed — kill zombie if any
+                this.killProcess();
+                this.emit("error", err instanceof Error ? err : new Error(String(err)));
+            }
+            finally {
+                this.restarting = false;
+                this.restartPromise = null;
+            }
+        };
+        this.restartPromise = doRestart();
+        await this.restartPromise;
     }
 }
 /**

package/dist/src/observer/state.js

@@ -0,0 +1,199 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Observer state helpers — read/write observer state file.
+ * Used by: observer-daemon.ts (writes), playbook engine (reads), MCP tools (reads).
+ */
+import fs from "node:fs";
+import { readJsonWithRecovery, writeFileAtomicSync } from "../util/atomic-write.js";
+import { DEFAULT_POPUP_PATTERNS, OBSERVER_DIR, OBSERVER_STATE_FILE, OBSERVER_COMMANDS_FILE, OBSERVER_PID_FILE, CAPTURE_LOCK_FILE, } from "./types.js";
+/** Read current observer state from disk. Returns null if not running. */
+export function readObserverState() {
+    return readJsonWithRecovery(OBSERVER_STATE_FILE);
+}
+/** Write observer state to disk (atomic). */
+export function writeObserverState(state) {
+    fs.mkdirSync(OBSERVER_DIR, { recursive: true });
+    writeFileAtomicSync(OBSERVER_STATE_FILE, JSON.stringify(state, null, 2));
+}
+/** Get PID of running observer daemon, or null if not running. */
+export function getObserverDaemonPid() {
+    try {
+        const pid = Number(fs.readFileSync(OBSERVER_PID_FILE, "utf-8").trim());
+        if (Number.isNaN(pid))
+            return null;
+        // Check if process is alive
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            // Process not running — stale PID file
+            try {
+                fs.unlinkSync(OBSERVER_PID_FILE);
+            }
+            catch { /* ignore */ }
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** Match OCR text against popup patterns. Returns first match or null. */
+export function detectPopup(ocrText, patterns = DEFAULT_POPUP_PATTERNS) {
+    const lowerText = ocrText.toLowerCase();
+    for (const p of patterns) {
+        const regex = new RegExp(p.pattern, "i");
+        if (regex.test(lowerText)) {
+            return {
+                matchedText: ocrText.substring(0, 200),
+                pattern: p.pattern,
+                dismissAction: p.action,
+                detectedAt: new Date().toISOString(),
+            };
+        }
+    }
+    return null;
+}
+// ── Command file helpers ──
+/** Read all commands from the command file. */
+export function readObserverCommands() {
+    const data = readJsonWithRecovery(OBSERVER_COMMANDS_FILE);
+    return data ?? [];
+}
+/** Write commands to disk (atomic). */
+export function writeObserverCommands(commands) {
+    fs.mkdirSync(OBSERVER_DIR, { recursive: true });
+    writeFileAtomicSync(OBSERVER_COMMANDS_FILE, JSON.stringify(commands, null, 2));
+}
+/** Submit a new command. Returns the command ID. */
+export function submitObserverCommand(cmd) {
+    const commands = readObserverCommands();
+    const id = `cmd_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const newCmd = {
+        ...cmd,
+        id,
+        status: "pending",
+        createdAt: new Date().toISOString(),
+    };
+    commands.push(newCmd);
+    // Cap at 50 commands, evict oldest completed/errored first
+    if (commands.length > 50) {
+        const done = commands.filter((c) => c.status === "done" || c.status === "error");
+        if (done.length > 0) {
+            const removeId = done[0].id;
+            const idx = commands.findIndex((c) => c.id === removeId);
+            if (idx >= 0)
+                commands.splice(idx, 1);
+        }
+        else {
+            commands.shift();
+        }
+    }
+    writeObserverCommands(commands);
+    return id;
+}
+/** Get a command by ID. */
+export function getObserverCommand(id) {
+    const commands = readObserverCommands();
+    return commands.find((c) => c.id === id) ?? null;
+}
+/** Get the latest OCR text from observer (if running and has data). */
+export function getObserverOcrText() {
+    const state = readObserverState();
+    if (!state?.running || !state.lastFrame)
+        return null;
+    return state.lastFrame.ocrText;
+}
+/** Get detected popup from observer (if any). */
+export function getObserverPopup() {
+    const state = readObserverState();
+    if (!state?.running)
+        return null;
+    return state.popup;
+}
+// ── Capture lock helpers ──
+// Prevents observer daemon and perception coordinator from capturing simultaneously.
+const LOCK_STALE_MS = 10_000; // Locks older than 10s are considered stale
+/**
+ * Acquire the capture lock. Returns true if acquired, false if held by another process.
+ * Lock contains PID + timestamp so stale locks from crashed processes can be cleaned up.
+ */
+export function acquireCaptureLock() {
+    fs.mkdirSync(OBSERVER_DIR, { recursive: true });
+    try {
+        // Check existing lock
+        const existing = fs.readFileSync(CAPTURE_LOCK_FILE, "utf-8").trim();
+        if (existing) {
+            const parts = existing.split(":");
+            const lockPid = Number(parts[0]);
+            const lockTime = Number(parts[1]);
+            // Stale lock check
+            if (Date.now() - lockTime > LOCK_STALE_MS) {
+                // Lock is stale — safe to overwrite
+            }
+            else if (lockPid !== process.pid) {
+                // Check if holding process is alive
+                try {
+                    process.kill(lockPid, 0);
+                    return false; // Process alive, lock is valid
+                }
+                catch {
+                    // Process dead — stale lock
+                }
+            }
+            // Lock is ours or stale — fall through to acquire
+        }
+    }
+    catch {
+        // No lock file — safe to create
+    }
+    try {
+        fs.writeFileSync(CAPTURE_LOCK_FILE, `${process.pid}:${Date.now()}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Release the capture lock (only if we hold it).
+ */
+export function releaseCaptureLock() {
+    try {
+        const existing = fs.readFileSync(CAPTURE_LOCK_FILE, "utf-8").trim();
+        const lockPid = Number(existing.split(":")[0]);
+        if (lockPid === process.pid) {
+            fs.unlinkSync(CAPTURE_LOCK_FILE);
+        }
+    }
+    catch {
+        // No lock file or already cleaned up
+    }
+}
+/**
+ * Check if the capture lock is currently held (by any process).
+ */
+export function isCaptureLocked() {
+    try {
+        const existing = fs.readFileSync(CAPTURE_LOCK_FILE, "utf-8").trim();
+        if (!existing)
+            return false;
+        const parts = existing.split(":");
+        const lockPid = Number(parts[0]);
+        const lockTime = Number(parts[1]);
+        if (Date.now() - lockTime > LOCK_STALE_MS)
+            return false;
+        try {
+            process.kill(lockPid, 0);
+            return true;
+        }
+        catch {
+            return false; // Process dead
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/observer/types.js

@@ -0,0 +1,43 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Observer types — background app-level visual monitoring
+ *
+ * The observer daemon watches a single app window via CGWindowListCreateImage,
+ * runs OCR only when pixels change, and exposes state via a JSON file.
+ * The playbook engine reads this file — zero overhead on the hot path.
+ */
+import os from "node:os";
+import path from "node:path";
+/** Default popup patterns covering common OS and app dialogs */
+export const DEFAULT_POPUP_PATTERNS = [
+    // Save dialogs
+    { pattern: "Do you want to save", action: "click_cancel", buttonText: "Don't Save" },
+    { pattern: "Save changes", action: "click_cancel", buttonText: "Don't Save" },
+    { pattern: "would you like to save", action: "click_cancel", buttonText: "Don't Save" },
+    // Permission dialogs
+    { pattern: "would like to access", action: "click_allow", buttonText: "Allow" },
+    { pattern: "wants to access", action: "click_allow", buttonText: "Allow" },
+    { pattern: "requesting permission", action: "click_allow", buttonText: "Allow" },
+    // Cookie banners
+    { pattern: "Accept all cookies", action: "click_ok", buttonText: "Accept" },
+    { pattern: "cookie preferences", action: "click_ok", buttonText: "Accept All" },
+    // Update prompts
+    { pattern: "update is available", action: "click_cancel", buttonText: "Later" },
+    { pattern: "Remind Me Later", action: "click_cancel", buttonText: "Remind Me Later" },
+    { pattern: "Update Now", action: "click_cancel", buttonText: "Not Now" },
+    // Generic modals
+    { pattern: "Are you sure", action: "click_ok", buttonText: "OK" },
+    { pattern: "Close without saving", action: "click_ok", buttonText: "Close" },
+    // Chrome specific
+    { pattern: "Chrome is being controlled", action: "press_escape" },
+    { pattern: "Restore pages", action: "press_escape" },
+    // macOS specific
+    { pattern: "allow notifications", action: "click_deny", buttonText: "Don't Allow" },
+];
+export const OBSERVER_DIR = path.join(os.homedir(), ".screenhand", "observer");
+export const OBSERVER_STATE_FILE = path.join(OBSERVER_DIR, "state.json");
+export const OBSERVER_COMMANDS_FILE = path.join(OBSERVER_DIR, "commands.json");
+export const OBSERVER_PID_FILE = path.join(OBSERVER_DIR, "observer.pid");
+export const OBSERVER_LOG_FILE = path.join(OBSERVER_DIR, "observer.log");
+export const CAPTURE_LOCK_FILE = path.join(OBSERVER_DIR, "capture.lock");