@hasna/machines 0.0.9 → 0.0.10

package/LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -175,7 +176,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2026 hasna
+   Copyright 2026 Hasna, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -8,6 +8,21 @@ Machine fleet management for developers — provision, sync, inspect, and operat
 - `machines-mcp`: MCP server exposing fleet tools to AI agents
 - `machines-agent`: lightweight local daemon for heartbeats and runtime reporting
 
+## HTTP mode
+
+Long-lived Streamable HTTP transport for shared agent connections (stdio remains the default):
+
+```bash
+machines-mcp --http
+# or: MCP_HTTP=1 machines-mcp
+# default port: 8821 (override with --port or MCP_HTTP_PORT)
+```
+
+Endpoints on `127.0.0.1` only:
+
+- `GET /health` → `{"status":"ok","name":"machines"}`
+- `POST /mcp` → MCP Streamable HTTP
+
 ## Manifest
 
 `machines.json` is the desired fleet declaration.

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,337 @@ 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 getCurrentContentHash() {
+  return currentContentHash;
+}
+function setCurrentContentHash(hash) {
+  currentContentHash = hash;
+}
+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 hasDisplayServer() {
+  const display = process.env["DISPLAY"] || "";
+  const wayland = process.env["WAYLAND_DISPLAY"] || "";
+  if (display || wayland)
+    return true;
+  if (process.platform === "darwin")
+    return true;
+  if (process.platform === "linux") {
+    try {
+      const result = Bun.spawnSync(["loginctl", "list-sessions", "--no-legend"], { stdout: "pipe", stderr: "pipe", env: process.env, timeout: 2000 });
+      if (result.exitCode === 0) {
+        const sessions = result.stdout.toString("utf8").trim();
+        if (sessions) {
+          for (const line of sessions.split(`
+`)) {
+            const sessionId = line.trim().split(/\s+/)[0];
+            if (sessionId) {
+              const typeResult = Bun.spawnSync(["loginctl", "show-session", sessionId, "-p", "Type", "--value"], { stdout: "pipe", stderr: "pipe", env: process.env, timeout: 2000 });
+              if (typeResult.exitCode === 0) {
+                const sessionType = typeResult.stdout.toString("utf8").trim();
+                if (sessionType === "wayland" || sessionType === "x11") {
+                  return true;
+                }
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+    return false;
+  }
+  return false;
+}
+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);
+  });
+  const secret = loadSharedSecret2();
+  const machineId = process.env["HASNA_MACHINES_MACHINE_ID"] || "unknown";
+  const hasDisplay = hasDisplayServer();
+  if (!hasDisplay) {
+    console.log("clipboard daemon running in receive-only mode (no display server)");
+  }
+  setInterval(async () => {
+    if (!hasDisplay)
+      return;
+    const content = readLocalClipboardSync2();
+    if (!content)
+      return;
+    const hash = computeHash2(content);
+    const currentContentHash2 = getCurrentContentHash();
+    if (hash === currentContentHash2)
+      return;
+    setCurrentContentHash(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 +18399,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 +18546,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 +18725,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":"AA2HA,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,CA6DxD"}

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

@@ -9,6 +9,8 @@ export interface ClipboardServerHandle {
     port: number;
     close: () => Promise<void>;
 }
+export declare function getCurrentContentHash(): string | null;
+export declare function setCurrentContentHash(hash: string): void;
 export declare function startClipboardServer(options?: ClipboardServerOptions): ClipboardServerHandle;
 export declare function pushClipboardToPeer(host: string, port: number, token: string): Promise<{
     sent: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"clipboard-server.d.ts","sourceRoot":"","sources":["../../src/commands/clipboard-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA6C,MAAM,WAAW,CAAC;AAKpF,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAuFnE,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAID,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CA6ChG;AA6DD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA4ChI"}
+{"version":3,"file":"clipboard-server.d.ts","sourceRoot":"","sources":["../../src/commands/clipboard-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAA6C,MAAM,WAAW,CAAC;AAKpF,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAuFnE,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,eAAe,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAID,wBAAgB,qBAAqB,IAAI,MAAM,GAAG,IAAI,CAA+B;AACrF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAA+B;AAExF,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CA6ChG;AA6DD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA4ChI"}

package/dist/index.js

@@ -30811,6 +30811,9 @@ var MACHINE_MCP_TOOL_NAMES = [
   "machines_serve_info",
   "machines_serve_dashboard"
 ];
+function buildServer(version2 = getPackageVersion()) {
+  return createMcpServer(version2);
+}
 function createMcpServer(version2) {
   const server = new McpServer({ name: "machines", version: version2 });
   server.tool("machines_status", "Return local machine fleet status paths and machine identity.", {}, async () => ({
@@ -30979,6 +30982,7 @@ export {
   buildSyncPlan,
   buildSshCommand,
   buildSetupPlan,
+  buildServer,
   buildClaudeInstallPlan,
   buildCertPlan,
   buildBackupPlan,

package/dist/mcp/http.d.ts

@@ -0,0 +1,12 @@
+import { type Server } from "node:http";
+export declare const DEFAULT_HTTP_PORT = 8821;
+export declare const HTTP_NAME = "machines";
+export interface StartHttpServerOptions {
+    port?: number;
+    host?: string;
+    name?: string;
+}
+export declare function isHttpMode(args?: string[]): boolean;
+export declare function resolveHttpPort(args?: string[]): number;
+export declare function startHttpServer(options?: StartHttpServerOptions): Server;
+//# sourceMappingURL=http.d.ts.map

package/dist/mcp/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,MAAM,EAAuB,MAAM,WAAW,CAAC;AAIjG,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,SAAS,aAAa,CAAC;AAEpC,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,UAAU,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,OAAO,CAE1E;AAED,wBAAgB,eAAe,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,MAAM,CAiB9E;AAmDD,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,MAAM,CA8B5E"}

package/dist/mcp/index.js

@@ -16,11 +16,30 @@ var __export = (target, all) => {
 };
 
 // src/mcp/index.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
+// src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function getPackageVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join(here, "..", "package.json"), join(here, "..", "..", "package.json")];
+    const pkgPath = candidates.find((candidate) => existsSync(candidate));
+    if (!pkgPath) {
+      return "0.0.0";
+    }
+    return JSON.parse(readFileSync(pkgPath, "utf8")).version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/mcp/http.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
@@ -3999,20 +4018,20 @@ var coerce = {
 var NEVER = INVALID;
 // src/commands/backup.ts
 import { homedir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 function quote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function defaultBackupSources() {
   const home = homedir();
   return [
-    join(home, ".hasna"),
-    join(home, ".ssh"),
-    join(home, ".secrets")
+    join2(home, ".hasna"),
+    join2(home, ".ssh"),
+    join2(home, ".secrets")
   ];
 }
 function buildBackupPlan(bucket, prefix = "machines") {
-  const archivePath = join(homedir(), ".hasna", "machines", "backup.tgz");
+  const archivePath = join2(homedir(), ".hasna", "machines", "backup.tgz");
   const sources = defaultBackupSources();
   const steps = [
     {
@@ -4063,33 +4082,33 @@ function runBackup(bucket, prefix = "machines", options = {}) {
 }
 
 // src/manifests.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { arch, homedir as homedir2, hostname, platform, userInfo } from "os";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // src/paths.ts
-import { existsSync, mkdirSync } from "fs";
-import { dirname, join as join2, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname as dirname2, join as join3, resolve } from "path";
 function homeDir() {
   return process.env["HOME"] || process.env["USERPROFILE"] || "~";
 }
 function getDataDir() {
-  return process.env["HASNA_MACHINES_DIR"] || join2(homeDir(), ".hasna", "machines");
+  return process.env["HASNA_MACHINES_DIR"] || join3(homeDir(), ".hasna", "machines");
 }
 function getDbPath() {
-  return process.env["HASNA_MACHINES_DB_PATH"] || join2(getDataDir(), "machines.db");
+  return process.env["HASNA_MACHINES_DB_PATH"] || join3(getDataDir(), "machines.db");
 }
 function getManifestPath() {
-  return process.env["HASNA_MACHINES_MANIFEST_PATH"] || join2(getDataDir(), "machines.json");
+  return process.env["HASNA_MACHINES_MANIFEST_PATH"] || join3(getDataDir(), "machines.json");
 }
 function getNotificationsPath() {
-  return process.env["HASNA_MACHINES_NOTIFICATIONS_PATH"] || join2(getDataDir(), "notifications.json");
+  return process.env["HASNA_MACHINES_NOTIFICATIONS_PATH"] || join3(getDataDir(), "notifications.json");
 }
 function ensureParentDir(filePath) {
   if (filePath === ":memory:")
     return;
-  const dir = dirname(resolve(filePath));
-  if (!existsSync(dir)) {
+  const dir = dirname2(resolve(filePath));
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
 }
@@ -4154,10 +4173,10 @@ function getDefaultManifest() {
   };
 }
 function readManifest(path = getManifestPath()) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return getDefaultManifest();
   }
-  const raw = JSON.parse(readFileSync(path, "utf8"));
+  const raw = JSON.parse(readFileSync2(path, "utf8"));
   return fleetSchema.parse(raw);
 }
 function validateManifest(path = getManifestPath()) {
@@ -4181,7 +4200,7 @@ function getManifestMachine(machineId, path = getManifestPath()) {
 function detectCurrentMachineManifest() {
   const machineId = process.env["HASNA_MACHINES_MACHINE_ID"] || hostname();
   const user = userInfo().username;
-  const bunDir = dirname2(process.execPath);
+  const bunDir = dirname3(process.execPath);
   return {
     id: machineId,
     hostname: hostname(),
@@ -4207,22 +4226,22 @@ import { hostname as hostname2 } from "os";
 import { createRequire } from "module";
 import { Database } from "bun:sqlite";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   mkdirSync as mkdirSync2,
   readdirSync,
   copyFileSync
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join3, relative } from "path";
-import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4, relative } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync22, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir22 } from "os";
 import { join as join22 } from "path";
 import { readdirSync as readdirSync2, existsSync as existsSync32 } from "fs";
 import { join as join32 } from "path";
 import { homedir as homedir32 } from "os";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
-import { join as join6, dirname as dirname3 } from "path";
+import { join as join42 } from "path";
+import { join as join6, dirname as dirname4 } from "path";
 import { homedir as homedir5, platform as platform2 } from "os";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -13387,17 +13406,17 @@ var init_zod = __esm(() => {
   init_external();
 });
 function getDataDir2(serviceName) {
-  const dir = join3(HASNA_DIR, serviceName);
+  const dir = join4(HASNA_DIR, serviceName);
   mkdirSync2(dir, { recursive: true });
   return dir;
 }
 function getDbPath2(serviceName) {
   const dir = getDataDir2(serviceName);
-  return join3(dir, `${serviceName}.db`);
+  return join4(dir, `${serviceName}.db`);
 }
 var HASNA_DIR;
 var init_dotfile = __esm(() => {
-  HASNA_DIR = join3(homedir3(), ".hasna");
+  HASNA_DIR = join4(homedir3(), ".hasna");
 });
 var exports_config = {};
 __export2(exports_config, {
@@ -13420,7 +13439,7 @@ function getCloudConfig() {
     return CloudConfigSchema.parse({});
   }
   try {
-    const raw = readFileSync2(CONFIG_PATH, "utf-8");
+    const raw = readFileSync3(CONFIG_PATH, "utf-8");
     return CloudConfigSchema.parse(JSON.parse(raw));
   } catch {
     return CloudConfigSchema.parse({});
@@ -13711,7 +13730,7 @@ class SyncProgressTracker {
 init_adapter();
 init_config();
 init_discover();
-var AUTO_SYNC_CONFIG_PATH = join4(homedir4(), ".hasna", "cloud", "config.json");
+var AUTO_SYNC_CONFIG_PATH = join42(homedir4(), ".hasna", "cloud", "config.json");
 init_config();
 init_adapter();
 init_dotfile();
@@ -14089,16 +14108,16 @@ function runCertPlan(domains, options = {}) {
 }
 
 // src/commands/dns.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
 function getDnsPath() {
   return join7(getDataDir(), "dns.json");
 }
 function readMappings() {
   const path = getDnsPath();
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return [];
-  return JSON.parse(readFileSync3(path, "utf8"));
+  return JSON.parse(readFileSync4(path, "utf8"));
 }
 function writeMappings(mappings) {
   const path = getDnsPath();
@@ -14400,7 +14419,7 @@ function runTailscaleInstall(machineId, options = {}) {
 }
 
 // src/commands/notifications.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 var notificationChannelSchema = exports_external.object({
   id: exports_external.string(),
   type: exports_external.enum(["email", "webhook", "command"]),
@@ -14556,10 +14575,10 @@ function getDefaultNotificationConfig() {
   };
 }
 function readNotificationConfig(path = getNotificationsPath()) {
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     return getDefaultNotificationConfig();
   }
-  return notificationConfigSchema.parse(JSON.parse(readFileSync4(path, "utf8")));
+  return notificationConfigSchema.parse(JSON.parse(readFileSync5(path, "utf8")));
 }
 function writeNotificationConfig(config, path = getNotificationsPath()) {
   ensureParentDir(path);
@@ -14731,24 +14750,6 @@ function manifestValidate() {
   return validateManifest(getManifestPath());
 }
 
-// src/version.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, join as join8 } from "path";
-import { fileURLToPath } from "url";
-function getPackageVersion() {
-  try {
-    const here = dirname4(fileURLToPath(import.meta.url));
-    const candidates = [join8(here, "..", "package.json"), join8(here, "..", "..", "package.json")];
-    const pkgPath = candidates.find((candidate) => existsSync6(candidate));
-    if (!pkgPath) {
-      return "0.0.0";
-    }
-    return JSON.parse(readFileSync5(pkgPath, "utf8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-
 // src/commands/status.ts
 function getStatus() {
   const manifest = readManifest();
@@ -15268,6 +15269,9 @@ function getAgentStatus(machineId = getLocalMachineId()) {
 }
 
 // src/mcp/server.ts
+function buildServer(version = getPackageVersion()) {
+  return createMcpServer(version);
+}
 function createMcpServer(version) {
   const server = new McpServer({ name: "machines", version });
   server.tool("machines_status", "Return local machine fleet status paths and machine identity.", {}, async () => ({
@@ -15364,21 +15368,107 @@ function createMcpServer(version) {
   return server;
 }
 
-// src/mcp/index.ts
-function getPkgVersion() {
+// src/mcp/http.ts
+var DEFAULT_HTTP_PORT = 8821;
+var HTTP_NAME = "machines";
+function isHttpMode(args = process.argv.slice(2)) {
+  return args.includes("--http") || process.env.MCP_HTTP === "1";
+}
+function resolveHttpPort(args = process.argv.slice(2)) {
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" && args[i + 1]) {
+      return parsePort(args[i + 1]);
+    }
+    if (arg.startsWith("--port=")) {
+      return parsePort(arg.slice("--port=".length));
+    }
+  }
+  const envPort = process.env.MCP_HTTP_PORT;
+  if (envPort) {
+    return parsePort(envPort);
+  }
+  return DEFAULT_HTTP_PORT;
+}
+function parsePort(raw) {
+  const port = Number.parseInt(raw, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port: ${raw}`);
+  }
+  return port;
+}
+function pathnameFromRequest(req) {
+  return new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+}
+async function readRequestBody(req) {
+  if (req.method !== "POST" && req.method !== "DELETE") {
+    return;
+  }
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text) {
+    return;
+  }
+  return JSON.parse(text);
+}
+async function handleMcpRequest(req, res) {
+  const server = buildServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined
+  });
+  await server.connect(transport);
   try {
-    const pkgPath = join9(dirname5(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync7(pkgPath, "utf8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
+    const body = await readRequestBody(req);
+    await transport.handleRequest(req, res, body);
+  } finally {
+    res.on("close", () => {
+      transport.close().catch(() => {
+        return;
+      });
+      server.close().catch(() => {
+        return;
+      });
+    });
   }
 }
+function startHttpServer(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? resolveHttpPort();
+  const name = options.name ?? HTTP_NAME;
+  const httpServer = createServer(async (req, res) => {
+    const path = pathnameFromRequest(req);
+    if (req.method === "GET" && path === "/health") {
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", name }));
+      return;
+    }
+    if (path === "/mcp") {
+      await handleMcpRequest(req, res);
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  });
+  httpServer.listen(port, host, () => {
+    const address = httpServer.address();
+    const boundPort = typeof address === "object" && address ? address.port : port;
+    console.error(`machines-mcp HTTP listening on http://${host}:${boundPort}`);
+  });
+  return httpServer;
+}
+
+// src/mcp/index.ts
 function printHelp() {
   console.log(`Usage: machines-mcp [options]
 
-MCP server for machine fleet management tools (stdio transport)
+MCP server for machine fleet management tools (stdio transport by default)
 
 Options:
+  --http         Start Streamable HTTP transport on 127.0.0.1 (or MCP_HTTP=1)
+  --port <n>     HTTP port (default: 8821, or MCP_HTTP_PORT env)
   -V, --version  output the version number
   -h, --help     display help for command`);
 }
@@ -15388,9 +15478,13 @@ if (args.includes("--help") || args.includes("-h")) {
   process.exit(0);
 }
 if (args.includes("--version") || args.includes("-V")) {
-  console.log(getPkgVersion());
+  console.log(getPackageVersion());
   process.exit(0);
 }
-var server = createMcpServer(getPkgVersion());
-var transport = new StdioServerTransport;
-await server.connect(transport);
+if (isHttpMode(args)) {
+  startHttpServer({ port: resolveHttpPort(args) });
+} else {
+  const server = buildServer();
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+}

package/dist/mcp/server.d.ts

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare const MACHINE_MCP_TOOL_NAMES: readonly ["machines_status", "machines_doctor", "machines_self_test", "machines_apps_list", "machines_apps_status", "machines_apps_diff", "machines_apps_plan", "machines_apps_apply", "machines_manifest", "machines_manifest_validate", "machines_manifest_bootstrap", "machines_manifest_get", "machines_manifest_remove", "machines_agent_status", "machines_setup_preview", "machines_setup_apply", "machines_sync_preview", "machines_sync_apply", "machines_diff", "machines_install_tailscale_preview", "machines_install_tailscale_apply", "machines_install_claude_status", "machines_install_claude_diff", "machines_install_claude_preview", "machines_install_claude_apply", "machines_ssh_resolve", "machines_ports", "machines_backup_preview", "machines_backup_apply", "machines_cert_preview", "machines_cert_apply", "machines_dns_add", "machines_dns_list", "machines_dns_render", "machines_notifications_add", "machines_notifications_list", "machines_notifications_test", "machines_notifications_dispatch", "machines_notifications_remove", "machines_serve_info", "machines_serve_dashboard"];
+export declare function buildServer(version?: string): McpServer;
 export declare function createMcpServer(version: string): McpServer;
 //# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA2BpE,eAAO,MAAM,sBAAsB,4jCA0CzB,CAAC;AAEX,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CA6R1D"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA4BpE,eAAO,MAAM,sBAAsB,4jCA0CzB,CAAC;AAEX,wBAAgB,WAAW,CAAC,OAAO,GAAE,MAA4B,GAAG,SAAS,CAE5E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CA6R1D"}

package/package.json

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