@mirasim/computer-use 0.0.0-stage → 0.1.0-rc.2

package/extension/runtime-info.js

@@ -0,0 +1,9 @@
+/** Captured from the loaded manifest, never fetched from files that an app update can replace. */
+const manifest = chrome.runtime.getManifest();
+export const RUNTIME_INFO = Object.freeze({
+  id: chrome.runtime.id,
+  version: manifest.version,
+  build: manifest.version_name ?? null,
+  protocol: 1,
+  capabilities: ["discarded-tabs", "safe-reload"],
+});

package/extension/transport.js

@@ -0,0 +1,81 @@
+/**
+ * The two ways this worker reaches the local mirasim bridge, behind one shape.
+ *
+ * `RelayConnection` speaks JSON objects; which pipe carries them is this file's business:
+ *
+ *  - **native** — `chrome.runtime.connectNative`: Chrome spawns `mirasim-cu
+ *    bridge-host`, which pumps the frames into mirasim's own socket. The product path.
+ *  - **ws** — the one-shot relay a connect page handed over; only the end-to-end test seam
+ *    (see background.js).
+ *
+ * A transport is `{kind, send(obj), close(reason), onmessage, onclose}` — assign the two
+ * handlers, then send. Both call `onclose` exactly once.
+ */
+
+/** @typedef {{kind: 'native'|'ws', send: (msg: any) => void, close: (reason: string) => void, onmessage?: (msg: any) => void, onclose?: () => void}} Transport */
+
+/** @param {chrome.runtime.Port} port @returns {Transport} */
+export function nativeTransport(port) {
+  let closed = false;
+  /** @type {Transport} */
+  const transport = {
+    kind: "native",
+    // Ports carry structured values — no stringify, and no 1 MB blind spot of our own: the
+    // limit lives in Chrome and surfaces as a disconnect, which the reconnect loop handles.
+    send: (msg) => {
+      if (!closed) port.postMessage(msg);
+    },
+    close: () => {
+      if (closed) return;
+      closed = true;
+      try {
+        port.disconnect();
+      } catch {
+        /* already gone */
+      }
+    },
+  };
+  port.onMessage.addListener((msg) => transport.onmessage?.(msg));
+  port.onDisconnect.addListener(() => {
+    if (closed) return;
+    closed = true;
+    transport.onclose?.();
+  });
+  return transport;
+}
+
+/** @param {WebSocket} ws @returns {Transport} */
+export function webSocketTransport(ws) {
+  /** @type {Transport} */
+  const transport = {
+    kind: "ws",
+    send: (msg) => {
+      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(msg));
+    },
+    close: (reason) => {
+      try {
+        ws.close(1000, reason);
+      } catch {
+        /* already closing */
+      }
+    },
+  };
+  ws.onmessage = (event) => {
+    let msg;
+    try {
+      msg = JSON.parse(event.data);
+    } catch {
+      return; // a malformed frame is the bridge's bug; dropping it keeps the line up
+    }
+    transport.onmessage?.(msg);
+  };
+  let closed = false;
+  const shut = () => {
+    if (closed) return;
+    closed = true;
+    transport.onclose?.();
+  };
+  ws.onclose = shut;
+  ws.onerror = shut;
+  return transport;
+}

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@mirasim/computer-use",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.2",
+  "description": "Computer use for any agent: an MCP server that drives browsers, macOS apps, Windows apps and Electron apps through their accessibility trees.",
+  "type": "module",
+  "keywords": [
+    "computer-use",
+    "mcp",
+    "browser",
+    "macos",
+    "windows",
+    "accessibility",
+    "agent"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mirasim-ai/computer-use.git"
+  },
+  "homepage": "https://github.com/mirasim-ai/computer-use#readme",
+  "bugs": {
+    "url": "https://github.com/mirasim-ai/computer-use/issues"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "bin": {
+    "mirasim-cu": "bin/mirasim-cu.mjs"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "extension",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES",
+    "scripts/extension.mjs"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "dev": "tsx src/entries/cli.ts",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "npm run typecheck && node scripts/test.mjs unit",
+    "test:browser": "node scripts/test.mjs browser",
+    "test:all": "npm run typecheck && node scripts/test.mjs all"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "acorn": "^8.16.0",
+    "playwright-core": "^1.62.1",
+    "typebox": "^1.3.9",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.3",
+    "@types/ws": "^8.18.1",
+    "esbuild": "0.28.2",
+    "tsx": "^4.19.2",
+    "typescript": "7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@mirasim/computer-use-darwin-arm64": "0.1.0-rc.2",
+    "@mirasim/computer-use-darwin-x64": "0.1.0-rc.2",
+    "@mirasim/computer-use-win32-x64": "0.1.0-rc.2",
+    "@mirasim/computer-use-win32-arm64": "0.1.0-rc.2"
+  }
+}

package/scripts/extension.mjs

@@ -0,0 +1,111 @@
+/**
+ * The browser extension, packaged two ways from one identity and one readable file set:
+ *
+ * - `stageExtension(dir)` lays out the unpacked copy a host ships beside its bundle (imported by
+ *   hosts that bundle computer-use);
+ * - `node scripts/extension.mjs --version <v> --out <dir> [--public-key <pem>]` also writes the
+ *   deterministic, uncompressed Chrome Web Store ZIP, with Node alone (including on Windows).
+ */
+import { createHash, createPublicKey } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { crc32 } from 'node:zlib';
+
+export const extensionSource = fileURLToPath(new URL('../extension/', import.meta.url));
+const files = ['background.js', 'group.js', 'relay.js', 'runtime-info.js', 'transport.js',
+  'connect.html', 'connect.js', ...[16, 32, 48, 128].map((size) => `icons/icon-${size}.png`)];
+
+export function extensionId(key) {
+  return [...createHash('sha256').update(Buffer.from(key, 'base64')).digest().subarray(0, 16)]
+    .map((b) => 'abcdefghijklmnop'[b >> 4] + 'abcdefghijklmnop'[b & 15]).join('');
+}
+
+export function stageExtension(destination, options = {}) {
+  const source = options.sourceDir ?? extensionSource;
+  const manifest = JSON.parse(readFileSync(path.join(source, 'manifest.json'), 'utf8'));
+  manifest.version = options.version ?? manifest.version;
+  if (!/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){0,3}$/.test(manifest.version)
+    || manifest.version.split('.').some((n) => Number(n) > 65535)
+    || !manifest.version.split('.').some(Number)) throw new Error('Extension version must contain 1–4 integers from 0 to 65535 and cannot be all zero.');
+  if (manifest.description.length > 132) throw new Error('Extension description exceeds the Web Store 132-character limit.');
+  const keyFile = options.publicKeyFile;
+  if (keyFile) {
+    const input = readFileSync(keyFile, 'utf8').trim();
+    if (input.includes('PRIVATE KEY')) throw new Error('Provide the Web Store PUBLIC key, never a private key.');
+    const key = input.includes('BEGIN PUBLIC KEY') ? createPublicKey(input)
+      : createPublicKey({ key: Buffer.from(input.replace(/\s/g, ''), 'base64'), format: 'der', type: 'spki' });
+    if (key.asymmetricKeyType !== 'rsa') throw new Error('Expected an RSA public key from the Web Store Package tab.');
+    manifest.key = key.export({ format: 'der', type: 'spki' }).toString('base64');
+  }
+  // Stable across machines and output paths. The loaded manifest identifies the running code,
+  // even when an app update has already replaced the unpacked files on disk.
+  delete manifest.version_name;
+  const payload = files.map((name) => [name, readFileSync(path.join(source, name))]);
+  const { key: _identity, ...behavior } = manifest;
+  const hash = createHash('sha256').update(JSON.stringify(behavior));
+  for (const [name, content] of payload) hash.update(name).update(content);
+  manifest.version_name = `${manifest.version} (${hash.digest('hex').slice(0, 16)})`;
+  payload.push(['manifest.json', Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`)]);
+  // The license and its notices travel with every copy of the code (Apache-2.0 §4). They are not
+  // behavior, so they stay out of the fingerprint: changing them never reads as a new extension.
+  for (const name of ['LICENSE', 'NOTICE']) payload.push([name, readFileSync(path.join(source, '..', name))]);
+  for (const [name, content] of payload) {
+    const target = path.join(destination, name);
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, content);
+  }
+  return { manifest, extensionId: extensionId(manifest.key), files: payload };
+}
+
+/** The Web Store ZIP and its receipt (the command line above). */
+function packageForStore() {
+  const { values } = parseArgs({ options: {
+    version: { type: 'string' }, out: { type: 'string' }, 'public-key': { type: 'string' }, help: { type: 'boolean' },
+  } });
+  if (values.help || !values.version || !values.out) {
+    console.log('Usage: node scripts/extension.mjs --version 0.1.1 --out /path/to/new-output [--public-key /path/to/store-public-key.pem]');
+    process.exit(values.help ? 0 : 1);
+  }
+  const out = path.resolve(values.out);
+  if (existsSync(out)) throw new Error('Output already exists; choose a new directory so an earlier package is preserved.');
+  const staged = stageExtension(path.join(out, 'extension'), { version: values.version, publicKeyFile: values['public-key'] });
+  // The Web Store refuses an uploaded manifest that carries `key`: the store assigns the item's
+  // identity itself. Only the ZIP drops it — the unpacked copy keeps it, so loading that locally
+  // runs under the same ID, and the build fingerprint never covered `key` (stageExtension above).
+  const { key: _identity, ...storeManifest } = staged.manifest;
+  const zipFiles = staged.files.map(([name, content]) => name === 'manifest.json'
+    ? [name, Buffer.from(`${JSON.stringify(storeManifest, null, 2)}\n`)] : [name, content]);
+  const local = [], central = [];
+  let offset = 0;
+  for (const [name, content] of zipFiles.sort(([a], [b]) => a.localeCompare(b, 'en'))) {
+    const filename = Buffer.from(name), checksum = crc32(content);
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(0x04034b50); header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(0x21, 12); // fixed DOS date: 1980-01-01
+    header.writeUInt32LE(checksum, 14); header.writeUInt32LE(content.length, 18);
+    header.writeUInt32LE(content.length, 22); header.writeUInt16LE(filename.length, 26);
+    local.push(header, filename, content);
+    const entry = Buffer.alloc(46);
+    entry.writeUInt32LE(0x02014b50); entry.writeUInt16LE(20, 4); entry.writeUInt16LE(20, 6);
+    entry.writeUInt16LE(0x21, 14); entry.writeUInt32LE(checksum, 16);
+    entry.writeUInt32LE(content.length, 20); entry.writeUInt32LE(content.length, 24);
+    entry.writeUInt16LE(filename.length, 28); entry.writeUInt32LE(offset, 42);
+    central.push(entry, filename);
+    offset += header.length + filename.length + content.length;
+  }
+  const directory = Buffer.concat(central), end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50); end.writeUInt16LE(zipFiles.length, 8); end.writeUInt16LE(zipFiles.length, 10);
+  end.writeUInt32LE(directory.length, 12); end.writeUInt32LE(offset, 16);
+  const zip = Buffer.concat([...local, directory, end]);
+  const filename = `mirasim-browser-bridge-${staged.manifest.version}.zip`;
+  mkdirSync(out, { recursive: true });
+  writeFileSync(path.join(out, filename), zip);
+  const receipt = { file: filename, version: staged.manifest.version, build: staged.manifest.version_name,
+    extensionId: staged.extensionId, sha256: createHash('sha256').update(zip).digest('hex') };
+  writeFileSync(path.join(out, 'package.json'), `${JSON.stringify(receipt, null, 2)}\n`);
+  console.log(JSON.stringify(receipt, null, 2));
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) packageForStore();