ramwisp 0.1.1

package/README.md

@@ -0,0 +1,12 @@
+# ramwisp
+
+Subagentes do Claude Code e do Codex em máquinas próprias na nuvem, com a RAM que precisarem.
+Cada subagente roda numa AWS Nitro Enclave efêmera: antes de enviar qualquer coisa, este MCP confere a
+atestação do hardware (raiz AWS Nitro Enclaves G1 + PCR0 publicado) e cifra missão, projeto e credencial
+só para aquela enclave.
+
+```bash
+claude mcp add --scope user ramwisp -- npx -y ramwisp@latest
+```
+
+No primeiro uso ele abre o navegador para você entrar na sua conta. Mais em https://ramwisp.duckdns.org

package/bin/wisp.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// Sem argumentos: servidor MCP (é o que o Claude Code/Codex executa). Com argumentos: CLI para humanos.
+import { API, getToken, logout, startLogin } from "../src/account.js";
+import { killAgent, listAgents, result, sealed, spawnAgent, waitAgent } from "../src/client.js";
+import { serve } from "../src/mcp.js";
+
+const [cmd, ...rest] = process.argv.slice(2);
+const flag = (name, d) => { const i = rest.indexOf(`--${name}`); return i >= 0 ? rest[i + 1] : d; };
+const out = (x) => console.log(JSON.stringify(x, null, 2));
+
+const HELP = `wisp — subagentes com RAM sob demanda (${API})
+
+  wisp login                         conecta esta máquina à sua conta (navegador)
+  wisp logout
+  wisp spawn "missão" [--ram 2] [--engine claude|codex] [--model M] [--auth auto|login|key] [--workspace DIR] [--wait]
+  wisp wait ID | result ID | kill ID
+  wisp ls
+  wisp setup                         mostra como adicionar o MCP ao Claude Code / Codex
+
+Sem argumentos roda o servidor MCP (stdio).`;
+
+async function main() {
+  switch (cmd) {
+    case undefined: case "mcp": return serve();
+    case "login": {
+      if (getToken()) return console.log(`já conectado a ${API} (wisp logout para trocar)`);
+      const l = await startLogin();
+      console.log(`${l.opened ? "Abri o navegador. Se não abriu, acesse" : "Abra"}: ${l.verification_uri_complete}\nCódigo: ${l.user_code}`);
+      await l.done;
+      return console.log("conectado ✓");
+    }
+    case "logout": logout(); return console.log("desconectado");
+    case "spawn": {
+      const r = await spawnAgent({ mission: rest[0], ram_gb: Number(flag("ram", 2)), engine: flag("engine", "claude"),
+        model: flag("model"), auth: flag("auth", "auto"), timeout_s: Number(flag("timeout", 1800)), label: flag("label"), workspace: flag("workspace") });
+      out(r);
+      console.error("esperando a máquina e a atestação para mandar a missão selada…");
+      await sealed(r.id);
+      const now = await result(r.id);
+      if (now.erro || ["failed", "killed", "expired"].includes(now.status)) { out(now); process.exit(1); }
+      if (rest.includes("--wait")) return out(await waitAgent(r.id, 3600));
+      return console.error(`missão entregue. Recolha com: wisp wait ${r.id}`);
+    }
+    case "wait": return out(await waitAgent(rest[0], Number(flag("max", 3600))));
+    case "result": return out(await result(rest[0]));
+    case "kill": return out(await killAgent(rest[0]));
+    case "ls": return out(await listAgents());
+    case "setup":
+      return console.log(`Claude Code:\n  claude mcp add --scope user wisp -- npx -y ${API}/wisp.tgz\n\n` +
+        `Codex (~/.codex/config.toml):\n  [mcp_servers.wisp]\n  command = "npx"\n  args = ["-y", "${API}/wisp.tgz"]\n  tool_timeout_sec = 1000`);
+    default: return console.log(HELP);
+  }
+}
+
+main().catch((e) => { console.error("erro:", e.message); process.exit(1); });

package/nitro-root-g1.pem

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICETCCAZagAwIBAgIRAPkxdWgbkK/hHUbMtOTn+FYwCgYIKoZIzj0EAwMwSTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYD
+VQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMTkxMDI4MTMyODA1WhcNNDkxMDI4
+MTQyODA1WjBJMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQL
+DANBV1MxGzAZBgNVBAMMEmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEG
+BSuBBAAiA2IABPwCVOumCMHzaHDimtqQvkY4MpJzbolL//Zy2YlES1BR5TSksfbb
+48C8WBoyt7F2Bw7eEtaaP+ohG2bnUs990d0JX28TcPQXCEPZ3BABIeTPYwEoCWZE
+h8l5YoQwTcU/9KNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkCW1DdkF
+R+eWw5b6cp3PmanfS5YwDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMDA2kAMGYC
+MQCjfy+Rocm9Xue4YnwWmNJVA44fA0P5W2OpYow9OYCVRaEevL8uO1XYru5xtMPW
+rfMCMQCi85sWBbJwKKXdS6BptQFuZbT73o/gBh1qUxl/nNr12UO8Yfwr6wPLb+6N
+IwLz3/Y=
+-----END CERTIFICATE-----

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "ramwisp",
+  "version": "0.1.1",
+  "description": "ramwisp: subagentes do Claude Code e do Codex em máquinas próprias na nuvem (AWS Nitro Enclaves), com a sua assinatura. MCP + CLI.",
+  "type": "module",
+  "bin": {
+    "ramwisp": "bin/wisp.js",
+    "wisp": "bin/wisp.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "nitro-root-g1.pem",
+    "pcrs.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "license": "UNLICENSED",
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "codex",
+    "subagents",
+    "nitro-enclaves"
+  ],
+  "homepage": "https://ramwisp.duckdns.org"
+}

package/pcrs.json

@@ -0,0 +1,8 @@
+{
+  "pcr0": [
+    "32d23882b517b1b6b835934e0b684f29e2add4096c1ca42302b33ce38d202f39c3bf8d2ffff9001e355810800e2d0a4e"
+  ],
+  "builds": {
+    "32d23882b517b1b6b835934e0b684f29e2add4096c1ca42302b33ce38d202f39c3bf8d2ffff9001e355810800e2d0a4e": "380f1c5"
+  }
+}

package/src/account.js

@@ -0,0 +1,97 @@
+// Conta wisp (não é a credencial do motor): token wsp_… guardado em ~/.config/wisp/credentials.json (0600).
+import { spawn } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join } from "node:path";
+
+export const API = (process.env.WISP_API ?? "https://ramwisp.duckdns.org").replace(/\/$/, "");
+export const DIR = process.env.WISP_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "wisp");
+const CRED = join(DIR, "credentials.json");
+
+export function ensureDir(sub = "") {
+  const d = join(DIR, sub);
+  mkdirSync(d, { recursive: true, mode: 0o700 });
+  return d;
+}
+
+export function writeSecret(path, data) {
+  writeFileSync(path, data, { mode: 0o600 });
+  chmodSync(path, 0o600);
+}
+
+export function getToken() {
+  if (process.env.WISP_TOKEN) return process.env.WISP_TOKEN;
+  try {
+    const c = JSON.parse(readFileSync(CRED, "utf8"));
+    return c.api === API ? c.token : null;
+  } catch { return null; }
+}
+
+export function saveToken(token) {
+  ensureDir();
+  writeSecret(CRED, JSON.stringify({ api: API, token, saved_at: new Date().toISOString() }));
+}
+
+export function logout() {
+  if (existsSync(CRED)) rmSync(CRED);
+}
+
+export async function call(method, path, body, { token = getToken(), timeoutMs = 30_000 } = {}) {
+  const r = await fetch(API + path, {
+    method,
+    headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const text = await r.text();
+  let data = null;
+  try { data = text ? JSON.parse(text) : null; } catch { data = { error: text.slice(0, 300) }; }
+  if (!r.ok) {
+    const err = new Error(data?.error ?? `HTTP ${r.status}`);
+    err.status = r.status;
+    throw err;
+  }
+  return data;
+}
+
+export function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  try {
+    const p = spawn(cmd, args, { stdio: "ignore", detached: true });
+    p.on("error", () => {});
+    p.unref();
+    return true;
+  } catch { return false; }
+}
+
+let pending = null;   // login em andamento (um por processo)
+
+/** Começa (ou reaproveita) o login pelo navegador. Resolve quando aprovado. */
+export function startLogin() {
+  if (pending) return pending;
+  const p = (async () => {
+    const d = await call("POST", "/api/device/start", { client_name: `MCP em ${hostname()}` }, { token: null });
+    const opened = openBrowser(d.verification_uri_complete);
+    const done = (async () => {
+      const until = Date.now() + d.expires_in * 1000;
+      while (Date.now() < until) {
+        await new Promise((r) => setTimeout(r, d.interval * 1000));
+        try {
+          const r = await call("POST", "/api/device/poll", { device_code: d.device_code }, { token: null });
+          saveToken(r.token);
+          return r.token;
+        } catch (e) {
+          if (e.status !== 428) throw e;
+        }
+      }
+      throw new Error("o login expirou; tente de novo");
+    })();
+    done.finally(() => { pending = null; }).catch(() => {});
+    return { ...d, opened, done };
+  })();
+  pending = p;
+  p.catch(() => { pending = null; });
+  return p;
+}

package/src/attest.js

@@ -0,0 +1,65 @@
+// Confere o documento de atestação da enclave ANTES de qualquer segredo sair desta máquina.
+// Raiz confiável: AWS Nitro Enclaves Root G1 (nitro-root-g1.pem, sha256 do zip oficial conferido).
+// Imagens aceitas: PCR0 em pcrs.json (hash da imagem publicada da enclave).
+import { X509Certificate, createHash, verify } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { decode, encodeSigStructure } from "./cbor.js";
+
+const here = new URL("..", import.meta.url);
+const NITRO_ROOT = new X509Certificate(readFileSync(new URL("nitro-root-g1.pem", here)));
+const DEV_PCR0 = createHash("sha384").update("wisp-dev-image").digest("hex");
+const MAX_AGE_MS = 15 * 60_000;
+
+export function allowedPcr0() {
+  const extra = (process.env.WISP_EXTRA_PCR0 ?? "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const pinned = JSON.parse(readFileSync(new URL("pcrs.json", here), "utf8")).pcr0 ?? [];
+  return [...pinned.map((p) => p.toLowerCase()), ...extra];
+}
+
+/**
+ * @returns {{enclavePub: Buffer, pcr0: string, moduleId: string, timestamp: number, dev: boolean}}
+ * Lança erro se QUALQUER coisa não bater.
+ */
+export function verifyAttestation(docB64, expectedNonce, { devRootPem } = {}) {
+  const doc = decode(Buffer.from(docB64, "base64"));
+  if (!Array.isArray(doc) || doc.length !== 4) throw new Error("atestação: não é COSE_Sign1");
+  const [protectedBytes, , payloadBytes, signature] = doc;
+  const prot = decode(protectedBytes);
+  if (!(prot instanceof Map) || prot.get(1) !== -35) throw new Error("atestação: algoritmo não é ES384");
+  const p = decode(payloadBytes);
+  const get = (k) => { const v = p.get(k); if (v === undefined || v === null) throw new Error(`atestação: falta ${k}`); return v; };
+
+  // cadeia: cabundle[0] é a raiz, depois intermediárias, por fim o certificado da enclave
+  const bundle = get("cabundle").map((der) => new X509Certificate(der));
+  const leaf = new X509Certificate(get("certificate"));
+  const dev = !!devRootPem;
+  const root = dev ? new X509Certificate(devRootPem) : NITRO_ROOT;
+  if (!bundle.length || !bundle[0].raw.equals(root.raw)) throw new Error("atestação: raiz não é a AWS Nitro Enclaves");
+  const chain = [...bundle, leaf];
+  const at = new Date();
+  for (let i = 0; i < chain.length; i++) {
+    const cert = chain[i];
+    const issuer = i === 0 ? root : chain[i - 1];
+    if (!cert.verify(issuer.publicKey)) throw new Error(`atestação: assinatura do certificado ${i} inválida`);
+    if (at < new Date(cert.validFrom) || at > new Date(cert.validTo)) throw new Error(`atestação: certificado ${i} fora da validade`);
+    if (i < chain.length - 1 && !cert.ca) throw new Error(`atestação: certificado ${i} não é CA`);
+  }
+  const ok = verify("sha384", encodeSigStructure(protectedBytes, payloadBytes),
+    { key: leaf.publicKey, dsaEncoding: "ieee-p1363" }, signature);
+  if (!ok) throw new Error("atestação: assinatura COSE inválida");
+
+  if (get("digest") !== "SHA384") throw new Error("atestação: digest inesperado");
+  const ts = get("timestamp");
+  if (Math.abs(Date.now() - ts) > MAX_AGE_MS) throw new Error("atestação: velha demais ou do futuro");
+  if (!Buffer.from(get("nonce")).equals(expectedNonce)) throw new Error("atestação: nonce não confere (repetição?)");
+  const ud = p.get("user_data");
+  if (!ud || Buffer.from(ud).toString() !== "wisp-v1") throw new Error("atestação: protocolo desconhecido");
+  const enclavePub = Buffer.from(get("public_key"));
+  if (enclavePub.length !== 32) throw new Error("atestação: chave pública inválida");
+
+  const pcr0 = Buffer.from(get("pcrs").get(0)).toString("hex");
+  if (/^0+$/.test(pcr0)) throw new Error("atestação: enclave em modo debug (PCR0 zerado) — recusado");
+  const allowed = dev ? [DEV_PCR0] : allowedPcr0();
+  if (!allowed.includes(pcr0)) throw new Error(`atestação: imagem não reconhecida (PCR0 ${pcr0.slice(0, 16)}…)`);
+  return { enclavePub, pcr0, moduleId: get("module_id"), timestamp: ts, dev };
+}

package/src/cbor.js

@@ -0,0 +1,80 @@
+// Decodificador CBOR mínimo (RFC 8949) para o documento de atestação. Mapas viram Map (chaves podem ser inteiros).
+
+export function decode(buf) {
+  const b = Buffer.from(buf);
+  const [v] = item(b, 0);
+  return v;
+}
+
+function item(b, i) {
+  const ib = b[i++];
+  const major = ib >> 5, ai = ib & 31;
+  if (major === 7) {
+    if (ai === 20) return [false, i];
+    if (ai === 21) return [true, i];
+    if (ai === 22 || ai === 23) return [null, i];
+    if (ai === 26) return [b.readFloatBE(i), i + 4];
+    if (ai === 27) return [b.readDoubleBE(i), i + 8];
+    throw new Error(`cbor: simple ${ai}`);
+  }
+  if (ai === 31) return indefinite(b, i, major);   // comprimento indefinido (o NSM da AWS usa)
+  let n;
+  if (ai < 24) n = ai;
+  else if (ai === 24) { n = b[i]; i += 1; }
+  else if (ai === 25) { n = b.readUInt16BE(i); i += 2; }
+  else if (ai === 26) { n = b.readUInt32BE(i); i += 4; }
+  else if (ai === 27) { n = Number(b.readBigUInt64BE(i)); i += 8; }
+  else throw new Error(`cbor: info adicional ${ai}`);
+  switch (major) {
+    case 0: return [n, i];
+    case 1: return [-1 - n, i];
+    case 2: return [b.subarray(i, i + n), i + n];
+    case 3: return [b.subarray(i, i + n).toString("utf8"), i + n];
+    case 4: {
+      const out = [];
+      for (let k = 0; k < n; k++) { let v; [v, i] = item(b, i); out.push(v); }
+      return [out, i];
+    }
+    case 5: {
+      const out = new Map();
+      for (let k = 0; k < n; k++) { let key, v; [key, i] = item(b, i); [v, i] = item(b, i); out.set(key, v); }
+      return [out, i];
+    }
+    case 6: return item(b, i);          // tag (COSE_Sign1 = 18): devolve o conteúdo
+    default: throw new Error(`cbor: major ${major}`);
+  }
+}
+
+/** Codificador só para o Sig_structure do COSE: ["Signature1", bstr, bstr, bstr]. */
+export function encodeSigStructure(protectedBytes, payload) {
+  const head = (major, len) => {
+    if (len < 24) return Buffer.from([(major << 5) | len]);
+    if (len < 256) return Buffer.from([(major << 5) | 24, len]);
+    if (len < 65536) { const h = Buffer.alloc(3); h[0] = (major << 5) | 25; h.writeUInt16BE(len, 1); return h; }
+    const h = Buffer.alloc(5); h[0] = (major << 5) | 26; h.writeUInt32BE(len, 1); return h;
+  };
+  const bstr = (x) => Buffer.concat([head(2, x.length), x]);
+  const ctx = Buffer.from("Signature1");
+  return Buffer.concat([head(4, 4), head(3, ctx.length), ctx, bstr(protectedBytes), bstr(Buffer.alloc(0)), bstr(payload)]);
+}
+
+/** Itens de comprimento indefinido: pedaços ou elementos até o byte de parada 0xFF. */
+function indefinite(b, i, major) {
+  if (major === 2 || major === 3) {
+    const parts = [];
+    while (b[i] !== 0xff) { let v; [v, i] = item(b, i); parts.push(major === 2 ? Buffer.from(v) : Buffer.from(v, "utf8")); }
+    const all = Buffer.concat(parts);
+    return [major === 2 ? all : all.toString("utf8"), i + 1];
+  }
+  if (major === 4) {
+    const out = [];
+    while (b[i] !== 0xff) { let v; [v, i] = item(b, i); out.push(v); }
+    return [out, i + 1];
+  }
+  if (major === 5) {
+    const out = new Map();
+    while (b[i] !== 0xff) { let k, v; [k, i] = item(b, i); [v, i] = item(b, i); out.set(k, v); }
+    return [out, i + 1];
+  }
+  throw new Error(`cbor: indefinido em major ${major}`);
+}

package/src/client.js

@@ -0,0 +1,187 @@
+// Ciclo de um subagente do lado do cliente: cria o job, espera a atestação, confere, sela e recolhe o resultado.
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { call, ensureDir, getToken, writeSecret } from "./account.js";
+import { verifyAttestation } from "./attest.js";
+import { exportKey, importKey, newClientKey, openOutput, sealInput } from "./crypto.js";
+import { engineCredential } from "./creds.js";
+
+export const FINAL = ["done", "failed", "killed", "expired"];
+const sealers = new Map();          // id -> Promise (selagem em andamento neste processo)
+const sealErrors = new Map();
+
+export class LoginRequired extends Error {}
+
+const keyFile = (id) => join(ensureDir("jobs"), `${id}.json`);
+const MAX_WORKSPACE = 15 * 1024 * 1024;       // compactado
+const SKIP_DIRS = new Set(["node_modules", ".git", ".venv", "venv", "__pycache__", "dist", "build", ".next", "target", ".cache"]);
+
+/** Copia do projeto: no git, o que ele rastreia + arquivos novos não ignorados (nunca o que está no .gitignore). */
+export function packWorkspace(dir) {
+  const root = resolve(dir);
+  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`workspace não é um diretório: ${root}`);
+  let files;
+  const git = spawnSync("git", ["-C", root, "ls-files", "-z", "-co", "--exclude-standard"], { maxBuffer: 256 * 1024 * 1024 });
+  if (git.status === 0) {
+    files = git.stdout.toString().split("\0").filter((f) => f && existsSync(join(root, f)));
+  } else {
+    files = [];
+    const walk = (rel) => {
+      for (const e of readdirSync(join(root, rel), { withFileTypes: true })) {
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(r); }
+        else if (e.isFile() && !/^\.env(\.|$)/.test(e.name)) files.push(r);
+      }
+    };
+    walk("");
+  }
+  if (!files.length) throw new Error(`workspace vazio: ${root}`);
+  const tar = spawnSync("tar", ["-czf", "-", "-C", root, "--null", "-T", "-"], { input: files.join("\0"), maxBuffer: 256 * 1024 * 1024 });
+  if (tar.status !== 0) throw new Error(`tar falhou: ${tar.stderr.toString().slice(0, 300)}`);
+  if (tar.stdout.length > MAX_WORKSPACE) {
+    throw new Error(`projeto grande demais (${(tar.stdout.length / 1048576).toFixed(1)} MB compactado, máximo 15 MB): ` +
+      "aponte workspace para um subdiretório ou ignore arquivos pesados no .gitignore");
+  }
+  return { root, tgz: tar.stdout, files: files.length };
+}
+const devRoot = () => (process.env.WISP_DEV_ROOT ? readFileSync(process.env.WISP_DEV_ROOT, "utf8") : undefined);
+
+export async function spawnAgent(o) {
+  if (!getToken()) throw new LoginRequired();
+  const engine = o.engine ?? "claude";
+  let timeout = o.timeout_s ?? 1800;
+  const cred = engineCredential(engine, o.auth ?? process.env.WISP_AUTH ?? "auto", timeout);
+  let note;
+  if (cred.left && cred.left - 300 < timeout) {
+    timeout = Math.max(60, Math.floor(cred.left - 300));
+    note = `timeout reduzido para ${timeout}s (validade do login local)`;
+  }
+  const ws = o.workspace ? packWorkspace(o.workspace) : null;
+  const priv = newClientKey();
+  const nonce = randomBytes(32);
+  const job = await call("POST", "/api/jobs", { engine, ram_gb: o.ram_gb ?? 2, timeout_s: timeout,
+    nonce: nonce.toString("base64"), label: o.label });
+  writeSecret(keyFile(job.id), JSON.stringify({ id: job.id, priv: exportKey(priv), nonce: nonce.toString("base64"), engine,
+    workspace: ws?.root }));
+  const payload = Buffer.from(JSON.stringify({ engine, model: o.model, mission: o.mission, turns: o.max_turns ?? 20,
+    timeout, auth: { kind: cred.kind, value: cred.value }, ...(ws ? { workspace_tgz: ws.tgz.toString("base64") } : {}) }));
+  const p = sealWhenReady(job.id, priv, nonce, payload).finally(() => { payload.fill(0); sealers.delete(job.id); });
+  sealers.set(job.id, p);
+  p.catch(() => {});
+  return { id: job.id, status: job.status, engine, ram_gb: job.ram_gb, instance_type: job.instance_type,
+    credential: cred.source, reserved_usd: +(job.hold_cents / 100).toFixed(4),
+    ...(ws ? { workspace: `${ws.root} (${ws.files} arquivos, ${(ws.tgz.length / 1024).toFixed(0)} KB, cifrado)` } : {}),
+    ...(note ? { note } : {}) };
+}
+
+async function sealWhenReady(id, priv, nonce, payload) {
+  const until = Date.now() + 20 * 60_000;
+  while (Date.now() < until) {
+    const j = await call("GET", `/api/jobs/${id}`).catch(() => null);
+    if (j && FINAL.includes(j.status)) return;
+    if (j?.attestation) {
+      let att;
+      try {
+        att = verifyAttestation(j.attestation, nonce, { devRootPem: devRoot() });
+      } catch (e) {
+        sealErrors.set(id, e.message);
+        await call("DELETE", `/api/jobs/${id}`).catch(() => {});
+        throw e;
+      }
+      const f = keyFile(id);
+      const k = JSON.parse(readFileSync(f, "utf8"));
+      writeSecret(f, JSON.stringify({ ...k, enclave_pub: att.enclavePub.toString("base64"), pcr0: att.pcr0, dev: att.dev }));
+      await call("POST", `/api/jobs/${id}/input`, { sealed: sealInput(priv, att.enclavePub, nonce, payload) });
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  throw new Error("a máquina não ficou pronta em 20 min");
+}
+
+/** Espera a selagem terminar (útil para o CLI, que sai logo depois). */
+export async function sealed(id) {
+  await sealers.get(id);
+}
+
+function parseOutput(stdout) {
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  try {
+    const last = JSON.parse(lines.at(-1));
+    const isCodex = last?.type === "turn.completed" || lines.slice(0, 3).some((l) => l.includes('"thread.started"'));
+    if (!isCodex) return { engine: "claude", ...last };
+    const res = { engine: "codex", result: "" };
+    for (const l of lines) {
+      let ev; try { ev = JSON.parse(l); } catch { continue; }
+      const item = ev.item ?? {};
+      if (ev.type === "item.completed" && item.type === "agent_message") res.result = item.text ?? "";
+      else if (ev.type === "turn.completed") res.usage = ev.usage;
+      else if (ev.type === "turn.failed" || ev.type === "error") { res.is_error = true; res.erro = ev.error?.message ?? ev.message; }
+    }
+    return res;
+  } catch {
+    return { raw: stdout.trim().slice(-2000) };
+  }
+}
+
+/** Resultado final (e apaga a chave local e a saída cifrada no servidor), ou o status se ainda roda. */
+export async function result(id) {
+  const j = await call("GET", `/api/jobs/${id}`);
+  const meta = { id, status: j.status, ram_gb: j.ram_gb, peak_mem_mib: j.peak_mem_mib, cost_usd: j.cost_cents != null ? +(j.cost_cents / 100).toFixed(4) : null };
+  if (sealErrors.has(id)) return { ...meta, status: "failed", erro: `recusado por segurança: ${sealErrors.get(id)}` };
+  if (!FINAL.includes(j.status)) return { ...meta, mem_used_mib: j.mem_used_mib };
+  if (j.status !== "done" || !j.output) {
+    rmSync(keyFile(id), { force: true });
+    return { ...meta, erro: j.error ?? (j.collected_at ? "resultado já recolhido antes" : j.status) };
+  }
+  const f = keyFile(id);
+  if (!existsSync(f)) return { ...meta, erro: "a chave para abrir esse resultado não está nesta máquina" };
+  const k = JSON.parse(readFileSync(f, "utf8"));
+  const out = JSON.parse(openOutput(importKey(k.priv), Buffer.from(k.enclave_pub, "base64"), Buffer.from(k.nonce, "base64"), j.output).toString());
+  await call("POST", `/api/jobs/${id}/collected`).catch(() => {});
+  rmSync(f, { force: true });
+  const parsed = parseOutput(out.stdout ?? "");
+  const res = { ...parsed, ...meta, exit_code: out.exit_code, duration_s: out.duration_s };
+  if (out.exit_code === 124) res.erro = "timeout";
+  if (out.patch) {
+    const f = join(ensureDir("patches"), `${id}.patch`);
+    writeSecret(f, out.patch);
+    res.patch_file = f;
+    res.patch_stat = out.patch_stat;
+    res.aplicar = k.workspace ? `git -C ${JSON.stringify(k.workspace)} apply ${JSON.stringify(f)}` : `git apply ${JSON.stringify(f)}`;
+  } else if (out.patch === "") {
+    res.patch_stat = "nenhuma mudança no projeto";
+  } else if (out.patch_error) {
+    res.patch_erro = out.patch_error;
+    res.patch_stat = out.patch_stat;
+  }
+  if (out.exit_code !== 0 && out.stderr_tail) res.stderr_tail = out.stderr_tail.slice(-1500);
+  return res;
+}
+
+export async function waitAgent(id, maxWaitS = 900) {
+  const until = Date.now() + maxWaitS * 1000;
+  for (;;) {
+    const r = await result(id);
+    if (FINAL.includes(r.status) || r.erro || Date.now() > until) return r;
+    await new Promise((res) => setTimeout(res, 3000));
+  }
+}
+
+export async function killAgent(id) {
+  const j = await call("DELETE", `/api/jobs/${id}`);
+  rmSync(keyFile(id), { force: true });
+  return { id, status: j.status, cost_usd: j.cost_cents != null ? +(j.cost_cents / 100).toFixed(4) : null };
+}
+
+export async function listAgents() {
+  const [me, jobs] = await Promise.all([call("GET", "/api/me"), call("GET", "/api/jobs?limit=20")]);
+  return {
+    conta: me.email, saldo_usd: +(me.credit_cents / 100).toFixed(2),
+    ram_disponivel_gb: me.tiers.filter((t) => t.available).map((t) => t.ram_gb),
+    agentes: jobs.filter((j) => !FINAL.includes(j.status) || (j.status === "done" && !j.collected_at)).map((j) => ({
+      id: j.id, status: j.status, engine: j.engine, ram_gb: j.ram_gb, mem_used_mib: j.mem_used_mib, label: j.label })),
+  };
+}

package/src/creds.js

@@ -0,0 +1,65 @@
+// Credencial do MOTOR (Claude/Codex), lida só nesta máquina. Sai daqui apenas cifrada para a enclave atestada.
+// Só o access token vai: nunca o refresh token, então a sessão local nunca cai nem é rotacionada lá.
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const MIN_LEFT_S = 600;
+
+function claudeLogin() {
+  let raw = "";
+  if (process.platform === "darwin") {
+    try { raw = execFileSync("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }); } catch {}
+  }
+  if (!raw.trim()) {
+    const f = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), ".credentials.json");
+    if (existsSync(f)) raw = readFileSync(f, "utf8");
+  }
+  try {
+    const o = JSON.parse(raw).claudeAiOauth;
+    return { token: o.accessToken, exp: o.expiresAt / 1000 };
+  } catch { return null; }
+}
+
+function claudeCredential(mode, needS) {
+  const key = process.env.WISP_ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+  if (mode !== "login" && key) return { kind: "anthropic_key", value: key, left: null, source: "chave de API" };
+  if (mode === "key") throw new Error("modo chave: defina ANTHROPIC_API_KEY (ou WISP_ANTHROPIC_API_KEY) no env do MCP");
+  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) return { kind: "claude_oauth", value: process.env.CLAUDE_CODE_OAUTH_TOKEN, left: null, source: "CLAUDE_CODE_OAUTH_TOKEN" };
+  let l = claudeLogin();
+  if (l && l.exp - Date.now() / 1000 < Math.max(MIN_LEFT_S, needS)) {
+    // quase vencendo: uma chamada mínima faz o Claude Code local renovar o próprio login
+    spawnSync("claude", ["-p", "ok", "--max-turns", "1"], { stdio: "ignore", timeout: 120_000 });
+    l = claudeLogin();
+  }
+  if (!l) throw new Error("sem login do Claude Code nesta máquina: rode `claude` e faça login, ou use uma chave (ANTHROPIC_API_KEY)");
+  const left = l.exp - Date.now() / 1000;
+  if (left < MIN_LEFT_S) throw new Error("o login local do Claude não renovou; abra o Claude Code uma vez e tente de novo");
+  return { kind: "claude_oauth", value: l.token, left, source: "login do Claude Code" };
+}
+
+const jwtExp = (t) => JSON.parse(Buffer.from(t.split(".")[1], "base64url").toString()).exp;
+
+function codexCredential(mode) {
+  const key = process.env.WISP_OPENAI_API_KEY || process.env.OPENAI_API_KEY;
+  if (mode !== "login" && key) return { kind: "openai_key", value: key, left: null, source: "chave de API" };
+  const path = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "auth.json");
+  let d;
+  try { d = JSON.parse(readFileSync(path, "utf8")); } catch {
+    throw new Error(mode === "key" ? "modo chave: defina OPENAI_API_KEY no env do MCP" : "sem login do Codex nesta máquina: rode `codex login`");
+  }
+  if (mode !== "login" && d.OPENAI_API_KEY) return { kind: "openai_key", value: d.OPENAI_API_KEY, left: null, source: "chave do Codex" };
+  if (mode === "key") throw new Error("modo chave: defina OPENAI_API_KEY no env do MCP");
+  const t = d.tokens ?? {};
+  const left = jwtExp(t.access_token) - Date.now() / 1000;
+  if (left < MIN_LEFT_S) throw new Error("o login do Codex venceu; abra o Codex uma vez nesta máquina");
+  const slim = { auth_mode: d.auth_mode ?? "chatgpt", OPENAI_API_KEY: null, last_refresh: new Date().toISOString(),
+    tokens: { id_token: t.id_token, access_token: t.access_token, account_id: t.account_id, refresh_token: "" } };
+  return { kind: "codex_auth", value: JSON.stringify(slim), left, source: "login do ChatGPT/Codex" };
+}
+
+/** mode: "auto" (chave se houver, senão login), "key" ou "login". */
+export function engineCredential(engine, mode = process.env.WISP_AUTH ?? "auto", needS = 0) {
+  return engine === "codex" ? codexCredential(mode) : claudeCredential(mode, needS);
+}

package/src/crypto.js

@@ -0,0 +1,41 @@
+// Canal selado wisp-v1 (mesma especificação de enclave/sealed.py).
+import { createCipheriv, createDecipheriv, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync,
+  hkdfSync, randomBytes } from "node:crypto";
+
+const V = Buffer.from("wisp-v1");
+const rawPub = (pub) => Buffer.from(pub.export({ format: "jwk" }).x, "base64url");
+const pubFromRaw = (raw) => createPublicKey({ key: { kty: "OKP", crv: "X25519", x: Buffer.from(raw).toString("base64url") }, format: "jwk" });
+
+export function newClientKey() {
+  const { privateKey } = generateKeyPairSync("x25519");
+  return privateKey;
+}
+
+export const exportKey = (priv) => priv.export({ format: "der", type: "pkcs8" }).toString("base64");
+export const importKey = (b64) => createPrivateKey({ key: Buffer.from(b64, "base64"), format: "der", type: "pkcs8" });
+
+function key(priv, enclavePub, nonce, direction) {
+  const clientPub = rawPub(createPublicKey(priv));
+  const shared = diffieHellman({ privateKey: priv, publicKey: pubFromRaw(enclavePub) });
+  const info = Buffer.concat([V, Buffer.from(" " + direction), enclavePub, clientPub]);
+  return { k: Buffer.from(hkdfSync("sha256", shared, nonce, info, 32)), clientPub };
+}
+
+export function sealInput(priv, enclavePub, nonce, plaintext) {
+  const { k, clientPub } = key(priv, enclavePub, nonce, "in");
+  const iv = randomBytes(12);
+  const c = createCipheriv("chacha20-poly1305", k, iv, { authTagLength: 16 });
+  c.setAAD(Buffer.concat([V, Buffer.from(" in")]), { plaintextLength: plaintext.length });
+  const ct = Buffer.concat([c.update(plaintext), c.final(), c.getAuthTag()]);
+  k.fill(0);
+  return { c_pub: clientPub.toString("base64"), iv: iv.toString("base64"), ct: ct.toString("base64") };
+}
+
+export function openOutput(priv, enclavePub, nonce, msg) {
+  const { k } = key(priv, enclavePub, nonce, "out");
+  const data = Buffer.from(msg.ct, "base64");
+  const d = createDecipheriv("chacha20-poly1305", k, Buffer.from(msg.iv, "base64"), { authTagLength: 16 });
+  d.setAAD(Buffer.concat([V, Buffer.from(" out")]), { plaintextLength: data.length - 16 });
+  d.setAuthTag(data.subarray(data.length - 16));
+  return Buffer.concat([d.update(data.subarray(0, data.length - 16)), d.final()]);
+}

package/src/mcp.js

@@ -0,0 +1,123 @@
+// Servidor MCP (stdio, JSON-RPC por linha). Sem dependências.
+import { createInterface } from "node:readline";
+import { API, getToken, startLogin } from "./account.js";
+import { LoginRequired, killAgent, listAgents, result, spawnAgent, waitAgent } from "./client.js";
+
+const PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const VERSION = "0.1.1";
+
+const INSTRUCTIONS = `wisp roda subagentes Claude Code ou Codex em máquinas efêmeras na nuvem, com a RAM que você pedir,
+sem pesar esta máquina. Cada subagente nasce numa enclave isolada (AWS Nitro): antes de mandar qualquer coisa,
+este MCP confere criptograficamente a imagem da enclave e cifra a missão e o login do usuário só para ela.
+Nem o operador do wisp consegue ler a missão, a credencial ou o resultado. A máquina é destruída ao terminar.
+
+Quando usar: o usuário pede subagente remoto / "roda no wisp" / "sobe N subagentes", ou há tarefas
+independentes e pesadas (build, testes, pesquisa longa) que podem rodar em paralelo fora daqui.
+
+Como usar bem:
+- Paralelo: chame spawn_agent para todas as missões primeiro, depois wait_agent para cada id.
+- Para trabalhar no código do usuário, passe workspace (ex.: o diretório do projeto): vai uma cópia cifrada,
+  o subagente trabalha nela e as mudanças voltam como patch (aplique com o comando em "aplicar" depois de revisar).
+  Sem workspace a máquina começa vazia: ponha todo o contexto na missão. Tem internet (HTTPS), mas não tem git/SSH do usuário.
+- A máquina leva ~2-3 min para subir; wait_agent espera até 15 min por chamada (chame de novo se voltar running).
+- Sempre recolha com wait_agent ou agent_result: a resposta só pode ser aberta nesta máquina.
+- Cada subagente consome crédito do wisp (máquina) e a assinatura/chave do usuário (modelo). Não dispare dezenas.
+- Se a resposta disser que é preciso entrar na conta, mostre o link ao usuário.`;
+
+const TOOLS = [
+  { name: "spawn_agent", description: "Sobe um subagente efêmero numa máquina com a RAM pedida e devolve o id na hora.",
+    inputSchema: { type: "object", required: ["mission"], properties: {
+      mission: { type: "string", description: "Missão completa e autocontida, com todo o contexto necessário." },
+      engine: { type: "string", enum: ["claude", "codex"], default: "claude" },
+      model: { type: "string", description: "Modelo do motor. Omitir = padrão dele." },
+      ram_gb: { type: "integer", enum: [2, 4, 8, 16, 24], default: 2, description: "RAM do subagente." },
+      max_turns: { type: "integer", default: 20, description: "Só vale para claude." },
+      timeout_s: { type: "integer", default: 1800, minimum: 60, maximum: 7200 },
+      auth: { type: "string", enum: ["auto", "login", "key"], default: "auto",
+        description: "login = assinatura do usuário nesta máquina; key = chave de API do env; auto = chave se houver." },
+      workspace: { type: "string", description: "Caminho de um diretório/repositório DESTA máquina para mandar junto. Vai uma cópia cifrada (no git: arquivos rastreados + novos não ignorados; nunca o que está no .gitignore). O subagente trabalha em ~/work e as mudanças voltam como patch (patch_file + comando aplicar). Máx. 15 MB compactado." },
+      label: { type: "string", description: "Rótulo curto VISÍVEL no painel (não coloque nada sensível)." } } } },
+  { name: "wait_agent", description: "Espera o subagente terminar e devolve o resultado (campo result = resposta).",
+    inputSchema: { type: "object", required: ["id"], properties: {
+      id: { type: "string" }, max_wait_s: { type: "integer", default: 900, maximum: 1800 } } } },
+  { name: "agent_result", description: "Resultado sem esperar: devolve a resposta ou o status atual (running, RAM em uso).",
+    inputSchema: { type: "object", required: ["id"], properties: { id: { type: "string" } } } },
+  { name: "kill_agent", description: "Mata o subagente e destrói a máquina na hora.",
+    inputSchema: { type: "object", required: ["id"], properties: { id: { type: "string" } } } },
+  { name: "list_agents", description: "Saldo, RAM disponível e subagentes vivos ou com resultado para recolher.",
+    inputSchema: { type: "object", properties: {} } },
+  { name: "wisp_login", description: "Conecta este MCP à conta wisp do usuário (abre o navegador).",
+    inputSchema: { type: "object", properties: {} } },
+];
+
+async function loginMessage() {
+  const l = await startLogin();
+  // com navegador aberto aqui, espera um pouco pela aprovação e segue sozinho
+  if (l.opened) {
+    const ok = await Promise.race([l.done.then(() => true).catch(() => false), new Promise((r) => setTimeout(() => r(false), 120_000))]);
+    if (ok) return null;
+  }
+  return `Para usar o wisp, conecte sua conta: abra ${l.verification_uri_complete} e confirme o código ${l.user_code}.\n` +
+    `Não tem conta? Crie lá mesmo, com crédito grátis. Depois repita o pedido.`;
+}
+
+async function runTool(name, a) {
+  if (name === "wisp_login") {
+    if (getToken()) return { ok: true, msg: `já conectado a ${API}` };
+    const msg = await loginMessage();
+    return msg ? { login_necessario: msg } : { ok: true, msg: "conta conectada" };
+  }
+  const attempt = () => {
+    switch (name) {
+      case "spawn_agent": return spawnAgent(a);
+      case "wait_agent": return waitAgent(a.id, a.max_wait_s ?? 900);
+      case "agent_result": return result(a.id);
+      case "kill_agent": return killAgent(a.id);
+      case "list_agents": return listAgents();
+      default: throw new Error(`ferramenta desconhecida: ${name}`);
+    }
+  };
+  try {
+    if (!getToken()) throw new LoginRequired();
+    return await attempt();
+  } catch (e) {
+    if (!(e instanceof LoginRequired) && e.status !== 401) throw e;
+    const msg = await loginMessage();
+    if (msg) return { login_necessario: msg };
+    return await attempt();
+  }
+}
+
+export function serve() {
+  const send = (m) => process.stdout.write(JSON.stringify(m) + "\n");
+  const rl = createInterface({ input: process.stdin });
+  rl.on("line", async (line) => {
+    let msg;
+    try { msg = JSON.parse(line); } catch { return; }
+    const { id, method, params } = msg;
+    if (id === undefined) return;                              // notificações
+    try {
+      let res;
+      if (method === "initialize") {
+        const v = PROTOCOLS.includes(params?.protocolVersion) ? params.protocolVersion : PROTOCOLS[0];
+        res = { protocolVersion: v, capabilities: { tools: {} }, serverInfo: { name: "ramwisp", version: VERSION }, instructions: INSTRUCTIONS };
+      } else if (method === "tools/list") {
+        res = { tools: TOOLS };
+      } else if (method === "ping") {
+        res = {};
+      } else if (method === "tools/call") {
+        try {
+          const out = await runTool(params.name, params.arguments ?? {});
+          res = { content: [{ type: "text", text: typeof out === "string" ? out : JSON.stringify(out, null, 1) }] };
+        } catch (e) {
+          res = { content: [{ type: "text", text: `erro: ${e.message}` }], isError: true };
+        }
+      } else {
+        return send({ jsonrpc: "2.0", id, error: { code: -32601, message: `método desconhecido: ${method}` } });
+      }
+      send({ jsonrpc: "2.0", id, result: res });
+    } catch (e) {
+      send({ jsonrpc: "2.0", id, error: { code: -32603, message: e.message } });
+    }
+  });
+}