openmausbot 0.1.55

package/dist-server/permission-proxy.js

@@ -0,0 +1,126 @@
+// server/permission-proxy.ts
+import { connect } from "node:net";
+import { randomUUID } from "node:crypto";
+var socketPath = process.argv[2] ?? "";
+var waiting = /* @__PURE__ */ new Map();
+var conn = connect(socketPath);
+var dead = () => {
+  for (const resolve of waiting.values()) {
+    resolve({ behavior: "deny", message: "OpenMausBot: permission broker unavailable \u2014 skip this action" });
+  }
+  waiting.clear();
+};
+conn.on("error", dead);
+conn.on("close", dead);
+var connBuf = "";
+conn.on("data", (chunk) => {
+  connBuf += chunk;
+  let nl;
+  while ((nl = connBuf.indexOf("\n")) !== -1) {
+    const line = connBuf.slice(0, nl);
+    connBuf = connBuf.slice(nl + 1);
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (msg.t === "answer") {
+      waiting.get(msg.id)?.(msg);
+      waiting.delete(msg.id);
+    }
+  }
+});
+var send = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
+var TOOLS = [
+  {
+    name: "approve",
+    description: "Ask the OpenMausBot user whether a tool use is allowed",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tool_name: { type: "string" },
+        input: { type: "object" },
+        tool_use_id: { type: "string" }
+      },
+      required: ["tool_name", "input"]
+    }
+  },
+  {
+    name: "ask_user",
+    description: "Ask the human who owns this bot a question and wait for their answer. Use whenever you need a decision, a preference, missing information, or sign-off before doing something consequential \u2014 do not guess on things the owner would want to decide. Returns their answer as text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The question, with enough context to answer at a glance" },
+        choices: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional 2-5 suggested answers, shown as one-tap buttons"
+        }
+      },
+      required: ["question"]
+    }
+  }
+];
+async function handle(msg) {
+  if (msg.method === "initialize") {
+    return send({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: msg.params?.protocolVersion ?? "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "openmausbot-permissions", version: "1" }
+      }
+    });
+  }
+  if (msg.method === "tools/list") return send({ jsonrpc: "2.0", id: msg.id, result: { tools: TOOLS } });
+  if (msg.method === "tools/call") {
+    const name = msg.params?.name;
+    const args = msg.params?.arguments ?? {};
+    const askId = randomUUID();
+    const isQuestion = name === "ask_user";
+    const suggestions = Array.isArray(args.permission_suggestions) ? args.permission_suggestions : Array.isArray(args.suggestions) ? args.suggestions : null;
+    const answer = await new Promise((resolve) => {
+      waiting.set(askId, resolve);
+      if (conn.destroyed) return dead();
+      const ask = isQuestion ? { t: "ask", id: askId, kind: "question", tool: "ask_user", input: { question: args.question, choices: args.choices } } : { t: "ask", id: askId, tool: args.tool_name, input: args.input };
+      try {
+        conn.write(JSON.stringify(ask) + "\n");
+      } catch {
+        dead();
+      }
+    });
+    let text = answer.message || "No answer was given \u2014 use your best judgment.";
+    if (!isQuestion) {
+      if (answer.behavior === "allow") {
+        const result = { behavior: "allow", updatedInput: args.input ?? {} };
+        if (answer.always && suggestions) result.updatedPermissions = suggestions;
+        text = JSON.stringify(result);
+      } else {
+        text = JSON.stringify({ behavior: "deny", message: answer.message || "Denied from OpenMausBot" });
+      }
+    }
+    return send({ jsonrpc: "2.0", id: msg.id, result: { content: [{ type: "text", text }] } });
+  }
+  if (String(msg.method ?? "").startsWith("notifications/")) return;
+  if (msg.id != null) {
+    send({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `method not found: ${msg.method}` } });
+  }
+}
+var inBuf = "";
+process.stdin.on("data", (chunk) => {
+  inBuf += chunk;
+  let nl;
+  while ((nl = inBuf.indexOf("\n")) !== -1) {
+    const line = inBuf.slice(0, nl);
+    inBuf = inBuf.slice(nl + 1);
+    if (!line.trim()) continue;
+    try {
+      void handle(JSON.parse(line));
+    } catch {
+    }
+  }
+});
+process.stdin.on("end", () => process.exit(0));

package/dist-server/prepare-cloudflared.js

@@ -0,0 +1,253 @@
+// scripts/prepare-cloudflared.mjs
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var CLOUDFLARED_VERSION = "2026.8.2";
+var CLOUDFLARED_ASSETS = Object.freeze({
+  "darwin-arm64": Object.freeze({
+    name: "cloudflared-darwin-arm64.tgz",
+    sha256: "9042c2c5d8b2de78e60f313d5fb31b6c5c1cebde787a3caf1f2c9588084ac442",
+    binarySha256: "b61054d3d6326ea558cb49826eebf5676e0d0a36d51b546975096ca3e0e3c89d",
+    archive: true
+  }),
+  "darwin-x64": Object.freeze({
+    name: "cloudflared-darwin-amd64.tgz",
+    sha256: "f1727723c586500e2092368ae21871b3df7ddfd2cb097f22d81bee4a9c458bb4",
+    binarySha256: "b0f770e1e0b281399a57219b840fd8eef1cc25387a404124248157ea2073727a",
+    archive: true
+  }),
+  "linux-x64": Object.freeze({
+    name: "cloudflared-linux-amd64",
+    sha256: "fcfb02b575a52ca1af2e3267af4e1517bcdeb30ac48c834c69abaed3c0576ad2",
+    binarySha256: "fcfb02b575a52ca1af2e3267af4e1517bcdeb30ac48c834c69abaed3c0576ad2",
+    archive: false
+  }),
+  "win32-x64": Object.freeze({
+    name: "cloudflared-windows-amd64.exe",
+    sha256: "c29eee2b121f5436a642eed69fd9767da7e7b8c510fa50aaa130337f931357b5",
+    binarySha256: "c29eee2b121f5436a642eed69fd9767da7e7b8c510fa50aaa130337f931357b5",
+    archive: false
+  })
+});
+function targetsForHost(platform) {
+  if (platform === "darwin") return ["darwin-arm64", "darwin-x64"];
+  if (platform === "linux") return ["linux-x64"];
+  if (platform === "win32") return ["win32-x64"];
+  throw new Error(`Cloudflare Tunnel packaging is unsupported on ${platform}`);
+}
+function targetForCurrentHost(platform = process.platform, arch = process.arch) {
+  const target = `${platform}-${arch}`;
+  if (!Object.hasOwn(CLOUDFLARED_ASSETS, target)) {
+    throw new Error(`Cloudflare Tunnel development is unsupported on ${target}`);
+  }
+  return target;
+}
+function targetsForPreparation({
+  current = false,
+  platform = process.platform,
+  arch = process.arch
+} = {}) {
+  return current ? [targetForCurrentHost(platform, arch)] : targetsForHost(platform);
+}
+function parsePrepareCloudflaredArgs(args = []) {
+  const options = { current: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    const next = args[index + 1];
+    if (argument === "--current" && !options.current) {
+      options.current = true;
+    } else if (argument === "--root" && !options.root && typeof next === "string" && next !== "") {
+      options.root = next;
+      index += 1;
+    } else {
+      throw new Error("Usage: node scripts/prepare-cloudflared.mjs [--current] [--root DIR]");
+    }
+  }
+  return options;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function verifySha256(value, expected, label = "cloudflared asset") {
+  const actual = sha256(value);
+  if (actual !== expected) {
+    throw new Error(`${label} failed SHA-256 verification (expected ${expected}, received ${actual})`);
+  }
+  return actual;
+}
+var executableName = (target) => target.startsWith("win32-") ? "cloudflared.exe" : "cloudflared";
+function executableTarget(value) {
+  const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value);
+  if (bytes.length >= 8 && bytes.readUInt32LE(0) === 4277009103) {
+    const cpu = bytes.readUInt32LE(4);
+    if (cpu === 16777228) return "darwin-arm64";
+    if (cpu === 16777223) return "darwin-x64";
+    throw new Error(`unsupported cloudflared Mach-O CPU type 0x${cpu.toString(16)}`);
+  }
+  if (bytes.length >= 20 && bytes.subarray(0, 4).equals(Buffer.from([127, 69, 76, 70])) && bytes[4] === 2 && bytes[5] === 1 && bytes.readUInt16LE(18) === 62) {
+    return "linux-x64";
+  }
+  if (bytes.length >= 64 && bytes[0] === 77 && bytes[1] === 90) {
+    const pe = bytes.readUInt32LE(60);
+    if (pe <= bytes.length - 6 && bytes.subarray(pe, pe + 4).equals(Buffer.from([80, 69, 0, 0])) && bytes.readUInt16LE(pe + 4) === 34404) {
+      return "win32-x64";
+    }
+  }
+  throw new Error("cloudflared release has an unsupported executable format or architecture");
+}
+function verifyPinnedBinary(value, target) {
+  const asset = CLOUDFLARED_ASSETS[target];
+  if (!asset) throw new Error(`No pinned cloudflared asset for ${target}`);
+  const actualTarget = executableTarget(value);
+  if (actualTarget !== target) {
+    throw new Error(`cloudflared architecture mismatch (expected ${target}, received ${actualTarget})`);
+  }
+  return verifySha256(value, asset.binarySha256, `${target} cloudflared executable`);
+}
+function expectedManifest(target) {
+  const asset = CLOUDFLARED_ASSETS[target];
+  return {
+    version: CLOUDFLARED_VERSION,
+    target,
+    releaseAsset: asset.name,
+    releaseAssetSha256: asset.sha256,
+    binarySha256: asset.binarySha256
+  };
+}
+function targetRunsOnHost(target, platform = process.platform, arch = process.arch) {
+  return target === `${platform}-${arch}`;
+}
+function executableHasPinnedVersion(binary, target) {
+  if (!targetRunsOnHost(target)) return true;
+  const result = spawnSync(binary, ["version"], {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 1e4
+  });
+  return result.status === 0 && `${result.stdout}
+${result.stderr}`.includes(CLOUDFLARED_VERSION);
+}
+function verifyCloudflaredExecutable(binary, target) {
+  verifyPinnedBinary(readFileSync(binary), target);
+  if (!executableHasPinnedVersion(binary, target)) {
+    throw new Error(`${target} executable did not identify as cloudflared ${CLOUDFLARED_VERSION}`);
+  }
+}
+function executableIsCurrent(binary, manifestFile, target) {
+  if (!existsSync(binary) || !existsSync(manifestFile)) return false;
+  try {
+    const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
+    if (JSON.stringify(manifest) !== JSON.stringify(expectedManifest(target))) return false;
+    verifyCloudflaredExecutable(binary, target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function extractionFailure(result) {
+  return result.error?.message ?? String(result.stderr || result.stdout || `exit status ${result.status}`).trim();
+}
+async function releaseBytes(asset) {
+  const cacheDirectory = process.env.OMB_CLOUDFLARED_ARCHIVE_DIR;
+  const cached = cacheDirectory ? join(cacheDirectory, asset.name) : "";
+  if (cached && existsSync(cached)) return readFileSync(cached);
+  const url = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${asset.name}`;
+  const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(12e4) });
+  if (!response.ok) throw new Error(`could not download ${asset.name}: HTTP ${response.status}`);
+  return Buffer.from(await response.arrayBuffer());
+}
+async function stageTarget(root, target) {
+  const asset = CLOUDFLARED_ASSETS[target];
+  if (!asset) throw new Error(`No pinned cloudflared asset for ${target}`);
+  const finalDirectory = join(root, "dist-native", "cloudflared", target);
+  const binary = join(finalDirectory, executableName(target));
+  const manifestFile = join(finalDirectory, "manifest.json");
+  if (executableIsCurrent(binary, manifestFile, target)) {
+    console.log(`cloudflared ${CLOUDFLARED_VERSION} already staged for ${target}`);
+    return;
+  }
+  const scratch = mkdtempSync(join(tmpdir(), `openmaus-cloudflared-${target}-`));
+  try {
+    const payload = await releaseBytes(asset);
+    verifySha256(payload, asset.sha256, asset.name);
+    let candidate;
+    if (asset.archive) {
+      const archive = join(scratch, basename(asset.name));
+      writeFileSync(archive, payload, { mode: 384 });
+      const extracted = join(scratch, "extracted");
+      mkdirSync(extracted, { mode: 448 });
+      const result = spawnSync("tar", ["-xzf", archive, "-C", extracted], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 6e4
+      });
+      if (result.status !== 0) throw new Error(`could not extract ${asset.name}: ${extractionFailure(result)}`);
+      candidate = join(extracted, "cloudflared");
+    } else {
+      candidate = join(scratch, executableName(target));
+      writeFileSync(candidate, payload, { mode: 448 });
+    }
+    if (!existsSync(candidate)) throw new Error(`${asset.name} did not contain cloudflared`);
+    if (!target.startsWith("win32-")) chmodSync(candidate, 448);
+    verifyCloudflaredExecutable(candidate, target);
+    const parent = dirname(finalDirectory);
+    mkdirSync(parent, { recursive: true });
+    const stagedDirectory = mkdtempSync(join(parent, `.${target}-`));
+    const stagedBinary = join(stagedDirectory, executableName(target));
+    copyFileSync(candidate, stagedBinary);
+    if (!target.startsWith("win32-")) {
+      chmodSync(stagedBinary, 493);
+    }
+    writeFileSync(
+      join(stagedDirectory, "manifest.json"),
+      `${JSON.stringify(expectedManifest(target), null, 2)}
+`,
+      { mode: 384 }
+    );
+    rmSync(finalDirectory, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+    renameSync(stagedDirectory, finalDirectory);
+    console.log(`staged cloudflared ${CLOUDFLARED_VERSION} for ${target}`);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
+  }
+}
+async function prepareCloudflared({
+  root = join(dirname(fileURLToPath(import.meta.url)), ".."),
+  platform = process.platform,
+  arch = process.arch,
+  current = false
+} = {}) {
+  for (const target of targetsForPreparation({ current, platform, arch })) {
+    await stageTarget(root, target);
+  }
+}
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  await prepareCloudflared(parsePrepareCloudflaredArgs(process.argv.slice(2)));
+}
+export {
+  CLOUDFLARED_ASSETS,
+  CLOUDFLARED_VERSION,
+  executableTarget,
+  parsePrepareCloudflaredArgs,
+  prepareCloudflared,
+  sha256,
+  targetForCurrentHost,
+  targetsForHost,
+  targetsForPreparation,
+  verifyCloudflaredExecutable,
+  verifyPinnedBinary,
+  verifySha256
+};

package/dist-server/proxy-paths.js

@@ -0,0 +1,29 @@
+// server/proxy-paths.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVER_ROOT = dirname(fileURLToPath(import.meta.url));
+function resolveProxy(relative) {
+  const source = join(SERVER_ROOT, `${relative}.ts`);
+  return existsSync(source) ? source : join(SERVER_ROOT, `${relative}.js`);
+}
+var SPAWNED_PROXIES = {
+  computer: resolveProxy("computer-proxy"),
+  permission: resolveProxy("permission-proxy"),
+  containerMcp: resolveProxy("container-mcp"),
+  vpsContainerMcp: resolveProxy("vps-container-mcp"),
+  agents: resolveProxy("drivers/agents-proxy"),
+  dweb: resolveProxy("drivers/dweb-proxy"),
+  connectors: resolveProxy("connector-proxy"),
+  phone: resolveProxy("drivers/phone-proxy"),
+  browser: resolveProxy("drivers/browser-proxy"),
+  // Loaded by the external `pi` process via `-e`, not by this server — but
+  // resolved through the same single source of truth so the packaged layout
+  // check can assert it ships.
+  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
+};
+export {
+  SERVER_ROOT,
+  SPAWNED_PROXIES,
+  resolveProxy
+};

package/dist-server/server/atomic.js

@@ -0,0 +1,40 @@
+// Durable, atomic file replace: write to a sibling temp file, fsync it, then
+// rename over the target. rename(2) is atomic on the same filesystem, so a
+// crash or power loss mid-write can never leave a truncated file behind — a
+// reader always sees either the complete old contents or the complete new
+// ones. Without this, an interrupted writeFileSync produces half-written JSON
+// that fails to parse on next boot and is silently treated as empty state.
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+export function writeFileAtomic(path, data, options = {}) {
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    let fd = null;
+    try {
+        // Apply sensitive-file permissions to the temporary inode itself. The
+        // final rename preserves them and never leaves a broader-permission
+        // config file visible between the write and a later chmod.
+        fd = openSync(tmp, "w", options.mode);
+        writeFileSync(fd, data);
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = null;
+        renameSync(tmp, path);
+    }
+    catch (e) {
+        if (fd !== null) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw e;
+    }
+}