@anusornneal/chat-relay 0.7.2 → 0.8.1

package/agent/windows-desktop-runner.mjs

@@ -0,0 +1,109 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+
+const POWERSHELL_TIMEOUT_MS = 15_000;
+const helperPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "windows-desktop-worker.ps1");
+
+export class PersistentDesktopRunner {
+  constructor(options = {}) {
+    this.platform = options.platform ?? process.platform;
+    this.timeoutMs = Number(options.timeoutMs ?? POWERSHELL_TIMEOUT_MS);
+    this.process = null;
+    this.stdout = null;
+    this.pending = new Map();
+    this.stderr = "";
+  }
+
+  ensureStarted() {
+    if (this.platform !== "win32") return false;
+    if (this.process && !this.process.killed) return true;
+
+    const child = spawn("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-Sta",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      helperPath,
+    ], {
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process = child;
+    this.stderr = "";
+    this.stdout = readline.createInterface({ input: child.stdout });
+
+    this.stdout.on("line", (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const pending = this.pending.get(message?.id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(message.id);
+      pending.resolve(message.result ?? { ok: false, error: "desktop_worker_error" });
+    });
+
+    child.stderr.on("data", (chunk) => {
+      this.stderr = (this.stderr + String(chunk)).slice(-8192);
+    });
+
+    child.on("exit", () => {
+      const error = { ok: false, error: "desktop_worker_exited" };
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.resolve(error);
+      }
+      this.pending.clear();
+      this.stdout?.close();
+      this.stdout = null;
+      this.process = null;
+    });
+
+    child.on("error", () => {
+      // exit handler settles pending work.
+    });
+
+    return true;
+  }
+
+  async run(operation, args) {
+    if (!this.ensureStarted() || !this.process?.stdin?.writable) {
+      return { ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" };
+    }
+
+    const id = randomUUID();
+    const request = JSON.stringify({ id, operation, args: args || {} }) + "\n";
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ ok: false, error: operation === "screenshot" ? "capture_timeout" : "input_timeout" });
+      }, this.timeoutMs);
+
+      this.pending.set(id, { resolve, timer });
+      this.process.stdin.write(request, (error) => {
+        if (!error) return;
+        clearTimeout(timer);
+        this.pending.delete(id);
+        resolve({ ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" });
+      });
+    });
+  }
+
+  close() {
+    try { this.stdout?.close(); } catch {}
+    try { this.process?.kill(); } catch {}
+    this.stdout = null;
+    this.process = null;
+  }
+}

package/agent/windows-desktop-worker.ps1

@@ -8,7 +8,9 @@ Add-Type -AssemblyName System.Drawing
 
 Add-Type @"
 using System;
+using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Text;
 
 public static class ChatRelayNative {
   public const uint INPUT_MOUSE = 0;
@@ -47,10 +49,78 @@ public static class ChatRelayNative {
     public INPUTUNION U;
   }
 
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RECT {
+    public int Left;
+    public int Top;
+    public int Right;
+    public int Bottom;
+  }
+
+  public sealed class WindowInfo {
+    public string WindowId;
+    public uint ProcessId;
+    public string Title;
+    public int X;
+    public int Y;
+    public int Width;
+    public int Height;
+    public bool IsForeground;
+  }
+
+  public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
   [DllImport("user32.dll")] public static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
   [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
   [DllImport("user32.dll")] public static extern bool SetProcessDPIAware();
   [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc callback, IntPtr lParam);
+  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool IsWindow(IntPtr hWnd);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)] public static extern int GetWindowTextLength(IntPtr hWnd);
+  [DllImport("user32.dll", CharSet = CharSet.Unicode)] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int maxCount);
+  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool ShowWindowAsync(IntPtr hWnd, int command);
+
+  public static WindowInfo[] ListWindows(int limit) {
+    var items = new List<WindowInfo>();
+    var foreground = GetForegroundWindow();
+    EnumWindows(delegate(IntPtr hWnd, IntPtr lParam) {
+      if (items.Count >= limit) return false;
+      if (!IsWindowVisible(hWnd)) return true;
+      int titleLength = GetWindowTextLength(hWnd);
+      if (titleLength <= 0) return true;
+      var title = new StringBuilder(titleLength + 1);
+      if (GetWindowText(hWnd, title, title.Capacity) <= 0) return true;
+      uint pid;
+      GetWindowThreadProcessId(hWnd, out pid);
+      RECT rect;
+      if (!GetWindowRect(hWnd, out rect)) return true;
+      items.Add(new WindowInfo {
+        WindowId = unchecked((ulong)hWnd.ToInt64()).ToString(),
+        ProcessId = pid,
+        Title = title.ToString(),
+        X = rect.Left,
+        Y = rect.Top,
+        Width = Math.Max(0, rect.Right - rect.Left),
+        Height = Math.Max(0, rect.Bottom - rect.Top),
+        IsForeground = hWnd == foreground,
+      });
+      return true;
+    }, IntPtr.Zero);
+    return items.ToArray();
+  }
+
+  public static bool FocusWindow(string windowId) {
+    ulong raw;
+    if (!UInt64.TryParse(windowId, out raw) || raw == 0) return false;
+    var hWnd = new IntPtr(unchecked((long)raw));
+    if (!IsWindow(hWnd)) return false;
+    ShowWindowAsync(hWnd, 9);
+    return SetForegroundWindow(hWnd);
+  }
 
   public static bool MouseButton(uint downFlag, uint upFlag) {
     var inputs = new INPUT[2];
@@ -125,6 +195,7 @@ function Resolve-Screen($Monitor) {
 }
 
 function Invoke-Screenshot($Payload) {
+  $totalTimer = [System.Diagnostics.Stopwatch]::StartNew()
   if (-not [System.Windows.Forms.SystemInformation]::UserInteractive) {
     return Result-Error "session_unavailable"
   }
@@ -142,11 +213,15 @@ function Invoke-Screenshot($Payload) {
   try {
     $source = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
     $graphics = [System.Drawing.Graphics]::FromImage($source)
+    $captureTimer = [System.Diagnostics.Stopwatch]::StartNew()
     try {
       $graphics.CopyFromScreen($bounds.Left, $bounds.Top, 0, 0, $bounds.Size)
     } finally {
+      $captureTimer.Stop()
       $graphics.Dispose()
     }
+    $captureMs = [int][Math]::Round($captureTimer.Elapsed.TotalMilliseconds)
+    $encodeTimer = [System.Diagnostics.Stopwatch]::StartNew()
 
     $codec = [System.Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() |
       Where-Object { $_.MimeType -eq "image/jpeg" } |
@@ -154,12 +229,17 @@ function Invoke-Screenshot($Payload) {
     if ($null -eq $codec) { return Result-Error "capture_failed" }
 
     $maxBytes = 32768
-    $targetWidth = [Math]::Min($bounds.Width, 960)
+    $requestedMaxWidth = if ($null -eq $Payload.maxWidth) { 960 } else { [int]$Payload.maxWidth }
+    if ($requestedMaxWidth -lt 320 -or $requestedMaxWidth -gt 1920) { return Result-Error "invalid_max_width" }
+    $requestedQuality = if ($null -eq $Payload.quality) { 58 } else { [int]$Payload.quality }
+    if ($requestedQuality -lt 20 -or $requestedQuality -gt 85) { return Result-Error "invalid_quality" }
+    $targetWidth = [Math]::Min($bounds.Width, $requestedMaxWidth)
     $targetHeight = [Math]::Max(1, [int][Math]::Round($bounds.Height * ($targetWidth / [double]$bounds.Width)))
-    $qualities = @(58L, 42L, 30L, 22L)
+    $qualities = @([long]$requestedQuality, [long][Math]::Min($requestedQuality, 42), [long][Math]::Min($requestedQuality, 30), 20L) | Select-Object -Unique
     $bytes = $null
     $finalWidth = $targetWidth
     $finalHeight = $targetHeight
+    $finalQuality = $requestedQuality
 
     for ($sizeAttempt = 0; $sizeAttempt -lt 3 -and $null -eq $bytes; $sizeAttempt++) {
       $resized = New-Object System.Drawing.Bitmap $targetWidth, $targetHeight
@@ -188,6 +268,7 @@ function Invoke-Screenshot($Payload) {
               $bytes = $stream.ToArray()
               $finalWidth = $targetWidth
               $finalHeight = $targetHeight
+              $finalQuality = [int]$quality
               break
             }
           } finally {
@@ -206,13 +287,24 @@ function Invoke-Screenshot($Payload) {
     }
 
     if ($null -eq $bytes) { return Result-Error "screenshot_too_large" }
+    $base64 = [Convert]::ToBase64String($bytes)
+    $encodeTimer.Stop()
+    $totalTimer.Stop()
+    $virtualBounds = [System.Windows.Forms.SystemInformation]::VirtualScreen
+    $monitorCount = @([System.Windows.Forms.Screen]::AllScreens).Count
 
     return [pscustomobject]@{
       ok = $true
       mimeType = "image/jpeg"
-      data = [Convert]::ToBase64String($bytes)
+      data = $base64
       width = $finalWidth
       height = $finalHeight
+      virtualDesktopOriginX = $virtualBounds.Left
+      virtualDesktopOriginY = $virtualBounds.Top
+      virtualDesktopWidth = $virtualBounds.Width
+      virtualDesktopHeight = $virtualBounds.Height
+      monitorCount = $monitorCount
+      jpegQuality = $finalQuality
       desktopOriginX = $bounds.Left
       desktopOriginY = $bounds.Top
       desktopWidth = $bounds.Width
@@ -223,6 +315,11 @@ function Invoke-Screenshot($Payload) {
       isPrimary = [bool]$screen.Primary
       deviceName = [string]$screen.DeviceName
       byteLength = $bytes.Length
+      timing = [pscustomobject]@{
+        captureMs = $captureMs
+        encodeMs = [int][Math]::Round($encodeTimer.Elapsed.TotalMilliseconds)
+        screenshotTotalMs = [int][Math]::Round($totalTimer.Elapsed.TotalMilliseconds)
+      }
     }
   } catch {
     return Result-Error "capture_failed"
@@ -295,61 +392,166 @@ function Invoke-KeyboardInput($Payload) {
   return [pscustomobject]@{ ok = $true; action = "keyboard_input" }
 }
 
+function Invoke-ClipboardRead($Payload) {
+  if (-not [System.Windows.Forms.SystemInformation]::UserInteractive) { return Result-Error "session_unavailable" }
+  try {
+    $text = if ([System.Windows.Forms.Clipboard]::ContainsText()) { [System.Windows.Forms.Clipboard]::GetText() } else { "" }
+    $truncated = $text.Length -gt 8192
+    if ($truncated) { $text = $text.Substring(0, 8192) }
+    return [pscustomobject]@{ ok = $true; text = $text; truncated = $truncated }
+  } catch { return Result-Error "clipboard_failed" }
+}
+
+function Invoke-ClipboardWrite($Payload) {
+  if (-not (Test-InteractiveSession)) { return Result-Error "session_unavailable" }
+  try {
+    $text = [string]$Payload.text
+    if ($text.Length -gt 8192) { return Result-Error "text_too_large" }
+    if ($text.Length -eq 0) { [System.Windows.Forms.Clipboard]::Clear() } else { [System.Windows.Forms.Clipboard]::SetText($text) }
+    return [pscustomobject]@{ ok = $true; action = "clipboard_write"; length = $text.Length }
+  } catch { return Result-Error "clipboard_failed" }
+}
+
+function Invoke-WindowList($Payload) {
+  if (-not [System.Windows.Forms.SystemInformation]::UserInteractive) { return Result-Error "session_unavailable" }
+  $limit = if ($null -eq $Payload.limit) { 50 } else { [int]$Payload.limit }
+  if ($limit -lt 1 -or $limit -gt 100) { return Result-Error "invalid_window_limit" }
+  try {
+    $windows = @([ChatRelayNative]::ListWindows($limit))
+    return [pscustomobject]@{ ok = $true; windows = $windows; count = $windows.Count }
+  } catch { return Result-Error "window_list_failed" }
+}
+
+function Invoke-WindowFocus($Payload) {
+  if (-not (Test-InteractiveSession)) { return Result-Error "session_unavailable" }
+  $windowId = [string]$Payload.windowId
+  if ($windowId -notmatch '^[1-9][0-9]{0,19}$') { return Result-Error "invalid_window_id" }
+  try {
+    if (-not [ChatRelayNative]::FocusWindow($windowId)) { return Result-Error "focus_failed" }
+    return [pscustomobject]@{ ok = $true; action = "window_focus"; windowId = $windowId }
+  } catch { return Result-Error "focus_failed" }
+}
+
 function Invoke-Step($Payload) {
+  $totalTimer = [System.Diagnostics.Stopwatch]::StartNew()
   $completed = 0
+  $inputMs = 0
+  $explicitWaitMs = 0
+  $settleMs = 0
+
   foreach ($action in @($Payload.actions)) {
     $result = $null
-    switch ([string]$action.type) {
-      "click" { $result = Invoke-MouseClick $action }
-      "text" { $result = Invoke-KeyboardInput $action }
-      "key" { $result = Invoke-KeyboardInput $action }
-      "wait" {
-        Start-Sleep -Milliseconds ([int]$action.ms)
-        $result = [pscustomobject]@{ ok = $true; action = "wait" }
+    if ([string]$action.type -eq "wait") {
+      $waitTimer = [System.Diagnostics.Stopwatch]::StartNew()
+      Start-Sleep -Milliseconds ([int]$action.ms)
+      $waitTimer.Stop()
+      $explicitWaitMs += [int][Math]::Round($waitTimer.Elapsed.TotalMilliseconds)
+      $result = [pscustomobject]@{ ok = $true; action = "wait" }
+    } else {
+      $inputTimer = [System.Diagnostics.Stopwatch]::StartNew()
+      switch ([string]$action.type) {
+        "click" { $result = Invoke-MouseClick $action }
+        "text" { $result = Invoke-KeyboardInput $action }
+        "key" { $result = Invoke-KeyboardInput $action }
+        default { $result = Result-Error "invalid_step_action" }
       }
-      default { $result = Result-Error "invalid_step_action" }
+      $inputTimer.Stop()
+      $inputMs += [int][Math]::Round($inputTimer.Elapsed.TotalMilliseconds)
     }
 
     if (-not $result.ok) {
+      $totalTimer.Stop()
       return [pscustomobject]@{
         ok = $false
         error = $result.error
         actionsCompleted = $completed
+        timing = [pscustomobject]@{
+          inputMs = $inputMs
+          explicitWaitMs = $explicitWaitMs
+          settleMs = $settleMs
+          captureMs = 0
+          encodeMs = 0
+          workerMs = [int][Math]::Round($totalTimer.Elapsed.TotalMilliseconds)
+        }
       }
     }
+
     $completed++
+    $actionSettleMs = [int]$action.settleAfterMs
+    if ($actionSettleMs -gt 0) {
+      $settleTimer = [System.Diagnostics.Stopwatch]::StartNew()
+      Start-Sleep -Milliseconds $actionSettleMs
+      $settleTimer.Stop()
+      $settleMs += [int][Math]::Round($settleTimer.Elapsed.TotalMilliseconds)
+    }
   }
 
   if ([int]$Payload.settleMs -gt 0) {
+    $finalSettleTimer = [System.Diagnostics.Stopwatch]::StartNew()
     Start-Sleep -Milliseconds ([int]$Payload.settleMs)
+    $finalSettleTimer.Stop()
+    $settleMs += [int][Math]::Round($finalSettleTimer.Elapsed.TotalMilliseconds)
   }
 
-  if ($Payload.captureAfter -eq $false) {
+  if ($Payload.captureAfter -ne $true) {
+    $totalTimer.Stop()
     return [pscustomobject]@{
       ok = $true
       action = "step"
       actionsCompleted = $completed
+      timing = [pscustomobject]@{
+        inputMs = $inputMs
+        explicitWaitMs = $explicitWaitMs
+        settleMs = $settleMs
+        captureMs = 0
+        encodeMs = 0
+        workerMs = [int][Math]::Round($totalTimer.Elapsed.TotalMilliseconds)
+      }
     }
   }
 
-  $shotPayload = [pscustomobject]@{ monitor = $Payload.monitor }
+  $shotPayload = [pscustomobject]@{ monitor = $Payload.monitor; maxWidth = $Payload.maxWidth; quality = $Payload.quality }
   $shot = Invoke-Screenshot $shotPayload
   if (-not $shot.ok) {
+    $totalTimer.Stop()
     return [pscustomobject]@{
       ok = $false
       error = $shot.error
       actionsCompleted = $completed
+      timing = [pscustomobject]@{
+        inputMs = $inputMs
+        explicitWaitMs = $explicitWaitMs
+        settleMs = $settleMs
+        captureMs = 0
+        encodeMs = 0
+        workerMs = [int][Math]::Round($totalTimer.Elapsed.TotalMilliseconds)
+      }
     }
   }
 
+  $totalTimer.Stop()
+  $captureMs = if ($null -ne $shot.timing) { [int]$shot.timing.captureMs } else { 0 }
+  $encodeMs = if ($null -ne $shot.timing) { [int]$shot.timing.encodeMs } else { 0 }
   $shot | Add-Member -NotePropertyName action -NotePropertyValue "step" -Force
   $shot | Add-Member -NotePropertyName actionsCompleted -NotePropertyValue $completed -Force
+  $shot | Add-Member -NotePropertyName timing -NotePropertyValue ([pscustomobject]@{
+    inputMs = $inputMs
+    explicitWaitMs = $explicitWaitMs
+    settleMs = $settleMs
+    captureMs = $captureMs
+    encodeMs = $encodeMs
+    workerMs = [int][Math]::Round($totalTimer.Elapsed.TotalMilliseconds)
+  }) -Force
   return $shot
 }
 
 function Invoke-Operation([string]$Operation, $Payload) {
   switch ($Operation) {
     "screenshot" { return Invoke-Screenshot $Payload }
+    "clipboard_read" { return Invoke-ClipboardRead $Payload }
+    "clipboard_write" { return Invoke-ClipboardWrite $Payload }
+    "window_list" { return Invoke-WindowList $Payload }
+    "window_focus" { return Invoke-WindowFocus $Payload }
     "mouse_click" { return Invoke-MouseClick $Payload }
     "keyboard_input" { return Invoke-KeyboardInput $Payload }
     "step" { return Invoke-Step $Payload }

package/cli/config.mjs

@@ -1,114 +1,114 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-export function configDir() {
-  if (process.env.CHAT_RELAY_HOME) return path.resolve(process.env.CHAT_RELAY_HOME);
-  if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
-    return path.join(base, "chat-relay");
-  }
-  const base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
-  return path.join(base, "chat-relay");
-}
-
-export function configPath() {
-  return path.join(configDir(), "config.json");
-}
-
-export function identityPath() {
-  return path.join(configDir(), "identity.json");
-}
-
-export function loadIdentity() {
-  const file = identityPath();
-  if (!fs.existsSync(file)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-
-export function saveIdentity(identity) {
-  const dir = configDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = identityPath();
-  fs.writeFileSync(file, JSON.stringify(identity, null, 2) + os.EOL, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-  try { fs.chmodSync(file, 0o600); } catch {}
-  return file;
-}
-
-function parseEnvFile(file) {
-  const result = {};
-  for (const raw of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || !line.includes("=")) continue;
-    const index = line.indexOf("=");
-    result[line.slice(0, index)] = line.slice(index + 1);
-  }
-  return result;
-}
-
-function migrateLegacyConfig() {
-  const legacyPath = path.resolve(".dev.vars");
-  if (!fs.existsSync(legacyPath)) return null;
-  const legacy = parseEnvFile(legacyPath);
-  if (!legacy.RELAY_URL || !legacy.CALLER_TOKEN || !legacy.AGENT_TOKEN) return null;
-
-  const config = {
-    relayUrl: legacy.RELAY_URL.replace(/\/$/, ""),
-    user: { id: "owner", name: "Owner", login: null },
-    userToken: legacy.CALLER_TOKEN,
-    agentId: legacy.AGENT_ID || "default",
-    agentName: legacy.AGENT_NAME || "Primary PC",
-    agentToken: legacy.AGENT_TOKEN,
-    allowedRoots: legacy.ALLOWED_ROOTS || defaultAllowedRoot(),
-    terminalEnabled: legacy.TERMINAL_ENABLED !== "0",
-    desktopEnabled: legacy.DESKTOP_ENABLED === "1",
-    migratedAt: new Date().toISOString(),
-  };
-  saveConfig(config);
-  saveIdentity({
-    agentId: config.agentId,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  });
-  return config;
-}
-
-export function loadConfig() {
-  const file = configPath();
-  if (!fs.existsSync(file)) return migrateLegacyConfig();
-  try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    throw new Error(`Invalid Chat Relay config: ${file}`);
-  }
-}
-
-export function saveConfig(config) {
-  const dir = configDir();
-  fs.mkdirSync(dir, { recursive: true });
-  const file = configPath();
-  fs.writeFileSync(file, JSON.stringify(config, null, 2) + os.EOL, {
-    encoding: "utf8",
-    mode: 0o600,
-  });
-  try { fs.chmodSync(file, 0o600); } catch {}
-  return file;
-}
-
-export function clearConfig() {
-  const file = configPath();
-  if (fs.existsSync(file)) fs.rmSync(file, { force: true });
-}
-
-export function defaultAllowedRoot() {
-  const projects = path.join(os.homedir(), "Projects");
-  if (fs.existsSync(projects)) return projects;
-  return os.homedir();
-}
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function configDir() {
+  if (process.env.CHAT_RELAY_HOME) return path.resolve(process.env.CHAT_RELAY_HOME);
+  if (process.platform === "win32") {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
+    return path.join(base, "chat-relay");
+  }
+  const base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return path.join(base, "chat-relay");
+}
+
+export function configPath() {
+  return path.join(configDir(), "config.json");
+}
+
+export function identityPath() {
+  return path.join(configDir(), "identity.json");
+}
+
+export function loadIdentity() {
+  const file = identityPath();
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveIdentity(identity) {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const file = identityPath();
+  fs.writeFileSync(file, JSON.stringify(identity, null, 2) + os.EOL, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  try { fs.chmodSync(file, 0o600); } catch {}
+  return file;
+}
+
+function parseEnvFile(file) {
+  const result = {};
+  for (const raw of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || !line.includes("=")) continue;
+    const index = line.indexOf("=");
+    result[line.slice(0, index)] = line.slice(index + 1);
+  }
+  return result;
+}
+
+function migrateLegacyConfig() {
+  const legacyPath = path.resolve(".dev.vars");
+  if (!fs.existsSync(legacyPath)) return null;
+  const legacy = parseEnvFile(legacyPath);
+  if (!legacy.RELAY_URL || !legacy.CALLER_TOKEN || !legacy.AGENT_TOKEN) return null;
+
+  const config = {
+    relayUrl: legacy.RELAY_URL.replace(/\/$/, ""),
+    user: { id: "owner", name: "Owner", login: null },
+    userToken: legacy.CALLER_TOKEN,
+    agentId: legacy.AGENT_ID || "default",
+    agentName: legacy.AGENT_NAME || "Primary PC",
+    agentToken: legacy.AGENT_TOKEN,
+    allowedRoots: legacy.ALLOWED_ROOTS || defaultAllowedRoot(),
+    terminalEnabled: legacy.TERMINAL_ENABLED !== "0",
+    desktopEnabled: legacy.DESKTOP_ENABLED === "1",
+    migratedAt: new Date().toISOString(),
+  };
+  saveConfig(config);
+  saveIdentity({
+    agentId: config.agentId,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  });
+  return config;
+}
+
+export function loadConfig() {
+  const file = configPath();
+  if (!fs.existsSync(file)) return migrateLegacyConfig();
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    throw new Error(`Invalid Chat Relay config: ${file}`);
+  }
+}
+
+export function saveConfig(config) {
+  const dir = configDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const file = configPath();
+  fs.writeFileSync(file, JSON.stringify(config, null, 2) + os.EOL, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  try { fs.chmodSync(file, 0o600); } catch {}
+  return file;
+}
+
+export function clearConfig() {
+  const file = configPath();
+  if (fs.existsSync(file)) fs.rmSync(file, { force: true });
+}
+
+export function defaultAllowedRoot() {
+  const projects = path.join(os.homedir(), "Projects");
+  if (fs.existsSync(projects)) return projects;
+  return os.homedir();
+}