@anusornneal/chat-relay 0.6.0

package/agent/process-manager.mjs

@@ -0,0 +1,69 @@
+import { execFile } from "node:child_process";
+import os from "node:os";
+
+function execPowerShell(script, timeout = 15000) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "powershell.exe",
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script],
+      { timeout, windowsHide: true, maxBuffer: 256 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(stderr?.trim() || error.message));
+          return;
+        }
+        resolve(stdout);
+      },
+    );
+  });
+}
+
+export class ProcessManager {
+  async list(filter = "") {
+    const escaped = String(filter).replace(/'/g, "''");
+    const where = escaped
+      ? ` | Where-Object { $_.Name -like '*${escaped}*' -or $_.CommandLine -like '*${escaped}*' }`
+      : "";
+    const script =
+      "$items = Get-CimInstance Win32_Process" + where +
+      " | Select-Object ProcessId,Name,CommandLine,ExecutablePath;" +
+      "$items | ConvertTo-Json -Compress -Depth 3";
+    const stdout = await execPowerShell(script);
+    if (!stdout.trim()) return [];
+    const parsed = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed : [parsed];
+  }
+
+  async kill(pid) {
+    const value = Number(pid);
+    if (!Number.isInteger(value) || value <= 100 || value === process.pid) {
+      throw new Error("invalid_or_protected_pid");
+    }
+    return new Promise((resolve, reject) => {
+      execFile("taskkill.exe", ["/PID", String(value), "/T", "/F"], { windowsHide: true }, (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(stderr?.trim() || error.message));
+          return;
+        }
+        resolve({ ok: true, pid: value, output: stdout.trim() });
+      });
+    });
+  }
+
+  info(extra = {}) {
+    return {
+      platform: process.platform,
+      arch: process.arch,
+      nodeVersion: process.version,
+      hostname: os.hostname(),
+      username: os.userInfo().username,
+      homeDir: os.homedir(),
+      cwd: process.cwd(),
+      cpus: os.cpus().length,
+      totalMemoryBytes: os.totalmem(),
+      freeMemoryBytes: os.freemem(),
+      uptimeSeconds: os.uptime(),
+      ...extra,
+    };
+  }
+}

package/agent/terminal-manager.mjs

@@ -0,0 +1,229 @@
+import { execFile, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+
+const MAX_EXEC_BUFFER = 48 * 1024;
+const MAX_SESSION_BUFFER = 256 * 1024;
+const MAX_READ_CHARS = 24 * 1024;
+const MAX_INPUT_CHARS = 8 * 1024;
+const MAX_SESSIONS = 8;
+const ENDED_TTL_MS = 30 * 60 * 1000;
+
+const BLOCKED_COMMANDS = [
+  /\b(mkfs|format|mount|umount|fdisk|dd|parted|diskpart|sudo|su|passwd)\b/i,
+  /\b(adduser|useradd|usermod|groupadd|chsh|visudo|shutdown|reboot|halt)\b/i,
+  /\b(poweroff|init|iptables|firewall|netsh|sfc|bcdedit|runas|cipher|takeown)\b/i,
+  /\b(reg|sc)\.exe\b/i,
+];
+
+function validateCommand(command) {
+  if (typeof command !== "string" || command.length === 0 || command.length > 4000) {
+    throw new Error("invalid_command");
+  }
+  if (BLOCKED_COMMANDS.some((pattern) => pattern.test(command))) {
+    throw new Error("command_blocked");
+  }
+}
+
+function normalizeTimeout(timeoutMs, fallback = 15000, max = 20000) {
+  const value = Number(timeoutMs);
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(Math.max(Math.trunc(value), 1000), max);
+}
+
+function safeCwd(cwd) {
+  if (cwd === undefined || cwd === null || cwd === "") return process.cwd();
+  if (typeof cwd !== "string" || cwd.length > 1024) throw new Error("invalid_cwd");
+  return cwd;
+}
+
+export class TerminalManager {
+  constructor() {
+    this.sessions = new Map();
+  }
+
+  async exec(command, cwd, timeoutMs) {
+    validateCommand(command);
+    const resolvedCwd = safeCwd(cwd);
+    const timeout = normalizeTimeout(timeoutMs);
+
+    return new Promise((resolve) => {
+      execFile(
+        "powershell.exe",
+        ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command],
+        {
+          cwd: resolvedCwd,
+          timeout,
+          windowsHide: true,
+          maxBuffer: MAX_EXEC_BUFFER,
+        },
+        (error, stdout, stderr) => {
+          resolve({
+            ok: !error,
+            exitCode: typeof error?.code === "number" ? error.code : (error ? 1 : 0),
+            stdout: stdout ?? "",
+            stderr: stderr ?? "",
+            error: error ? error.message : null,
+          });
+        },
+      );
+    });
+  }
+
+  start(command, cwd) {
+    validateCommand(command);
+    return this.#spawnSession({
+      type: "command",
+      command,
+      cwd: safeCwd(cwd),
+      args: ["-NoLogo", "-NoProfile", "-Command", command],
+    });
+  }
+
+  startShell(cwd) {
+    return this.#spawnSession({
+      type: "shell",
+      command: "powershell",
+      cwd: safeCwd(cwd),
+      args: ["-NoLogo", "-NoProfile", "-NoExit", "-Command", "-"],
+    });
+  }
+
+  list() {
+    this.#cleanup();
+    return [...this.sessions.values()].map((session) => this.#summary(session));
+  }
+
+  read(sessionId, afterSeq = 0, maxChars = MAX_READ_CHARS) {
+    this.#cleanup();
+    const session = this.#get(sessionId);
+    const limit = Math.min(Math.max(Number(maxChars) || MAX_READ_CHARS, 1024), MAX_READ_CHARS);
+    const oldestSeq = session.chunks[0]?.seq ?? session.nextSeq;
+    const chunks = [];
+    let chars = 0;
+
+    for (const chunk of session.chunks) {
+      if (chunk.seq <= afterSeq) continue;
+      if (chunks.length > 0 && chars + chunk.text.length > limit) break;
+      chunks.push(chunk);
+      chars += chunk.text.length;
+    }
+
+    return {
+      ...this.#summary(session),
+      chunks,
+      oldestSeq,
+      nextSeq: chunks.at(-1)?.seq ?? afterSeq,
+      truncated: afterSeq < oldestSeq - 1,
+    };
+  }
+
+  write(sessionId, input, appendNewline = true) {
+    const session = this.#get(sessionId);
+    if (session.status !== "running") throw new Error("session_not_running");
+    if (typeof input !== "string" || input.length === 0 || input.length > MAX_INPUT_CHARS) {
+      throw new Error("invalid_input");
+    }
+    session.process.stdin.write(input + (appendNewline ? os.EOL : ""));
+    return this.#summary(session);
+  }
+
+  async kill(sessionId) {
+    const session = this.#get(sessionId);
+    if (session.status !== "running") return this.#summary(session);
+
+    await new Promise((resolve) => {
+      execFile("taskkill.exe", ["/PID", String(session.pid), "/T", "/F"], () => resolve());
+    });
+    return this.#summary(session);
+  }
+
+  #spawnSession({ type, command, cwd, args }) {
+    this.#cleanup();
+    const running = [...this.sessions.values()].filter((session) => session.status === "running").length;
+    if (running >= MAX_SESSIONS) throw new Error("too_many_sessions");
+
+    const child = spawn("powershell.exe", args, {
+      cwd,
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const session = {
+      id: randomUUID(),
+      type,
+      command,
+      cwd,
+      pid: child.pid,
+      process: child,
+      status: "running",
+      exitCode: null,
+      signal: null,
+      startedAt: new Date().toISOString(),
+      endedAt: null,
+      chunks: [],
+      nextSeq: 1,
+      totalChars: 0,
+    };
+
+    this.sessions.set(session.id, session);
+    child.stdout.on("data", (data) => this.#append(session, "stdout", data));
+    child.stderr.on("data", (data) => this.#append(session, "stderr", data));
+    child.on("error", (error) => this.#append(session, "stderr", error.message + os.EOL));
+    child.on("exit", (code, signal) => {
+      session.status = "exited";
+      session.exitCode = code;
+      session.signal = signal;
+      session.endedAt = new Date().toISOString();
+    });
+
+    return this.#summary(session);
+  }
+
+  #append(session, stream, data) {
+    const text = data.toString();
+    for (let offset = 0; offset < text.length; offset += 4096) {
+      const part = text.slice(offset, offset + 4096);
+      session.chunks.push({ seq: session.nextSeq++, stream, text: part });
+      session.totalChars += part.length;
+    }
+
+    while (session.totalChars > MAX_SESSION_BUFFER && session.chunks.length > 1) {
+      const removed = session.chunks.shift();
+      session.totalChars -= removed.text.length;
+    }
+  }
+
+  #summary(session) {
+    return {
+      sessionId: session.id,
+      type: session.type,
+      command: session.command,
+      cwd: session.cwd,
+      pid: session.pid,
+      status: session.status,
+      exitCode: session.exitCode,
+      signal: session.signal,
+      startedAt: session.startedAt,
+      endedAt: session.endedAt,
+      nextSeq: session.nextSeq - 1,
+    };
+  }
+
+  #get(sessionId) {
+    if (typeof sessionId !== "string") throw new Error("invalid_session_id");
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error("session_not_found");
+    return session;
+  }
+
+  #cleanup() {
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (session.status === "running" || !session.endedAt) continue;
+      if (now - Date.parse(session.endedAt) > ENDED_TTL_MS) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+}

package/bin/chat-relay.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { runCli } from "../cli/index.mjs";
+
+const code = await runCli(process.argv.slice(2));
+if (Number.isInteger(code) && code !== 0) process.exitCode = code;

package/cli/config.mjs

@@ -0,0 +1,113 @@
+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",
+    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();
+}

package/cli/device-login.mjs

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import os from "node:os";
+import {
+  defaultAllowedRoot,
+  loadConfig,
+  loadIdentity,
+  saveConfig,
+  saveIdentity,
+} from "./config.mjs";
+
+const DEFAULT_RELAY_URL = "https://chat-relay.anusorn-hank.workers.dev";
+
+function sanitizeAgentId(value) {
+  const normalized = value.toLowerCase().trim()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 54) || "machine";
+  return normalized;
+}
+
+function createAgentId(hostname) {
+  return `${sanitizeAgentId(hostname)}-${randomBytes(4).toString("hex")}`;
+}
+
+async function requestJson(url, options = {}, timeoutMs = 10_000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+      headers: {
+        accept: "application/json",
+        ...(options.body ? { "content-type": "application/json" } : {}),
+        ...(options.headers || {}),
+      },
+    });
+    const text = await response.text();
+    let data;
+    try { data = text ? JSON.parse(text) : {}; }
+    catch { data = { raw: text }; }
+    return { response, data };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function openBrowser(url) {
+  if (process.env.CHAT_RELAY_NO_BROWSER === "1") return false;
+  try {
+    if (process.platform === "win32") {
+      const child = spawn("cmd.exe", ["/c", "start", "", url], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      child.unref();
+      return true;
+    }
+    if (process.platform === "darwin") {
+      const child = spawn("open", [url], { detached: true, stdio: "ignore" });
+      child.unref();
+      return true;
+    }
+    const child = spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function login(options = {}) {
+  const existing = loadConfig() || {};
+  const relayUrl = String(options.relayUrl || existing.relayUrl || DEFAULT_RELAY_URL).replace(/\/$/, "");
+  const hostname = os.hostname();
+  const identity = loadIdentity() || {};
+  const requestedAgentId = options.agentId ||
+    existing.agentId ||
+    identity.agentId ||
+    createAgentId(hostname);
+  const agentName = options.agentName || existing.agentName || hostname;
+  const allowedRoots = options.allowedRoot || existing.allowedRoots || defaultAllowedRoot();
+
+  saveIdentity({
+    agentId: requestedAgentId,
+    createdAt: identity.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  });
+
+  const { response, data } = await requestJson(`${relayUrl}/auth/device/start`, {
+    method: "POST",
+    body: JSON.stringify({ agentId: requestedAgentId, agentName }),
+  });
+  if (!response.ok) {
+    throw new Error(`Unable to start device login: ${data.error || response.status}`);
+  }
+
+  console.log("");
+  console.log("Chat Relay sign in");
+  console.log("------------------");
+  console.log(`Code: ${data.userCode}`);
+  console.log(`Open: ${data.verificationUriComplete}`);
+  console.log("");
+
+  const opened = options.noOpen ? false : openBrowser(data.verificationUriComplete);
+  console.log(opened ? "Browser opened. Waiting for authorization..." : "Open the URL above to continue.");
+
+  const deadline = Date.now() + Number(data.expiresIn || 600) * 1000;
+  const intervalMs = Math.max(Number(data.interval || 2), 1) * 1000;
+
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    const tokenResult = await requestJson(`${relayUrl}/auth/device/token`, {
+      method: "POST",
+      body: JSON.stringify({ deviceCode: data.deviceCode }),
+    });
+
+    if (tokenResult.response.status === 428 && tokenResult.data.error === "authorization_pending") {
+      continue;
+    }
+    if (!tokenResult.response.ok) {
+      throw new Error(`Device login failed: ${tokenResult.data.error || tokenResult.response.status}`);
+    }
+
+    const result = tokenResult.data;
+
+    if (existing.userToken && existing.relayUrl) {
+      const revoke = await requestJson(`${String(existing.relayUrl).replace(/\/$/, "")}/auth/session/revoke`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${existing.userToken}` },
+      }).catch(() => null);
+      if (revoke && !revoke.response.ok && revoke.response.status !== 401) {
+        console.warn("Warning: previous Chat Relay session could not be revoked.");
+      }
+    }
+
+    saveIdentity({
+      agentId: result.agent.id,
+      createdAt: identity.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    const config = {
+      relayUrl,
+      user: result.user,
+      userToken: result.userToken,
+      userTokenExpiresAt: result.userTokenExpiresAt,
+      agentId: result.agent.id,
+      agentName: result.agent.name,
+      agentToken: result.agentToken,
+      allowedRoots,
+      terminalEnabled: true,
+      loggedInAt: new Date().toISOString(),
+    };
+    const file = saveConfig(config);
+
+    console.log(`Signed in as ${result.user.name}.`);
+    console.log(`Registered ${result.agent.name} (${result.agent.id}).`);
+    console.log(`Saved credentials to ${file}`);
+    return config;
+  }
+
+  throw new Error("Device login expired. Run the login command again.");
+}
+
+export { DEFAULT_RELAY_URL, requestJson };