ramwisp 0.1.2 → 0.1.4

package/README.md

@@ -1,12 +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.
+Claude Code and Codex subagents on their own cloud machines, with the RAM they need.
+Every subagent runs inside an ephemeral AWS Nitro Enclave: before sending anything, this MCP verifies the
+hardware attestation (AWS Nitro Enclaves Root G1 + published PCR0) and encrypts the task, the project and the
+credential for that enclave only.
 
 ```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
+On first use it opens your browser so you can sign in. More at https://ramwisp.duckdns.org

package/bin/wisp.js

@@ -8,38 +8,38 @@ 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})
+const HELP = `ramwisp — subagents with on-demand RAM (${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
+  ramwisp login                      connect this machine to your account (browser)
+  ramwisp logout
+  ramwisp spawn "task" [--ram 2] [--engine claude|codex] [--model M] [--auth auto|login|key] [--workspace DIR] [--wait]
+  ramwisp wait ID | result ID | kill ID
+  ramwisp ls
+  ramwisp setup                      how to add the MCP to Claude Code / Codex
 
-Sem argumentos roda o servidor MCP (stdio).`;
+With no arguments it runs the MCP server (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)`);
+      if (getToken()) return console.log(`already connected to ${API} (ramwisp logout to switch)`);
       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}`);
+      console.log(`${l.opened ? "Opened your browser. If it didn't open, visit" : "Open"}: ${l.verification_uri_complete}\nCode: ${l.user_code}`);
       await l.done;
-      return console.log("conectado ✓");
+      return console.log("connected ✓");
     }
-    case "logout": logout(); return console.log("desconectado");
+    case "logout": logout(); return console.log("disconnected");
     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…");
+      console.error("waiting for the machine and its attestation to send the sealed task…");
       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 (now.error || ["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}`);
+      return console.error(`task delivered. Collect it with: ramwisp wait ${r.id}`);
     }
     case "wait": return out(await waitAgent(rest[0], Number(flag("max", 3600))));
     case "result": return out(await result(rest[0]));
@@ -52,4 +52,4 @@ async function main() {
   }
 }
 
-main().catch((e) => { console.error("erro:", e.message); process.exit(1); });
+main().catch((e) => { console.error("error:", e.message); process.exit(1); });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ramwisp",
-  "version": "0.1.2",
-  "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.",
+  "version": "0.1.4",
+  "description": "ramwisp: Claude Code and Codex subagents on their own cloud machines (AWS Nitro Enclaves), with your own subscription. MCP + CLI.",
   "type": "module",
   "bin": {
     "ramwisp": "bin/wisp.js",

package/src/account.js

@@ -36,10 +36,14 @@ export function logout() {
   if (existsSync(CRED)) rmSync(CRED);
 }
 
+let client = "cli";
+/** Quem está usando o MCP (vem do clientInfo do initialize: "claude-code", "codex-mcp-client"…). */
+export function setClient(name) { if (name) client = String(name).slice(0, 60); }
+
 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}` } : {}) },
+    headers: { "Content-Type": "application/json", "X-Wisp-Client": client, ...(token ? { Authorization: `Bearer ${token}` } : {}) },
     body: body === undefined ? undefined : JSON.stringify(body),
     signal: AbortSignal.timeout(timeoutMs),
   });

package/src/attest.js

@@ -22,44 +22,44 @@ export function allowedPcr0() {
  */
 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");
+  if (!Array.isArray(doc) || doc.length !== 4) throw new Error("attestation: not a 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");
+  if (!(prot instanceof Map) || prot.get(1) !== -35) throw new Error("attestation: algorithm is not 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; };
+  const get = (k) => { const v = p.get(k); if (v === undefined || v === null) throw new Error(`attestation: missing ${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");
+  if (!bundle.length || !bundle[0].raw.equals(root.raw)) throw new Error("attestation: root is not 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`);
+    if (!cert.verify(issuer.publicKey)) throw new Error(`attestation: certificate ${i} signature invalid`);
+    if (at < new Date(cert.validFrom) || at > new Date(cert.validTo)) throw new Error(`attestation: certificate ${i} outside its validity`);
+    if (i < chain.length - 1 && !cert.ca) throw new Error(`attestation: certificate ${i} is not a 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 (!ok) throw new Error("attestation: invalid COSE signature");
 
-  if (get("digest") !== "SHA384") throw new Error("atestação: digest inesperado");
+  if (get("digest") !== "SHA384") throw new Error("attestation: unexpected digest");
   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?)");
+  if (Math.abs(Date.now() - ts) > MAX_AGE_MS) throw new Error("attestation: too old or from the future");
+  if (!Buffer.from(get("nonce")).equals(expectedNonce)) throw new Error("attestation: nonce mismatch (replay?)");
   const ud = p.get("user_data");
-  if (!ud || Buffer.from(ud).toString() !== "wisp-v1") throw new Error("atestação: protocolo desconhecido");
+  if (!ud || Buffer.from(ud).toString() !== "wisp-v1") throw new Error("attestation: unknown protocol");
   const enclavePub = Buffer.from(get("public_key"));
-  if (enclavePub.length !== 32) throw new Error("atestação: chave pública inválida");
+  if (enclavePub.length !== 32) throw new Error("attestation: invalid public key");
 
   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");
+  if (/^0+$/.test(pcr0)) throw new Error("attestation: enclave in debug mode (zero PCR0) — refused");
   const allowed = dev ? [DEV_PCR0] : allowedPcr0();
-  if (!allowed.includes(pcr0)) throw new Error(`atestação: imagem não reconhecida (PCR0 ${pcr0.slice(0, 16)}…)`);
+  if (!allowed.includes(pcr0)) throw new Error(`attestation: unrecognized image (PCR0 ${pcr0.slice(0, 16)}…)`);
   return { enclavePub, pcr0, moduleId: get("module_id"), timestamp: ts, dev };
 }

package/src/client.js

@@ -21,7 +21,7 @@ const SKIP_DIRS = new Set(["node_modules", ".git", ".venv", "venv", "__pycache__
 /** 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}`);
+  if (!existsSync(root) || !statSync(root).isDirectory()) throw new Error(`workspace is not a directory: ${root}`);
   let files;
   const git = spawnSync("git", ["-C", root, "ls-files", "-z", "-co", "--exclude-standard"], { maxBuffer: 256 * 1024 * 1024 });
   if (git.status === 0) {
@@ -41,8 +41,8 @@ export function packWorkspace(dir) {
   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");
+    throw new Error(`project too large (${(tar.stdout.length / 1048576).toFixed(1)} MB compressed, max 15 MB): ` +
+      "point workspace at a subdirectory or ignore heavy files in .gitignore");
   }
   return { root, tgz: tar.stdout, files: files.length };
 }
@@ -56,7 +56,7 @@ export async function spawnAgent(o) {
   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)`;
+    note = `timeout lowered to ${timeout}s (local login validity)`;
   }
   const ws = o.workspace ? packWorkspace(o.workspace) : null;
   const priv = newClientKey();
@@ -72,7 +72,7 @@ export async function spawnAgent(o) {
   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)` } : {}),
+    ...(ws ? { workspace: `${ws.root} (${ws.files} files, ${(ws.tgz.length / 1024).toFixed(0)} KB, encrypted)` } : {}),
     ...(note ? { note } : {}) };
 }
 
@@ -98,7 +98,7 @@ async function sealWhenReady(id, priv, nonce, payload) {
     }
     await new Promise((r) => setTimeout(r, 2000));
   }
-  throw new Error("a máquina não ficou pronta em 20 min");
+  throw new Error("the machine was not ready within 20 min");
 }
 
 /** Espera a selagem terminar (útil para o CLI, que sai logo depois). */
@@ -130,31 +130,31 @@ function parseOutput(stdout) {
 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 (sealErrors.has(id)) return { ...meta, status: "failed", error: `refused for security: ${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) };
+    return { ...meta, error: j.error ?? (j.collected_at ? "result was already collected" : j.status) };
   }
   const f = keyFile(id);
-  if (!existsSync(f)) return { ...meta, erro: "a chave para abrir esse resultado não está nesta máquina" };
+  if (!existsSync(f)) return { ...meta, error: "the key to open this result is not on this machine" };
   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.exit_code === 124) res.error = "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)}`;
+    res.apply = 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";
+    res.patch_stat = "no changes to the project";
   } else if (out.patch_error) {
-    res.patch_erro = out.patch_error;
+    res.patch_error = 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);
@@ -165,7 +165,7 @@ 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;
+    if (FINAL.includes(r.status) || r.error || Date.now() > until) return r;
     await new Promise((res) => setTimeout(res, 3000));
   }
 }
@@ -179,9 +179,9 @@ export async function killAgent(id) {
 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) => ({
+    account: me.email, balance_usd: +(me.credit_cents / 100).toFixed(2),
+    ram_available_gb: me.tiers.filter((t) => t.available).map((t) => t.ram_gb),
+    agents: 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

@@ -24,8 +24,8 @@ function claudeLogin() {
 
 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 (mode !== "login" && key) return { kind: "anthropic_key", value: key, left: null, source: "API key" };
+  if (mode === "key") throw new Error("key mode: set ANTHROPIC_API_KEY (or WISP_ANTHROPIC_API_KEY) in the MCP env");
   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)) {
@@ -33,30 +33,30 @@ function claudeCredential(mode, needS) {
     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)");
+  if (!l) throw new Error("no Claude Code login on this machine: run `claude` and sign in, or use a key (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" };
+  if (left < MIN_LEFT_S) throw new Error("the local Claude login did not refresh; open Claude Code once and try again");
+  return { kind: "claude_oauth", value: l.token, left, source: "Claude Code login" };
 }
 
 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" };
+  if (mode !== "login" && key) return { kind: "openai_key", value: key, left: null, source: "API key" };
   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`");
+    throw new Error(mode === "key" ? "key mode: set OPENAI_API_KEY in the MCP env" : "no Codex login on this machine: run `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");
+  if (mode !== "login" && d.OPENAI_API_KEY) return { kind: "openai_key", value: d.OPENAI_API_KEY, left: null, source: "Codex API key" };
+  if (mode === "key") throw new Error("key mode: set OPENAI_API_KEY in the MCP env");
   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");
+  if (left < MIN_LEFT_S) throw new Error("the Codex login expired; open Codex once on this machine");
   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" };
+  return { kind: "codex_auth", value: JSON.stringify(slim), left, source: "ChatGPT/Codex login" };
 }
 
 /** mode: "auto" (chave se houver, senão login), "key" ou "login". */

package/src/mcp.js

@@ -1,71 +1,71 @@
 // Servidor MCP (stdio, JSON-RPC por linha). Sem dependências.
 import { createInterface } from "node:readline";
-import { API, getToken, startLogin } from "./account.js";
+import { API, getToken, setClient, 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.2";
+const VERSION = "0.1.4";
 
-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.
+const INSTRUCTIONS = `ramwisp runs Claude Code or Codex subagents on ephemeral cloud machines with the RAM you ask for,
+without loading this machine. Each subagent starts inside an isolated enclave (AWS Nitro): before sending anything,
+this MCP cryptographically verifies the enclave image and encrypts the task and the user's login for that enclave only.
+Not even the ramwisp operator can read the task, the credential or the result. The machine is destroyed when it finishes.
 
-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.
+When to use: the user asks for remote subagents / "run it on ramwisp" / "spin up N subagents", or there are
+independent, heavy tasks (builds, test suites, long research) that can run in parallel elsewhere.
 
-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.`;
+How to use it well:
+- Parallel: call spawn_agent for every task first, then wait_agent for each id.
+- To work on the user's code, pass workspace (e.g. the project directory): an encrypted copy is sent,
+  the subagent works on it and the changes come back as a patch (apply it with the "apply" command after reviewing).
+  Without workspace the machine starts empty: put all context in the mission. It has internet (HTTPS) but no git/SSH access of the user.
+- A machine takes ~1-3 min to start; wait_agent waits up to 15 min per call (call it again if it returns running).
+- Always collect with wait_agent or agent_result: the answer can only be decrypted on this machine.
+- Each subagent uses ramwisp credit (the machine) and the user's subscription/key (the model). Don't launch dozens.
+- If a response says the user needs to sign in, show them the link.`;
 
 const TOOLS = [
-  { name: "spawn_agent", description: "Sobe um subagente efêmero numa máquina com a RAM pedida e devolve o id na hora.",
+  { name: "spawn_agent", description: "Launch an ephemeral subagent on a machine with the requested RAM and return its id right away.",
     inputSchema: { type: "object", required: ["mission"], properties: {
-      mission: { type: "string", description: "Missão completa e autocontida, com todo o contexto necessário." },
+      mission: { type: "string", description: "Complete, self-contained task with all the context it needs." },
       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." },
+      model: { type: "string", description: "Model for the engine. Omit for its default." },
+      ram_gb: { type: "integer", enum: [2, 4, 8, 16, 24], default: 2, description: "Subagent RAM." },
+      max_turns: { type: "integer", default: 20, description: "Claude only." },
       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).",
+        description: "login = the user's subscription on this machine; key = API key from env; auto = key if present." },
+      workspace: { type: "string", description: "Path to a directory/repo ON THIS MACHINE to send along. An encrypted copy is sent (in git: tracked files + new non-ignored files; never anything in .gitignore). The subagent works in ~/work and changes come back as a patch (patch_file + apply command). Max 15 MB compressed." },
+      label: { type: "string", description: "Short label VISIBLE in the dashboard (don't put anything sensitive)." } } } },
+  { name: "wait_agent", description: "Wait for the subagent to finish and return the result (field result = the answer).",
     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).",
+  { name: "agent_result", description: "Result without waiting: returns the answer or the current status (running, RAM in use).",
     inputSchema: { type: "object", required: ["id"], properties: { id: { type: "string" } } } },
-  { name: "kill_agent", description: "Mata o subagente e destrói a máquina na hora.",
+  { name: "kill_agent", description: "Kill the subagent and destroy its machine immediately.",
     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.",
+  { name: "list_agents", description: "Balance, available RAM sizes and subagents that are running or have results to collect.",
     inputSchema: { type: "object", properties: {} } },
-  { name: "wisp_login", description: "Conecta este MCP à conta wisp do usuário (abre o navegador).",
+  { name: "wisp_login", description: "Connect this MCP to the user's ramwisp account (opens the browser).",
     inputSchema: { type: "object", properties: {} } },
 ];
 
 async function loginMessage() {
   const l = await startLogin();
-  // com navegador aberto aqui, espera um pouco pela aprovação e segue sozinho
+  // with a browser open here, wait a bit for approval and continue on its own
   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.`;
+  return `To use ramwisp, connect your account: open ${l.verification_uri_complete} and confirm the code ${l.user_code}.\n` +
+    `No account yet? Create one there, with free credit. Then repeat the request.`;
 }
 
 async function runTool(name, a) {
   if (name === "wisp_login") {
-    if (getToken()) return { ok: true, msg: `já conectado a ${API}` };
+    if (getToken()) return { ok: true, msg: `already connected to ${API}` };
     const msg = await loginMessage();
-    return msg ? { login_necessario: msg } : { ok: true, msg: "conta conectada" };
+    return msg ? { login_required: msg } : { ok: true, msg: "account connected" };
   }
   const attempt = () => {
     switch (name) {
@@ -74,7 +74,7 @@ async function runTool(name, a) {
       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}`);
+      default: throw new Error(`unknown tool: ${name}`);
     }
   };
   try {
@@ -83,7 +83,7 @@ async function runTool(name, a) {
   } catch (e) {
     if (!(e instanceof LoginRequired) && e.status !== 401) throw e;
     const msg = await loginMessage();
-    if (msg) return { login_necessario: msg };
+    if (msg) return { login_required: msg };
     return await attempt();
   }
 }
@@ -99,6 +99,7 @@ export function serve() {
     try {
       let res;
       if (method === "initialize") {
+        setClient(params?.clientInfo?.name ?? "mcp");
         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") {
@@ -110,10 +111,10 @@ export function serve() {
           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 };
+          res = { content: [{ type: "text", text: `error: ${e.message}` }], isError: true };
         }
       } else {
-        return send({ jsonrpc: "2.0", id, error: { code: -32601, message: `método desconhecido: ${method}` } });
+        return send({ jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${method}` } });
       }
       send({ jsonrpc: "2.0", id, result: res });
     } catch (e) {