nolo-cli 0.1.26 → 0.1.29

package/server/handlers/machines/machineInstallAssets.ts

@@ -0,0 +1,563 @@
+const DAEMON_SCRIPT = String.raw`#!/usr/bin/env bun
+
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform, arch } from "node:os";
+import { dirname, join } from "node:path";
+
+const args = process.argv.slice(2);
+
+function readOption(flag, fallback) {
+  const index = args.indexOf(flag);
+  return index >= 0 && args[index + 1] ? args[index + 1] : fallback;
+}
+
+const serverUrl = (readOption("--server-url", process.env.NOLO_SERVER) || "").replace(/\/+$/, "");
+const apiKey = readOption("--api-key", process.env.AUTH_TOKEN || process.env.NOLO_MACHINE_API_KEY);
+
+if (!serverUrl || !apiKey || args.includes("--help") || args.includes("-h")) {
+  console.log("Usage: bun nolo-daemon.js --server-url <url> --api-key <sk_machine_xxx>");
+  process.exit(args.includes("--help") || args.includes("-h") ? 0 : 1);
+}
+
+const stateDir = join(homedir(), ".nolo", "daemon");
+const logDir = join(homedir(), ".nolo", "logs");
+const machineIdFile = join(stateDir, "machine-id");
+const configFile = join(stateDir, "config.json");
+mkdirSync(stateDir, { recursive: true });
+mkdirSync(logDir, { recursive: true });
+
+function readConfig() {
+  try {
+    if (!existsSync(configFile)) return {};
+    const parsed = JSON.parse(readFileSync(configFile, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    console.error("[nolo] Failed to read config:", error instanceof Error ? error.message : String(error));
+    return {};
+  }
+}
+
+const daemonConfig = readConfig();
+
+function getMachineId() {
+  if (existsSync(machineIdFile)) {
+    const existing = readFileSync(machineIdFile, "utf8").trim();
+    if (existing) return existing;
+  }
+  const id = "machine-" + randomUUID();
+  writeFileSync(machineIdFile, id);
+  return id;
+}
+
+function commandExists(command) {
+  return Boolean(resolveCommand(command));
+}
+
+function configuredCommand(command) {
+  const normalized = command.toLowerCase().replace(/\.exe$/, "");
+  const configured = daemonConfig?.commands?.[normalized];
+  if (typeof configured === "string" && configured.trim() && existsSync(configured)) {
+    return configured;
+  }
+  return null;
+}
+
+function knownWindowsCommand(command) {
+  if (process.platform !== "win32") return null;
+  const normalized = command.toLowerCase().replace(/\.exe$/, "");
+  if (normalized === "codex") {
+    if (process.env.NOLO_CODEX_PATH && existsSync(process.env.NOLO_CODEX_PATH)) {
+      return process.env.NOLO_CODEX_PATH;
+    }
+    const localRoots = [
+      process.env.LOCALAPPDATA,
+      process.env.USERPROFILE ? join(process.env.USERPROFILE, "AppData", "Local") : null,
+      join(homedir(), "AppData", "Local"),
+    ].filter(Boolean);
+    for (const localRoot of localRoots) {
+      const codexPath = join(localRoot, "OpenAI", "Codex", "bin", "codex.exe");
+      if (existsSync(codexPath)) return codexPath;
+    }
+  }
+  return null;
+}
+
+function resolveCommand(command) {
+  const configured = configuredCommand(command);
+  if (configured) return configured;
+  const known = knownWindowsCommand(command);
+  if (known) return known;
+  const extensions = process.platform === "win32" && !/\.[a-z0-9]+$/i.test(command)
+    ? [".exe", ".cmd", ".bat", ".com", ""]
+    : [""];
+  const candidates = process.platform === "win32" && !command.endsWith(".exe")
+    ? extensions.map((extension) => command + extension)
+    : [command];
+  for (const candidate of candidates) {
+    const result = process.platform === "win32"
+      ? spawnSync("where.exe", [candidate], { encoding: "utf8" })
+      : spawnSync("sh", ["-lc", "command -v " + command], { encoding: "utf8" });
+    if (result.status !== 0) continue;
+    const resolved = String(result.stdout || "")
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .find((line) => !(command.toLowerCase().replace(/\.exe$/, "") === "codex" && /\\WindowsApps\\/i.test(line)));
+    if (resolved) return resolved;
+  }
+  return null;
+}
+
+function detectCapabilities() {
+  return [
+    [["codex"], "codex-cli"],
+    [["copilot", "gh"], "copilot-cli"],
+    [["claude"], "claude-code"],
+    [["agy"], "agy-cli"],
+    [["gemini"], "gemini-cli"],
+  ].filter(([commands]) => commands.some((command) => commandExists(command))).map(([, capability]) => capability);
+}
+
+const machine = {
+  machineId: getMachineId(),
+  name: hostname(),
+  platform: platform(),
+  arch: arch(),
+  connectorVersion: "standalone-0.1.0",
+  capabilities: detectCapabilities(),
+};
+
+async function sendHeartbeat() {
+  const response = await fetch(serverUrl + "/api/machines/heartbeat", {
+    method: "POST",
+    headers: {
+      Authorization: "Bearer " + apiKey,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(machine),
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error("heartbeat failed HTTP " + response.status + "\n" + text);
+  }
+}
+
+function wsUrl() {
+  const url = new URL(serverUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  url.pathname = "/api/connector/ws";
+  url.search = "";
+  url.searchParams.set("machineId", machine.machineId);
+  return url.toString();
+}
+
+async function resolveConnectorTarget() {
+  const probeUrl = new URL(serverUrl);
+  probeUrl.pathname = "/api/connector/ws";
+  probeUrl.search = "";
+  probeUrl.searchParams.set("machineId", machine.machineId);
+  try {
+    const response = await fetch(probeUrl, {
+      headers: { Authorization: "Bearer " + apiKey },
+    });
+    const discovered = response.ok ? await response.json() : null;
+    return discovered?.wsUrl || wsUrl();
+  } catch {
+    return wsUrl();
+  }
+}
+
+function buildPrompt(agentConfig, userInput) {
+  const policy = resolveMachineRunPermissionPolicy(agentConfig);
+  return [
+    agentConfig?.prompt || "",
+    buildMachinePermissionPromptBlock(policy),
+    "--- User task ---\n" + String(userInput || "")
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+}
+
+function resolveMachineRunPermissionPolicy(agentConfig) {
+  const runtimeBinding = agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+    ? agentConfig.runtimeBinding
+    : {};
+  const raw = agentConfig?.machinePermissions && typeof agentConfig.machinePermissions === "object"
+    ? agentConfig.machinePermissions
+    : runtimeBinding.permissions && typeof runtimeBinding.permissions === "object"
+      ? runtimeBinding.permissions
+      : {};
+  const fullAccess = raw.mode === "full_access" || raw.allowFilesystemWrite === true || raw.allowShell === true;
+  if (fullAccess) {
+    return {
+      mode: "full_access",
+      allowFilesystemRead: raw.allowFilesystemRead !== false,
+      allowFilesystemWrite: true,
+      allowShell: raw.allowShell !== false,
+      writableRoots: Array.isArray(raw.writableRoots) ? raw.writableRoots.filter((item) => typeof item === "string" && item.trim()) : [],
+    };
+  }
+  return {
+    mode: "read_only",
+    allowFilesystemRead: raw.allowFilesystemRead !== false,
+    allowFilesystemWrite: false,
+    allowShell: false,
+    writableRoots: [],
+  };
+}
+
+function buildMachinePermissionPromptBlock(policy) {
+  return [
+    "--- Machine permission policy ---",
+    "Mode: " + policy.mode,
+    "Filesystem reads are " + (policy.allowFilesystemRead ? "allowed" : "not allowed") + ".",
+    "File writes are " + (policy.allowFilesystemWrite ? "allowed" : "not allowed") + ".",
+    "Arbitrary shell commands are " + (policy.allowShell ? "allowed" : "not allowed") + ".",
+    policy.writableRoots.length ? "Writable roots: " + policy.writableRoots.join(", ") : "Writable roots: none.",
+    "If the user asks for an operation outside this policy, refuse instead of attempting it.",
+  ].join("\n");
+}
+
+function assertMachineRunAllowed(userInput, policy) {
+  const writeIntentRe = /\b(write|overwrite|edit|modify|delete|remove|rename|move|create|save|patch|apply patch|mkdir|touch|rm|rmdir|del|erase|copy-item|move-item|remove-item|set-content|add-content|new-item)\b|(\u5199\u5165|\u5199\u6587\u4EF6|\u5220\u9664|\u79FB\u9664|\u91CD\u547D\u540D|\u79FB\u52A8|\u521B\u5EFA|\u65B0\u5EFA|\u4FDD\u5B58|\u4FEE\u6539|\u7F16\u8F91|\u6253\u8865\u4E01|\u5E94\u7528\u8865\u4E01)/i;
+  const shellIntentRe = /\b(run|execute|exec)\s+(?:a\s+)?(?:shell|command|terminal|powershell|pwsh|bash|zsh|cmd\.exe|npm|bun|node|python|git|curl|wget|ssh|scp|chmod|chown|sudo|tests?|test suite)\b|\b(open|start)\s+(?:a\s+)?(?:shell|terminal)\b|\b(powershell|pwsh|bash|zsh|cmd\.exe|ssh|sudo)\b|(\u8FD0\u884C\u547D\u4EE4|\u6267\u884C\u547D\u4EE4|\u547D\u4EE4\u884C|\u7EC8\u7AEF|\u63A7\u5236\u53F0)/i;
+  const negationRe = /\b(do not|don't|dont|never|no need to|without|非目标|不要|不需要|禁止|无需)\b|[\u4E0D\u975E]/i;
+  const task = String(userInput || "")
+    .split(/([\n.;!?。；！？])/)
+    .reduce((segments, part, index, parts) => {
+      if (index % 2 === 1) return segments;
+      const segment = part + (parts[index + 1] || "");
+      const mentionsRestrictedAction = writeIntentRe.test(segment) || shellIntentRe.test(segment);
+      if (mentionsRestrictedAction && negationRe.test(segment)) return segments;
+      segments.push(segment);
+      return segments;
+    }, [])
+    .join("");
+  const writeIntent = writeIntentRe.test(task);
+  const shellIntent = shellIntentRe.test(task);
+  if (!policy.allowFilesystemWrite && writeIntent) {
+    throw new Error("Machine permission denied: this bound machine agent is read-only for filesystem writes. Enable machine write permission for this agent before asking it to modify files.");
+  }
+  if (!policy.allowShell && shellIntent) {
+    throw new Error("Machine permission denied: this bound machine agent cannot run arbitrary shell commands. Enable machine shell permission for this agent before asking it to execute commands.");
+  }
+}
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const started = Date.now();
+    const executable = resolveCommand(command);
+    if (!executable) {
+      reject(new Error(command + " was not found in PATH"));
+      return;
+    }
+    console.log("[nolo] spawn", command, "=>", executable);
+    const proc = spawn(executable, args, {
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, NO_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = options.timeout || 120_000;
+    const timer = timeout > 0 ? setTimeout(() => {
+      proc.kill("SIGTERM");
+      reject(new Error(command + " timed out after " + timeout + "ms"));
+    }, timeout) : null;
+
+    proc.stdout.on("data", (data) => { stdout += data.toString(); });
+    proc.stderr.on("data", (data) => { stderr += data.toString(); });
+    proc.on("error", (error) => {
+      if (timer) clearTimeout(timer);
+      reject(error);
+    });
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(command + " exited with code " + code + "\n" + stderr));
+        return;
+      }
+      resolve({ text: stdout.trim(), raw: stdout, elapsed: Date.now() - started, executable });
+    });
+  });
+}
+
+async function runCodex(prompt, options) {
+  const tempDir = join(stateDir, "codex-" + randomUUID());
+  mkdirSync(tempDir, { recursive: true });
+  const outputFile = join(tempDir, "last-message.txt");
+  const args = [
+    "exec",
+    "--skip-git-repo-check",
+    "--ephemeral",
+    "--color",
+    "never",
+    "--output-last-message",
+    outputFile,
+    "--cd",
+    process.cwd(),
+  ];
+  if (options.model) args.push("--model", options.model);
+  args.push("--sandbox", "danger-full-access", prompt);
+  try {
+    const result = await runProcess("codex", args, options);
+    if (existsSync(outputFile)) {
+      const last = readFileSync(outputFile, "utf8").trim();
+      if (last) result.text = last;
+    }
+    return result;
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function runCopilot(prompt, options) {
+  const command = commandExists("copilot") ? "copilot" : "gh";
+  const args = command === "copilot"
+    ? ["-p", prompt, "--silent", "--disable-builtin-mcps", "--stream", "off", "--no-color", "--yolo"]
+    : ["copilot", "--", "-p", prompt, "--silent", "--disable-builtin-mcps", "--stream", "off", "--no-color", "--yolo"];
+  if (options.model) args.push("--model", options.model);
+  return runProcess(command, args, options).then((result) => ({
+    ...result,
+    text: result.text
+      .split("\n")
+      .filter((line) => !line.includes("A new release of gh is available"))
+      .filter((line) => !line.includes("To upgrade, run:"))
+      .join("\n")
+      .trim(),
+  }));
+}
+
+function runClaude(prompt, options) {
+  const args = ["-p", prompt, "--permission-mode", "bypassPermissions"];
+  if (options.model) args.push("--model", options.model);
+  return runProcess("claude", args, options);
+}
+
+function runAgy(prompt, options) {
+  return runProcess("agy", [
+    "--print",
+    prompt,
+    "--print-timeout",
+    "120s",
+    "--dangerously-skip-permissions",
+  ], options);
+}
+
+function runGemini(prompt, options) {
+  const args = ["-p", prompt, "--output-format", "text", "--yolo", "-e", "none"];
+  if (options.model) args.push("-m", options.model);
+  return runProcess("gemini", args, options);
+}
+
+async function executeCli(agentConfig, userInput) {
+  const provider = String(agentConfig?.cliProvider || "copilot");
+  const prompt = buildPrompt(agentConfig, userInput);
+  const options = { model: agentConfig?.model || undefined };
+  if (provider === "codex") return runCodex(prompt, options);
+  if (provider === "claude") return runClaude(prompt, options);
+  if (provider === "agy") return runAgy(prompt, options);
+  if (provider === "gemini") return runGemini(prompt, options);
+  return runCopilot(prompt, options);
+}
+
+async function handleMessage(ws, message) {
+  let parsed;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
+
+  try {
+    const agentConfig = parsed.payload?.agentConfig || {};
+    if (agentConfig.apiSource !== "cli") {
+      throw new Error("Legacy daemon.js can only execute CLI agents. Install or run nolo connect --ws for runtimeToolPolicy workspace agents.");
+    }
+    const userInput = String(parsed.payload?.userInput || "");
+    assertMachineRunAllowed(userInput, resolveMachineRunPermissionPolicy(agentConfig));
+    const result = await executeCli(agentConfig, userInput);
+    ws.send(JSON.stringify({
+      type: "agent.run.result",
+      requestId: parsed.requestId,
+      result: {
+        content: result.text,
+        model: agentConfig.model || agentConfig.cliProvider || "cli",
+        trace: [{ role: "assistant", content: result.text }],
+        diagnostics: {
+          executable: result.executable,
+          elapsedMs: result.elapsed,
+        },
+      },
+    }));
+  } catch (error) {
+    ws.send(JSON.stringify({
+      type: "agent.run.result",
+      requestId: parsed.requestId,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+}
+
+async function connectWebSocket() {
+  return new Promise((resolve, reject) => {
+    resolveConnectorTarget().then((target) => {
+      const ws = new WebSocket(target, { headers: { Authorization: "Bearer " + apiKey } });
+      let opened = false;
+      ws.addEventListener("open", () => {
+        opened = true;
+        console.log("[nolo] Connector websocket connected:", machine.name, machine.machineId);
+      });
+      ws.addEventListener("message", (event) => {
+        void handleMessage(ws, String(event.data));
+      });
+      ws.addEventListener("error", () => reject(new Error("connector websocket error")));
+      ws.addEventListener("close", () => {
+        if (opened) resolve();
+        else reject(new Error("connector websocket closed before opening"));
+      });
+    }).catch(reject);
+  });
+}
+
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+console.log("[nolo] Starting connector daemon:", machine.name, machine.platform + "/" + machine.arch);
+console.log("[nolo] Capabilities:", machine.capabilities.join(", ") || "none");
+
+while (true) {
+  try {
+    await sendHeartbeat();
+    const heartbeatTimer = setInterval(() => {
+      sendHeartbeat().catch((error) => console.error("[nolo]", error.message));
+    }, 30_000);
+    await connectWebSocket();
+    clearInterval(heartbeatTimer);
+  } catch (error) {
+    console.error("[nolo]", error instanceof Error ? error.message : String(error));
+  }
+  await sleep(5_000);
+}
+`;
+
+export function getMachineInstallAsset(pathname: string) {
+  if (pathname.endsWith("/daemon.js")) {
+    return {
+      body: DAEMON_SCRIPT,
+      contentType: "application/javascript; charset=utf-8",
+    };
+  }
+
+  if (pathname.endsWith("/install.ps1")) {
+    return {
+      body: String.raw`param(
+  [Alias("Server")][string]$ServerUrl,
+  [Alias("Token")][string]$ApiKey
+)
+
+$ErrorActionPreference = "Stop"
+
+function Install-NoloCli {
+  $nolo = Get-Command nolo -ErrorAction SilentlyContinue
+  if ($nolo) {
+    Write-Output "[nolo] CLI already installed at: $($nolo.Source)"
+    return
+  }
+
+  Write-Output "[nolo] Installing nolo-cli@latest..."
+  try {
+    npm install -g nolo-cli@latest
+  } catch {
+    throw "Failed to install nolo-cli. Ensure npm is installed and available."
+  }
+
+  $nolo = Get-Command nolo -ErrorAction SilentlyContinue
+  if (-not $nolo) {
+    throw "nolo-cli installation succeeded but nolo command not found in PATH"
+  }
+  Write-Output "[nolo] CLI installed successfully at: $($nolo.Source)"
+}
+
+if ([string]::IsNullOrWhiteSpace($ServerUrl) -or [string]::IsNullOrWhiteSpace($ApiKey)) {
+  Write-Output "Usage: powershell -ExecutionPolicy Bypass -File install.ps1 -ServerUrl <url> -ApiKey <key>"
+  exit 1
+}
+
+Install-NoloCli
+
+Write-Output "[nolo] Connecting machine to $ServerUrl..."
+ & nolo connect --ws --server-url "$ServerUrl" --api-key "$ApiKey"
+`,
+      contentType: "text/plain; charset=utf-8",
+    };
+  }
+
+  if (pathname.endsWith("/install.sh")) {
+    return {
+      body: `#!/usr/bin/env bash
+set -euo pipefail
+
+SERVER_URL=""
+API_KEY=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --server-url|--server)
+      SERVER_URL="\${2:-}"
+      shift 2
+      ;;
+    --api-key|--token)
+      API_KEY="\${2:-}"
+      shift 2
+      ;;
+    -h|--help)
+      echo "Usage: install.sh --server-url <url> --api-key <key>"
+      exit 0
+      ;;
+    *)
+      echo "[nolo] Unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "$SERVER_URL" || -z "$API_KEY" ]]; then
+  echo "[nolo] --server-url and --api-key are required." >&2
+  exit 1
+fi
+
+install_nolo_cli() {
+  if command -v nolo >/dev/null 2>&1; then
+    echo "[nolo] CLI already installed at: $(command -v nolo)"
+    return
+  fi
+
+  echo "[nolo] Installing nolo-cli@latest..."
+  if ! npm install -g nolo-cli@latest; then
+    echo "[nolo] Failed to install nolo-cli. Ensure npm is installed and available." >&2
+    exit 1
+  fi
+
+  if ! command -v nolo >/dev/null 2>&1; then
+    echo "[nolo] nolo-cli installation succeeded but nolo command not found in PATH" >&2
+    exit 1
+  fi
+  echo "[nolo] CLI installed successfully at: $(command -v nolo)"
+}
+
+install_nolo_cli
+
+echo "[nolo] Connecting machine to $SERVER_URL..."
+exec nolo connect --ws --server-url "$SERVER_URL" --api-key "$API_KEY"
+`,
+      contentType: "text/x-shellscript; charset=utf-8",
+    };
+  }
+
+  return null;
+}

package/server/handlers/machines/machineRegistry.ts

@@ -0,0 +1,89 @@
+import type { MachineHeartbeat } from "../../../connector-experimental/protocol";
+
+export type MachineStatus = "online" | "offline";
+
+export type MachineRecord = MachineHeartbeat & {
+  ownerUserId: string;
+  status: MachineStatus;
+  lastSeenAt: number;
+};
+
+export type MachineSummary = {
+  machineId: string;
+  name: string;
+  platform: string;
+  arch: string;
+  connectorVersion: string | null;
+  capabilities: string[];
+  status: MachineStatus;
+  lastSeenAt: number;
+};
+
+export type MachineRegistry = {
+  recordHeartbeat(ownerUserId: string, heartbeat: MachineHeartbeat): MachineRecord;
+  listMachines(ownerUserId: string): MachineRecord[];
+  removeMachine(ownerUserId: string, machineId: string): boolean;
+  clear(): void;
+};
+
+const DEFAULT_OFFLINE_AFTER_MS = 90_000;
+
+function projectStatus(record: MachineRecord, now: number, offlineAfterMs: number): MachineStatus {
+  return now - record.lastSeenAt > offlineAfterMs ? "offline" : "online";
+}
+
+export function serializeMachineSummary(record: MachineRecord): MachineSummary {
+  return {
+    machineId: record.machineId,
+    name: record.name,
+    platform: record.platform,
+    arch: record.arch,
+    connectorVersion: record.connectorVersion ?? null,
+    capabilities: [...record.capabilities],
+    status: record.status,
+    lastSeenAt: record.lastSeenAt,
+  };
+}
+
+export function createInMemoryMachineRegistry(
+  now = () => Date.now(),
+  options: { offlineAfterMs?: number } = {}
+): MachineRegistry {
+  const records = new Map<string, MachineRecord>();
+  const keyFor = (ownerUserId: string, machineId: string) => `${ownerUserId}:${machineId}`;
+  const offlineAfterMs = options.offlineAfterMs ?? DEFAULT_OFFLINE_AFTER_MS;
+
+  return {
+    recordHeartbeat(ownerUserId, heartbeat) {
+      const record: MachineRecord = {
+        ...heartbeat,
+        ownerUserId,
+        status: "online",
+        lastSeenAt: now(),
+      };
+      records.set(keyFor(ownerUserId, heartbeat.machineId), record);
+      return record;
+    },
+
+    listMachines(ownerUserId) {
+      const currentTime = now();
+      return [...records.values()]
+        .filter((record) => record.ownerUserId === ownerUserId)
+        .map((record) => ({
+          ...record,
+          status: projectStatus(record, currentTime, offlineAfterMs),
+        }))
+        .sort((a, b) => b.lastSeenAt - a.lastSeenAt || a.name.localeCompare(b.name));
+    },
+
+    removeMachine(ownerUserId, machineId) {
+      return records.delete(keyFor(ownerUserId, machineId));
+    },
+
+    clear() {
+      records.clear();
+    },
+  };
+}
+
+export const machineRegistry = createInMemoryMachineRegistry();