@hasna/machines 0.0.4 → 0.0.5

package/dist/cli/index.js

@@ -17959,6 +17959,28 @@ function readHistory(historyPath) {
     return [];
   }
 }
+function writeHistory(entries, historyPath) {
+  const path = resolveHistoryPath(historyPath);
+  ensureParentDir(path);
+  writeFileSync5(path, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+}
+function computeHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function shouldSkipContent(content, skipPatterns) {
+  const lower = content.toLowerCase();
+  return skipPatterns.some((pattern) => lower.includes(pattern.toLowerCase()));
+}
+function sanitizeClipboardForRead(content, maxSizeBytes, skipPatterns) {
+  if (Buffer.byteLength(content, "utf8") > maxSizeBytes) {
+    return { ok: false, reason: "content exceeds size limit" };
+  }
+  if (shouldSkipContent(content, skipPatterns)) {
+    return { ok: false, reason: "content matches skip pattern" };
+  }
+  return { ok: true };
+}
 function getOrCreateClipboardKey() {
   const keyPath = getClipboardKeyPath();
   if (existsSync8(keyPath)) {
@@ -17985,6 +18007,20 @@ function writeClipboardConfig(config, configPath) {
 function readClipboardHistory(historyPath) {
   return readHistory(historyPath);
 }
+function addClipboardEntry(entry, historyPath) {
+  const entries = readHistory(historyPath);
+  const existing = entries.find((e) => e.hash === entry.hash);
+  if (existing) {
+    existing.timestamp = entry.timestamp;
+  } else {
+    entries.unshift(entry);
+  }
+  const config = readConfig();
+  if (entries.length > config.maxHistory) {
+    entries.length = config.maxHistory;
+  }
+  writeHistory(entries, historyPath);
+}
 function clearClipboardHistory(historyPath) {
   const path = resolveHistoryPath(historyPath);
   if (existsSync8(path)) {
@@ -18001,6 +18037,292 @@ function getClipboardStatus(historyPath) {
   };
 }
 
+// src/commands/clipboard-daemon.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join10 } from "path";
+import { createHash as createHash3 } from "crypto";
+
+// src/commands/clipboard-server.ts
+import { createServer } from "http";
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync8 } from "fs";
+function readLocalClipboardSync() {
+  const platform4 = process.platform;
+  if (platform4 === "darwin") {
+    const result = Bun.spawnSync(["pbpaste"], { stdout: "pipe", stderr: "pipe" });
+    return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+  }
+  if (platform4 === "linux") {
+    if (hasCommand2("wl-paste")) {
+      const result = Bun.spawnSync(["wl-paste"], { stdout: "pipe", stderr: "pipe" });
+      return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+    }
+    if (hasCommand2("xclip")) {
+      const result = Bun.spawnSync(["xclip", "-selection", "clipboard", "-o"], { stdout: "pipe", stderr: "pipe" });
+      return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+    }
+    return "";
+  }
+  return "";
+}
+function writeLocalClipboardSync(content) {
+  const platform4 = process.platform;
+  if (platform4 === "darwin") {
+    const result = Bun.spawnSync(["pbcopy"], { stdin: new TextEncoder().encode(content), stdout: "ignore", stderr: "ignore" });
+    return result.exitCode === 0;
+  }
+  if (platform4 === "linux") {
+    if (hasCommand2("wl-copy")) {
+      const result = Bun.spawnSync(["wl-copy"], { stdin: new TextEncoder().encode(content), stdout: "ignore", stderr: "ignore" });
+      return result.exitCode === 0;
+    }
+    if (hasCommand2("xclip")) {
+      const result = Bun.spawnSync(["xclip", "-selection", "clipboard"], { stdin: new TextEncoder().encode(content), stdout: "ignore", stderr: "ignore" });
+      return result.exitCode === 0;
+    }
+    return false;
+  }
+  return false;
+}
+function hasCommand2(binary) {
+  const result = Bun.spawnSync(["bash", "-lc", `command -v ${binary} >/dev/null 2>&1`], { stdout: "ignore", stderr: "ignore", env: process.env });
+  return result.exitCode === 0;
+}
+function loadSharedSecret() {
+  const keyPath = getClipboardKeyPath();
+  try {
+    return readFileSync8(keyPath, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+function authenticate(request) {
+  const authHeader = request.headers["authorization"];
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    return false;
+  }
+  const token = authHeader.slice(7);
+  const secret = loadSharedSecret();
+  if (!secret)
+    return false;
+  return createHash2("sha256").update(token).digest("hex") === createHash2("sha256").update(secret).digest("hex");
+}
+function jsonResponse(response, status, data) {
+  response.writeHead(status, { "content-type": "application/json" });
+  response.end(JSON.stringify(data));
+}
+var currentContentHash = null;
+function startClipboardServer(options = {}) {
+  const config = options.config || readClipboardConfig();
+  const port = options.port || config.port;
+  const server = createServer(async (request, response) => {
+    if (!authenticate(request)) {
+      return jsonResponse(response, 401, { error: "unauthorized" });
+    }
+    const url = new URL(request.url || "/", `http://${request.headers.host || "localhost"}`);
+    if (url.pathname === "/clipboard" && request.method === "POST") {
+      return handleReceiveClipboard(request, response, config);
+    }
+    if (url.pathname === "/clipboard" && request.method === "GET") {
+      return handleGetClipboard(response, config);
+    }
+    if (url.pathname === "/health" && request.method === "GET") {
+      return jsonResponse(response, 200, { ok: true, machineId: process.env["HASNA_MACHINES_MACHINE_ID"] || "unknown" });
+    }
+    jsonResponse(response, 404, { error: "not found" });
+  });
+  server.listen(port, "0.0.0.0", () => {});
+  server.on("error", (error) => {
+    console.error(`clipboard server error: ${error.message}`);
+  });
+  return {
+    server,
+    port,
+    close: async () => {
+      await new Promise((resolve2) => server.close(() => resolve2()));
+    }
+  };
+}
+function handleReceiveClipboard(request, response, config) {
+  let body = "";
+  request.on("data", (chunk) => {
+    body += chunk;
+  });
+  request.on("end", () => {
+    try {
+      const parsed = JSON.parse(body);
+      const content = parsed.content || "";
+      const contentType = parsed.contentType || "text";
+      const sourceMachine = parsed.sourceMachine || "unknown";
+      if (!content) {
+        return jsonResponse(response, 400, { error: "empty content" });
+      }
+      const hash = computeHash(content);
+      if (hash === currentContentHash) {
+        return jsonResponse(response, 200, { received: false, reason: "loop detected" });
+      }
+      const check2 = sanitizeClipboardForRead(content, config.maxSizeBytes, config.skipPatterns);
+      if (!check2.ok) {
+        return jsonResponse(response, 200, { received: false, reason: check2.reason });
+      }
+      writeLocalClipboardSync(content);
+      currentContentHash = hash;
+      addClipboardEntry({
+        hash,
+        content,
+        contentType,
+        sourceMachine,
+        timestamp: new Date().toISOString()
+      });
+      return jsonResponse(response, 200, { received: true, hash });
+    } catch {
+      return jsonResponse(response, 400, { error: "invalid JSON" });
+    }
+  });
+}
+function handleGetClipboard(response, config) {
+  const content = readLocalClipboardSync();
+  if (!content) {
+    return jsonResponse(response, 200, { content: "", hash: null });
+  }
+  const hash = computeHash(content);
+  return jsonResponse(response, 200, { content, hash, contentType: "text" });
+}
+
+// src/commands/clipboard-daemon.ts
+var DAEMON_PID_PATH = join10(getDataDir(), "clipboard-daemon.pid");
+function readLocalClipboardSync2() {
+  const platform4 = process.platform;
+  if (platform4 === "darwin") {
+    const result = Bun.spawnSync(["pbpaste"], { stdout: "pipe", stderr: "pipe" });
+    return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+  }
+  if (platform4 === "linux") {
+    if (hasCommand3("wl-paste")) {
+      const result = Bun.spawnSync(["wl-paste"], { stdout: "pipe", stderr: "pipe" });
+      return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+    }
+    if (hasCommand3("xclip")) {
+      const result = Bun.spawnSync(["xclip", "-selection", "clipboard", "-o"], { stdout: "pipe", stderr: "pipe" });
+      return result.exitCode === 0 ? result.stdout.toString("utf8").trim() : "";
+    }
+    return "";
+  }
+  return "";
+}
+function hasCommand3(binary) {
+  const result = Bun.spawnSync(["bash", "-lc", `command -v ${binary} >/dev/null 2>&1`], { stdout: "ignore", stderr: "ignore", env: process.env });
+  return result.exitCode === 0;
+}
+function computeHash2(content) {
+  return createHash3("sha256").update(content).digest("hex").slice(0, 16);
+}
+function loadSharedSecret2() {
+  try {
+    return readFileSync9(getClipboardKeyPath(), "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+function writePid(pid) {
+  writeFileSync6(DAEMON_PID_PATH, `${pid}
+`);
+}
+function readPid() {
+  try {
+    const pid = Number.parseInt(readFileSync9(DAEMON_PID_PATH, "utf8").trim());
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stopClipboardDaemon() {
+  const pid = readPid();
+  if (pid && isProcessRunning(pid)) {
+    process.kill(pid, "SIGTERM");
+    return { stopped: true, pid };
+  }
+  return { stopped: false, pid };
+}
+function startClipboardDaemon(port) {
+  const config = readClipboardConfig();
+  const daemonPort = port || config.port;
+  const { server, close } = startClipboardServer({ port: daemonPort });
+  server.on("listening", () => {
+    console.log(`clipboard daemon started on port ${daemonPort} (pid ${process.pid})`);
+    writePid(process.pid);
+  });
+  let lastHash = "";
+  const secret = loadSharedSecret2();
+  const machineId = process.env["HASNA_MACHINES_MACHINE_ID"] || "unknown";
+  setInterval(async () => {
+    const content = readLocalClipboardSync2();
+    if (!content)
+      return;
+    const hash = computeHash2(content);
+    if (hash === lastHash)
+      return;
+    lastHash = hash;
+    const peers = await discoverPeers();
+    for (const peer of peers) {
+      try {
+        const res = await fetch(`http://${peer.host}:${peer.port}/clipboard`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${secret}`
+          },
+          body: JSON.stringify({
+            content,
+            contentType: "text",
+            sourceMachine: machineId
+          }),
+          signal: AbortSignal.timeout(2000)
+        });
+        if (res.ok) {
+          const data = await res.json();
+          if (data["received"] === true) {
+            console.log(`clipboard sent to ${peer.host}`);
+          }
+        }
+      } catch {}
+    }
+  }, 500);
+}
+async function discoverPeers() {
+  const config = readClipboardConfig();
+  const peers = [];
+  try {
+    const result = Bun.spawnSync(["tailscale", "status", "--json"], { stdout: "pipe", stderr: "pipe", env: process.env });
+    if (result.exitCode === 0) {
+      const status = JSON.parse(result.stdout.toString("utf8"));
+      const peers_map = status["Peer"] || {};
+      for (const [, peerInfo] of Object.entries(peers_map)) {
+        for (const ip of peerInfo.TailscaleIPs) {
+          if (ip.includes(".") && !ip.endsWith(".1")) {
+            peers.push({ host: ip, port: config.port });
+          }
+        }
+      }
+    }
+  } catch {}
+  const knownPeers = ["100.82.44.120", "100.100.226.69", "100.71.123.34", "100.85.234.92"];
+  for (const ip of knownPeers) {
+    if (!peers.some((p) => p.host === ip)) {
+      peers.push({ host: ip, port: config.port });
+    }
+  }
+  return peers;
+}
+
 // src/cli-utils.ts
 function parseIntegerOption(value, label, constraints = {}) {
   const parsed = Number.parseInt(value, 10);
@@ -18032,7 +18354,7 @@ ${items.map((item) => `- ${item}`).join(`
 
 // src/cli/index.ts
 import { rmSync as rmSync2 } from "fs";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 var program2 = new Command;
 function printJsonOrText(data, text, json = false) {
   if (json || program2.opts().quiet) {
@@ -18179,7 +18501,7 @@ manifestCommand.command("add").description("Add or replace a machine in the flee
       console.error("error: --from-stdin requires piped input");
       process.exit(1);
     }
-    const input = readFileSync8(0, "utf8");
+    const input = readFileSync10(0, "utf8");
     const machine2 = JSON.parse(input);
     console.log(JSON.stringify(manifestAdd(machine2), null, 2));
     return;
@@ -18358,6 +18680,14 @@ clipboardCommand.command("key").description("Show or rotate the shared secret ke
   const key = getOrCreateClipboardKey();
   printJsonOrText({ key }, key, options.json);
 });
+clipboardCommand.command("start").description("Start clipboard sync daemon").option("--port <port>", "Port to listen on").action((options) => {
+  const port = options.port ? Number(options.port) : undefined;
+  startClipboardDaemon(port);
+});
+clipboardCommand.command("stop").description("Stop clipboard sync daemon").action(() => {
+  const result = stopClipboardDaemon();
+  console.log(result.stopped ? `daemon stopped (pid ${result.pid})` : "daemon not running");
+});
 installClaudeCommand.command("status").description("Check installed state for Claude, Codex, and Gemini CLIs").option("--machine <id>", "Machine identifier").option("--tool <name...>", "CLI tools to inspect (claude, codex, gemini)").option("-j, --json", "Print JSON output", false).action((options) => {
   const result = getClaudeCliStatus(options.machine, options.tool);
   printJsonOrText(result, renderClaudeStatusResult(result), options.json);

package/dist/commands/clipboard-daemon.d.ts

@@ -0,0 +1,6 @@
+export declare function stopClipboardDaemon(): {
+    stopped: boolean;
+    pid: number | null;
+};
+export declare function startClipboardDaemon(port?: number): void;
+//# sourceMappingURL=clipboard-daemon.d.ts.map

package/dist/commands/clipboard-daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard-daemon.d.ts","sourceRoot":"","sources":["../../src/commands/clipboard-daemon.ts"],"names":[],"mappings":"AAwFA,wBAAgB,mBAAmB,IAAI;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAO9E;AAED,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAqDxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/machines",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Machine fleet management CLI + MCP for developers",
   "type": "module",
   "license": "Apache-2.0",