airgate 0.1.2 → 0.1.4

package/README.md

@@ -37,10 +37,13 @@ with the result back here, or the whole project and conversation up and back.
 airgate run "get the failing tests passing"   # a fresh pod; the result comes back as a patch
 airgate skill install                         # teach Claude Code when and how to use airgate
 claude mcp add airgate -- airgate mcp         # airgate as tools (pod_run, pod_up, pod_down…)
-claude setup-token                            # then: airgate secrets set CLAUDE_CODE_OAUTH_TOKEN
+airgate models connect claude --laptop        # a token from `claude setup-token`, kept on this laptop
+airgate models connect chatgpt --laptop       # or Codex on your ChatGPT plan
 ```
 
-The last line signs Claude Code in for every pod, so tasks run without a login each time.
+The last line lets this laptop sign the pods' model calls while airgate runs, so tasks run without
+a login in each pod and airgate never holds your sign-in. Or keep one on airgate so pods work while
+the laptop is off: `airgate models connect claude`. Guide: https://airgate.sh/docs/model-sign-in
 Guide: https://airgate.sh/docs/local-agents
 
 ## Links

package/dist/airgate.mjs

@@ -301,6 +301,72 @@ function dotenvExample(names) {
   return names.map((n2) => `${n2}=`).join("\n") + (names.length ? "\n" : "");
 }
 
+// ../sandbox/src/chatgpt.ts
+var CHATGPT_CODEX_BASE = "https://chatgpt.com/backend-api/codex";
+var CHATGPT_TOKEN_URL = "https://auth.openai.com/oauth/token";
+var CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+function jwtClaims(token) {
+  const part = token?.split(".")[1];
+  if (!part) return null;
+  try {
+    const b64 = part.replace(/-/g, "+").replace(/_/g, "/");
+    const bin = atob(b64 + "=".repeat((4 - b64.length % 4) % 4));
+    return JSON.parse(new TextDecoder().decode(Uint8Array.from(bin, (c) => c.charCodeAt(0))));
+  } catch {
+    return null;
+  }
+}
+function accountIdOf(t) {
+  if (typeof t.account_id === "string" && t.account_id) return t.account_id;
+  const auth = jwtClaims(typeof t.id_token === "string" ? t.id_token : void 0)?.["https://api.openai.com/auth"];
+  return typeof auth?.chatgpt_account_id === "string" ? auth.chatgpt_account_id : null;
+}
+function parseChatgptLogin(text2) {
+  let j;
+  try {
+    j = JSON.parse(text2);
+  } catch {
+    throw new Error("not a Codex login: expected the auth.json that `codex login` writes");
+  }
+  const t = j.tokens && typeof j.tokens === "object" ? j.tokens : j;
+  if (typeof t.access_token !== "string" || typeof t.refresh_token !== "string") {
+    throw new Error("this Codex login has no ChatGPT tokens: sign in with ChatGPT in `codex login`, not an API key");
+  }
+  const account = accountIdOf(t);
+  if (!account) throw new Error("this Codex login doesn't name a ChatGPT account");
+  return { access_token: t.access_token, refresh_token: t.refresh_token, id_token: typeof t.id_token === "string" ? t.id_token : void 0, account_id: account };
+}
+function chatgptNeedsRefresh(t, now = Date.now(), windowMs = 5 * 6e4) {
+  const exp = jwtClaims(t.access_token)?.exp;
+  return typeof exp !== "number" || exp * 1e3 - now < windowMs;
+}
+async function refreshChatgpt(t, o = {}) {
+  const res = await (o.fetch ?? fetch)(o.tokenUrl ?? CHATGPT_TOKEN_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ client_id: CODEX_CLIENT_ID, grant_type: "refresh_token", refresh_token: t.refresh_token, scope: "openid profile email" }),
+    signal: AbortSignal.timeout(45e3)
+  });
+  if (!res.ok) {
+    const why = await res.text().catch(() => "");
+    throw new Error(
+      res.status === 400 || res.status === 401 ? "the ChatGPT sign-in expired or was revoked: connect it again (airgate models connect chatgpt)" : `couldn't renew the ChatGPT sign-in (${res.status}${why ? `: ${why.slice(0, 120)}` : ""})`
+    );
+  }
+  const r = await res.json();
+  if (!r.access_token) throw new Error("renewing the ChatGPT sign-in returned no access token");
+  return { ...t, access_token: r.access_token, refresh_token: r.refresh_token ?? t.refresh_token, id_token: r.id_token ?? t.id_token };
+}
+function chatgptUrl(path, base = CHATGPT_CODEX_BASE) {
+  return base + path.replace(/^\/?v1(?=\/|$)/, "").replace(/^(?!\/)/, "/");
+}
+function signChatgpt(t, headers) {
+  delete headers["x-api-key"];
+  headers.authorization = `Bearer ${t.access_token}`;
+  headers["chatgpt-account-id"] = t.account_id;
+  headers.originator ??= "codex_cli_rs";
+}
+
 // src/api.ts
 var UPLOAD_PART = 6 * 1024 * 1024;
 var ApiError = class extends Error {
@@ -514,6 +580,20 @@ var Api = class {
   githubDisconnect(id) {
     return this.request("DELETE", `/v1/github/installations/${id}`);
   }
+  /* model sign-ins: connected to airgate (opt-in), and whether a laptop relay is connected */
+  modelsAuth() {
+    return this.request("GET", "/v1/models/auth");
+  }
+  connectModel(vendor, value, kind) {
+    return this.request("PUT", `/v1/models/auth/${enc(vendor)}`, { body: { value, ...kind ? { kind } : {} } });
+  }
+  disconnectModel(vendor) {
+    return this.request("DELETE", `/v1/models/auth/${enc(vendor)}`);
+  }
+  relayUrl() {
+    const q = new URLSearchParams({ token: this.tokenForUrl(), client: this.client });
+    return `${this.gateway.replace(/^http/, "ws")}/v1/relay?${q}`;
+  }
   secrets() {
     return this.request("GET", "/v1/secrets");
   }
@@ -4374,8 +4454,8 @@ function linked(s2, j, b2, ascii) {
   }
   return m;
 }
-function place3(s2, j, c, k, join6, a = ARMS.get(c), ascii = false, round = false) {
-  if (join6 && a !== void 0) {
+function place3(s2, j, c, k, join8, a = ARMS.get(c), ascii = false, round = false) {
+  if (join8 && a !== void 0) {
     const old = s2.chars[j], b2 = ascii ? asciiArms(old) : ARMS.get(old);
     if (b2 !== void 0) {
       const kept = linked(s2, j, b2, ascii);
@@ -4541,7 +4621,7 @@ function rect(s2, x, y, w, h, o) {
   if (title)
     for (const ch of title)
       code(ch);
-  const join6 = yes(o?.join, "join", true);
+  const join8 = yes(o?.join, "join", true);
   const k = paint(s2, color), fk = fillColor === void 0 ? k : paint(s2, fillColor);
   if (!finite3(x, y, w, h))
     return { x: 0, y: 0, cols: 0, rows: 0 };
@@ -4564,7 +4644,7 @@ function rect(s2, x, y, w, h, o) {
     const put = (cx, cy, e, reach = 255) => {
       const j = s2.index(cx, cy), a = ascii ? EDGE_ARMS[e] : ARMS.get(ed[e]);
       if (j >= 0)
-        place3(s2, j, ed[e], k, join6, a === void 0 ? a : a & reach, ascii, round);
+        place3(s2, j, ed[e], k, join8, a === void 0 ? a : a & reach, ascii, round);
     };
     const end = (i, n2, first, last) => n2 < 2 ? 255 : i === 0 ? 3 << first : i === n2 - 1 ? 3 << last : 255;
     const from = (o2, lo) => Math.max(lo, -o2), to = (o2, hi, n2) => Math.min(hi, n2 - o2);
@@ -4700,11 +4780,11 @@ function shape(s2, cx, cy, rx, ry, o, what, from = 0, span = 1) {
   const ch = char === "auto" ? "auto" : brush(char, `${/^[aeiou]/.test(what) ? "an" : "a"} ${what}'s char`);
   const f = fill === void 0 || fill === false ? null : brush(fill, "fill");
   const k = paint(s2, color), fk = fillColor === void 0 ? k : paint(s2, fillColor);
-  const join6 = yes(o?.join, "join", true);
+  const join8 = yes(o?.join, "join", true);
   ellipseCells(s2.cols, s2.rows, cx, cy, rx, ry, f !== null, (x, y, edge, slope) => {
     const j = y * s2.cols + x;
     if (edge)
-      place3(s2, j, ch === "auto" ? slope : ch, k, join6 && ch !== "auto");
+      place3(s2, j, ch === "auto" ? slope : ch, k, join8 && ch !== "auto");
     else
       s2.put(j, f, f === EMPTY ? NONE : fk);
   }, ch === "auto" ? s2.aspect : 0, from, span);
@@ -7019,14 +7099,14 @@ async function readAll2(stream) {
   for await (const c of stream) s2 += c.toString();
   return s2;
 }
-async function readValue(ctx, name) {
+async function readValue(ctx, name, pipeHint = `printf %s "$VALUE" | airgate secrets set ${name}`) {
   if (ctx.io.stdin.isTTY) {
     const v2 = await ctx.io.prompt(`value for ${name} (hidden): `, { hidden: true });
     if (!v2) throw new CliError("empty value, nothing saved");
     return v2;
   }
   const v = (await readAll2(ctx.io.stdin)).replace(/\r?\n$/, "");
-  if (!v) throw new CliError("no value on stdin", `printf %s "$VALUE" | airgate secrets set ${name}`);
+  if (!v) throw new CliError("no value on stdin", pipeHint);
   return v;
 }
 function parseDotenv2(text2) {
@@ -7648,7 +7728,7 @@ var log = {
 import { createInterface } from "node:readline";
 
 // src/version.ts
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 
 // src/commands/updown.ts
 import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
@@ -7657,7 +7737,7 @@ import { basename, dirname as dirname2, isAbsolute, join as join4, relative as r
 
 // src/pack.ts
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, lstatSync } from "node:fs";
+import { existsSync, lstatSync, readdirSync } from "node:fs";
 import { join as join2 } from "node:path";
 var UPLOAD_LIMIT = 32 * 6 * 1024 * 1024;
 var TooLargeError = class extends Error {
@@ -7667,6 +7747,11 @@ var TooLargeError = class extends Error {
     this.limit = limit;
   }
 };
+function isEnvFile(path) {
+  const name = path.split("/").pop() ?? "";
+  return /^\.env($|\.)/.test(name) && !/\.(example|sample|template|dist|defaults?|schema)$/.test(name);
+}
+var ENV_EXCLUDES = [".env", ".env.local", ".env.*.local", ".env.development", ".env.production", ".env.test", ".env.staging", ".envrc"].map((p) => `--exclude=${p}`);
 function git(cwd, args, input) {
   const r = spawnSync("git", args, { cwd, input, maxBuffer: 256 * 1024 * 1024 });
   return { status: r.status ?? (r.error ? 127 : 1), stdout: r.stdout?.toString("utf8") ?? "", stderr: r.stderr?.toString("utf8") ?? "", error: r.error };
@@ -7723,13 +7808,17 @@ function runTar(cwd, args, input, limit = UPLOAD_LIMIT) {
 }
 async function packProject(dir, limit = UPLOAD_LIMIT) {
   if (isGitRepo(dir)) {
-    const files = gitFiles(dir).filter((f) => !f.startsWith(".airgate/"));
+    const tracked = new Set(git(dir, ["ls-files", "-c", "-z"]).stdout.split("\0"));
+    const all = gitFiles(dir).filter((f) => !f.startsWith(".airgate/"));
+    const skipped2 = all.filter((f) => (isEnvFile(f) || f.split("/").pop() === ".envrc") && !tracked.has(f));
+    const files = all.filter((f) => !skipped2.includes(f));
     if (!files.length) throw new Error("no files to send (git sees nothing tracked or untracked here)");
     const archive2 = await runTar(dir, ["--null", "-T", "-", "-czf", "-"], files.join("\0") + "\0", limit);
-    return { archive: archive2, files: files.length, git: true };
+    return { archive: archive2, files: files.length, git: true, skipped: skipped2 };
   }
-  const archive = await runTar(dir, ["--exclude=node_modules", "--exclude=.git", "--exclude=.airgate", "-czf", "-", "."], null, limit);
-  return { archive, files: -1, git: false };
+  const skipped = readdirSync(dir).filter((f) => isEnvFile(f) || f === ".envrc");
+  const archive = await runTar(dir, ["--exclude=node_modules", "--exclude=.git", "--exclude=.airgate", ...ENV_EXCLUDES, "-czf", "-", "."], null, limit);
+  return { archive, files: -1, git: false, skipped };
 }
 var CLAUDE_CONFIG = ["settings.json", "CLAUDE.md", "skills", "agents", "commands"];
 async function packClaudeConfig(home, limit = UPLOAD_LIMIT) {
@@ -7751,7 +7840,7 @@ import { gunzipSync } from "node:zlib";
 
 // src/sessions.ts
 import { createHash, randomUUID } from "node:crypto";
-import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync, openSync, readdirSync, readFileSync as readFileSync4, readSync, realpathSync, renameSync as renameSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, mkdtempSync, openSync, readdirSync as readdirSync2, readFileSync as readFileSync4, readSync, realpathSync, renameSync as renameSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join as join3, relative } from "node:path";
 var POD_HOME = "/home/sprite";
@@ -7779,7 +7868,7 @@ function findClaudeSession(home, projectDir, id, env = {}) {
     const dir = join3(claudeHome(home, env), "projects", claudeKey(p));
     let names = [];
     try {
-      names = readdirSync(dir).filter((n2) => n2.endsWith(".jsonl"));
+      names = readdirSync2(dir).filter((n2) => n2.endsWith(".jsonl"));
     } catch {
       continue;
     }
@@ -7810,7 +7899,7 @@ function codexRollouts(root, limit = 3e3) {
   const walk = (d, depth) => {
     let list2 = [];
     try {
-      list2 = readdirSync(d, { withFileTypes: true });
+      list2 = readdirSync2(d, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7865,7 +7954,7 @@ async function packSession(s2, projectDir, podPath, limit = UPLOAD_LIMIT) {
       names.push(`${s2.id}.jsonl`);
       if (s2.sidecar) {
         const copy2 = (src, dst) => {
-          for (const x of readdirSync(src, { withFileTypes: true })) {
+          for (const x of readdirSync2(src, { withFileTypes: true })) {
             const a = join3(src, x.name);
             const b2 = join3(dst, x.name);
             if (x.isDirectory()) {
@@ -8279,10 +8368,11 @@ var up = {
     const state = { gateway: ctx.cfg.gateway, podId: pod.id, podName: pod.spec.name, dir: podDir, at: Date.now(), ...sent.length ? { sessions: sent } : {} };
     writeState(projectDir, state);
     if (ctx.json) {
-      return ui2.json({ pod, dir: podDir, bytes: packed.archive.length, files: packed.files, config: config?.parts ?? [], baseSet: based, sessions: resumed, secrets: envSent });
+      return ui2.json({ pod, dir: podDir, bytes: packed.archive.length, files: packed.files, skipped: packed.skipped, config: config?.parts ?? [], baseSet: based, sessions: resumed, secrets: envSent });
     }
     ui2.out(`${ui2.c("ok", "up")}: ${name} \u2192 ${pod.spec.name}:~/${podDir} \xB7 ${packed.files >= 0 ? `${packed.files} files, ` : ""}${bytes(packed.archive.length)}`);
     if (config) ui2.out(`config: ~/.claude/{${config.parts.join(",")}}`);
+    if (packed.skipped.length) ui2.out(ui2.c("dim", `kept here: ${packed.skipped.join(", ")} (env files go to a pod only as secrets: --env${packed.skipped.includes(".env") ? "" : " <file>"})`));
     if (!based) ui2.err(ui2.ce("warn", "couldn't set the down base; the first down will include the files you sent"));
     if (envSent) {
       ui2.out(`secrets for ${pod.spec.name}: ${envSent.sent.length ? envSent.sent.join(", ") : "none"}${envSent.skipped.length ? ui2.c("dim", ` (skipped: ${envSent.skipped.join(", ")})`) : ""}`);
@@ -8641,22 +8731,352 @@ async function runCommand(ctx, cmd, argv, cwd) {
 }
 
 // src/commands/run.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync8, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { basename as basename2, resolve as resolve5 } from "node:path";
 import { randomBytes } from "node:crypto";
-var SIGN_IN = {
-  "claude-code": { names: ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"], fix: "claude setup-token (on this laptop), then: airgate secrets set CLAUDE_CODE_OAUTH_TOKEN" },
-  codex: { names: ["OPENAI_API_KEY"], fix: "airgate secrets set OPENAI_API_KEY (or sign in to codex once in a pod you keep)" }
+
+// src/relay.ts
+import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+function vendorOf(name) {
+  const n2 = (name ?? "").toLowerCase();
+  if (n2 === "claude" || n2 === "anthropic" || n2 === "claude-code") return "anthropic";
+  if (n2 === "openai" || n2 === "codex" || n2 === "chatgpt") return "openai";
+  return null;
+}
+var vendorLabel = (v) => v === "anthropic" ? "Claude" : "OpenAI";
+var kindOf = (v, value) => v === "anthropic" && value.startsWith("sk-ant-oat") ? "oauth_token" : "api_key";
+var modelsPath = (env) => join5(configDir(env), "models.json");
+function readSaved(env) {
+  try {
+    return JSON.parse(readFileSync6(modelsPath(env), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveLocal(env, vendor, value, kind = value ? kindOf(vendor, value) : "api_key") {
+  const all = readSaved(env);
+  if (value) all[vendor] = { kind, value };
+  else delete all[vendor];
+  const dir = configDir(env);
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  const file = modelsPath(env);
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync4(tmp, JSON.stringify(all, null, 2) + "\n", { mode: 384 });
+  chmodSync2(tmp, 384);
+  renameSync3(tmp, file);
+  chmodSync2(file, 384);
+}
+function hasSavedFile(env) {
+  return existsSync4(modelsPath(env));
+}
+function localAuth(env) {
+  const saved = readSaved(env);
+  const out = {};
+  if (env.CLAUDE_CODE_OAUTH_TOKEN) out.anthropic = { kind: "oauth_token", value: env.CLAUDE_CODE_OAUTH_TOKEN, from: "CLAUDE_CODE_OAUTH_TOKEN" };
+  else if (env.ANTHROPIC_API_KEY) out.anthropic = { kind: "api_key", value: env.ANTHROPIC_API_KEY, from: "ANTHROPIC_API_KEY" };
+  else if (saved.anthropic) out.anthropic = { ...saved.anthropic, from: "this laptop" };
+  if (env.OPENAI_API_KEY) out.openai = { kind: "api_key", value: env.OPENAI_API_KEY, from: "OPENAI_API_KEY" };
+  else if (saved.openai) out.openai = { ...saved.openai, from: "this laptop" };
+  return out;
+}
+function sign(vendor, auth, headers) {
+  if (vendor === "openai") {
+    headers.authorization = `Bearer ${auth.value}`;
+    return;
+  }
+  if (auth.kind === "oauth_token") {
+    delete headers["x-api-key"];
+    headers.authorization = `Bearer ${auth.value}`;
+    const beta = (headers["anthropic-beta"] ?? "").split(",").map((s2) => s2.trim()).filter(Boolean);
+    if (!beta.includes("oauth-2025-04-20")) beta.push("oauth-2025-04-20");
+    headers["anthropic-beta"] = beta.join(",");
+  } else {
+    delete headers.authorization;
+    headers["x-api-key"] = auth.value;
+  }
+}
+var UPSTREAM = { anthropic: "https://api.anthropic.com", openai: "https://api.openai.com" };
+async function chatgptReady(io, auth, f) {
+  const t = JSON.parse(auth.value);
+  if (!chatgptNeedsRefresh(t)) return t;
+  const fresh = await refreshChatgpt(t, { fetch: f, tokenUrl: io.env.AIRGATE_RELAY_CHATGPT_TOKEN_URL || void 0 });
+  auth.value = JSON.stringify(fresh);
+  if (auth.from === "this laptop") saveLocal(io.env, "openai", auth.value, "chatgpt");
+  return fresh;
+}
+function startRelay(o) {
+  const vendors = Object.keys(o.auth).filter((v) => o.auth[v]);
+  const inflight = /* @__PURE__ */ new Map();
+  let ws = null;
+  let stopped = false;
+  let signed = 0;
+  let attempt = 0;
+  let resolveDone;
+  const done = new Promise((r) => resolveDone = r);
+  const base = (v) => o.io.env[v === "anthropic" ? "AIRGATE_RELAY_ANTHROPIC_URL" : "AIRGATE_RELAY_OPENAI_URL"] || UPSTREAM[v];
+  const handle2 = async (sock, m) => {
+    const send = (f) => sock.readyState === 1 && sock.send(JSON.stringify(f));
+    const auth = o.auth[m.vendor];
+    if (!auth) return send({ t: "error", id: m.id, message: `this laptop has no ${vendorLabel(m.vendor)} sign-in` });
+    const headers = { ...m.headers };
+    const ctl = new AbortController();
+    inflight.set(m.id, ctl);
+    try {
+      let url = `${base(m.vendor)}${m.path}`;
+      if (auth.kind === "chatgpt") {
+        signChatgpt(await chatgptReady(o.io, auth, o.fetch), headers);
+        url = chatgptUrl(m.path, o.io.env.AIRGATE_RELAY_CHATGPT_URL || CHATGPT_CODEX_BASE);
+      } else sign(m.vendor, auth, headers);
+      const res = await o.fetch(url, {
+        method: m.method,
+        headers,
+        body: m.body ? Buffer.from(m.body, "base64") : void 0,
+        signal: ctl.signal
+      });
+      const out = {};
+      res.headers.forEach((v, k) => {
+        if (!["content-encoding", "content-length", "transfer-encoding", "connection", "keep-alive"].includes(k)) out[k] = v;
+      });
+      send({ t: "head", id: m.id, status: res.status, headers: out });
+      signed++;
+      if (res.body) for await (const chunk of res.body) send({ t: "data", id: m.id, b64: Buffer.from(chunk).toString("base64") });
+      send({ t: "end", id: m.id });
+    } catch (e) {
+      if (!ctl.signal.aborted) send({ t: "error", id: m.id, message: e instanceof Error ? e.message : String(e) });
+    } finally {
+      inflight.delete(m.id);
+    }
+  };
+  const connect = () => {
+    if (stopped) return;
+    const sock = o.io.websocket(o.url);
+    ws = sock;
+    sock.onopen = () => {
+      attempt = 0;
+      sock.send(JSON.stringify({ t: "hello", vendors, client: `airgate ${VERSION}` }));
+    };
+    sock.onmessage = (ev) => {
+      let m;
+      try {
+        m = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      if (m.t === "req" && typeof m.id === "string") void handle2(sock, m);
+      else if (m.t === "cancel" && typeof m.id === "string") inflight.get(m.id)?.abort();
+    };
+    sock.onerror = () => void 0;
+    sock.onclose = (ev) => {
+      for (const c of inflight.values()) c.abort();
+      inflight.clear();
+      if (stopped) return resolveDone();
+      if (ev.code === 4401 || ev.code === 1008) {
+        o.say("the gateway refused this laptop (sign in again: airgate login)");
+        stopped = true;
+        return resolveDone();
+      }
+      attempt++;
+      setTimeout(connect, Math.min(15e3, 500 * 2 ** Math.min(attempt, 5)));
+    };
+  };
+  connect();
+  return {
+    vendors,
+    done,
+    count: () => signed,
+    stop() {
+      stopped = true;
+      try {
+        ws?.close(1e3, "done");
+      } catch {
+      }
+      resolveDone();
+    }
+  };
+}
+
+// src/commands/models.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync3 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join6 } from "node:path";
+var HOW = {
+  anthropic: "a Claude subscription token (run `claude setup-token` and paste what it prints) or an Anthropic API key",
+  openai: "an OpenAI API key (for a ChatGPT plan: airgate models connect chatgpt)"
+};
+function relayIfSignedIn(ctx, say) {
+  const auth = localAuth(ctx.io.env);
+  if (!Object.keys(auth).length || !ctx.api.signedIn) return null;
+  try {
+    return startRelay({ io: ctx.io, url: ctx.api.relayUrl(), fetch: ctx.fetch, auth, say: say ?? (() => void 0) });
+  } catch {
+    return null;
+  }
+}
+var KIND = { oauth_token: "subscription token", api_key: "API key", chatgpt: "ChatGPT plan" };
+async function connectChatgpt(ctx, laptop) {
+  const { ui: ui2 } = ctx;
+  let text2;
+  if (!ctx.io.stdin.isTTY) {
+    text2 = await readValue(ctx, "a Codex auth.json", "cat auth.json | airgate models connect chatgpt");
+  } else {
+    if (spawnSync2("codex", ["--version"], { stdio: "ignore" }).status !== 0) {
+      throw new CliError("Codex is not installed on this laptop", "npm i -g @openai/codex, then: airgate models connect chatgpt");
+    }
+    const home = mkdtempSync2(join6(tmpdir2(), "airgate-codex-"));
+    try {
+      ui2.err(ui2.ce("dim", "signing in to ChatGPT for airgate: a separate Codex login, so the one on this laptop stays as it is."));
+      const args = ["login", ...bool(ctx.args, "device") ? ["--device-auth"] : [], "-c", 'cli_auth_credentials_store="file"'];
+      const r2 = spawnSync2("codex", args, { stdio: "inherit", env: { ...process.env, ...ctx.io.env, CODEX_HOME: home } });
+      if (r2.status !== 0) throw new CliError("the ChatGPT sign-in did not finish", "try again, or with --device");
+      try {
+        text2 = readFileSync7(join6(home, "auth.json"), "utf8");
+      } catch {
+        throw new CliError("Codex didn't write a login file", "update Codex (npm i -g @openai/codex) and try again");
+      }
+    } finally {
+      rmSync3(home, { recursive: true, force: true });
+    }
+  }
+  let tokens2;
+  try {
+    tokens2 = parseChatgptLogin(text2);
+  } catch (e) {
+    throw new CliError(e.message);
+  }
+  const value = JSON.stringify(tokens2);
+  if (laptop) {
+    saveLocal(ctx.io.env, "openai", value, "chatgpt");
+    if (ctx.json) return ui2.json({ ok: true, vendor: "openai", kind: "chatgpt", where: "laptop" });
+    ui2.out(`${ui2.c("ok", "saved")} on this laptop only (ChatGPT plan). airgate doesn't get it.`);
+    return void ui2.out(ui2.c("dim", "pods' Codex uses it while this laptop is connected: airgate relay (airgate run and airgate mcp do this on their own)."));
+  }
+  const r = await ctx.api.connectModel("openai", value, "chatgpt");
+  if (ctx.json) return ui2.json({ ...r, where: "airgate" });
+  ui2.out(`${ui2.c("ok", "connected")}: ChatGPT plan for Codex, kept encrypted on airgate (renewed there) and never sent to a pod.`);
+  ui2.out(ui2.c("dim", "undo: airgate models disconnect chatgpt"));
+}
+var models = {
+  name: "models",
+  group: "account",
+  usage: "[connect|disconnect <claude|openai|chatgpt> [--laptop]]",
+  summary: "how pods' agents sign in to their model: in the pod, through this laptop, or connected to airgate",
+  example: "airgate models connect claude --laptop",
+  notes: [
+    "three ways, pick per your comfort: sign in inside the pod (nothing stored with airgate); this laptop signs (airgate relay: airgate holds nothing, works while the laptop is connected); or connect a sign-in to airgate (encrypted on the gateway, never sent to a pod).",
+    "connect <claude|openai|chatgpt>: saves it on airgate. with --laptop: saves it only on this laptop (~/.config/airgate/models.json), for airgate relay.",
+    "claude takes a subscription token (claude setup-token) or an API key; openai takes an API key. the value is read from a hidden prompt or stdin, never from the command line.",
+    "chatgpt (Codex on a ChatGPT plan) runs `codex login` into a fresh folder, so airgate gets its own Codex login and never the one on this laptop (sharing one would sign you out here). --device uses the device-code login. or pipe a Codex auth.json in.",
+    "this laptop also uses CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY or OPENAI_API_KEY from its environment."
+  ],
+  flags: {
+    laptop: { type: "boolean", help: "keep the sign-in on this laptop only (for airgate relay)" },
+    device: { type: "boolean", help: "chatgpt: sign in with a device code instead of this browser" }
+  },
+  async run(ctx) {
+    const { ui: ui2 } = ctx;
+    const [action, who, extra] = ctx.args.positionals;
+    if (extra) throw new UsageError(`unexpected "${extra}"`, "values are read from a hidden prompt or stdin, never from arguments");
+    const laptop = bool(ctx.args, "laptop");
+    if (action === "connect" || action === "disconnect") {
+      const vendor = vendorOf(who);
+      if (!vendor) throw new UsageError("which one? claude or openai", `airgate models ${action} claude`);
+      if (action === "disconnect") {
+        if (laptop) {
+          saveLocal(ctx.io.env, vendor, null);
+          if (ctx.json) return ui2.json({ ok: true, vendor, where: "laptop" });
+          return void ui2.out(`${vendorLabel(vendor)}: removed from this laptop.`);
+        }
+        const r2 = await ctx.api.disconnectModel(vendor);
+        if (ctx.json) return ui2.json({ ...r2, vendor, where: "airgate" });
+        return void ui2.out(r2.ok ? `${vendorLabel(vendor)}: disconnected from airgate. airgate no longer holds it.` : `${vendorLabel(vendor)} wasn't connected to airgate.`);
+      }
+      if (who?.toLowerCase() === "chatgpt") return connectChatgpt(ctx, laptop);
+      if (!ctx.json && ctx.io.stdin.isTTY) ui2.err(ui2.ce("dim", `paste ${HOW[vendor]}.`));
+      const value = (await readValue(ctx, vendor === "anthropic" ? "your Claude sign-in" : "your OpenAI key", `printf %s "$KEY" | airgate models connect ${who}${laptop ? " --laptop" : ""}`)).trim();
+      if (value.length < 20 || /\s/.test(value)) throw new CliError("that doesn't look like a key or token", HOW[vendor]);
+      if (laptop) {
+        saveLocal(ctx.io.env, vendor, value);
+        if (ctx.json) return ui2.json({ ok: true, vendor, kind: kindOf(vendor, value), where: "laptop" });
+        ui2.out(`${ui2.c("ok", "saved")} on this laptop only (${kindOf(vendor, value) === "oauth_token" ? "subscription token" : "API key"}). airgate doesn't get it.`);
+        return void ui2.out(ui2.c("dim", "pods use it while this laptop is connected: airgate relay (airgate run and airgate mcp do this on their own)."));
+      }
+      const r = await ctx.api.connectModel(vendor, value);
+      if (ctx.json) return ui2.json({ ...r, where: "airgate" });
+      ui2.out(`${ui2.c("ok", "connected")}: ${vendorLabel(vendor)} (${KIND[r.kind] ?? r.kind}), kept encrypted on airgate and never sent to a pod.`);
+      return void ui2.out(ui2.c("dim", `every pod's ${vendor === "anthropic" ? "Claude Code" : "Codex"} can use it now, unless signed in inside the pod. undo: airgate models disconnect ${who}`));
+    }
+    if (action) throw new UsageError(`unknown "${action}"`, "airgate models \xB7 airgate models connect claude [--laptop] \xB7 airgate models disconnect claude [--laptop]");
+    const st = await ctx.api.modelsAuth();
+    const local = localAuth(ctx.io.env);
+    if (ctx.json) return ui2.json({ ...st, thisLaptop: Object.fromEntries(Object.entries(local).map(([v, a]) => [v, { kind: a.kind, from: a.from }])) });
+    const rows2 = ["anthropic", "openai"].map((v) => {
+      const c = st.connected.find((x) => x.vendor === v);
+      const l = local[v];
+      return [
+        vendorLabel(v),
+        c ? ui2.c("ok", `connected to airgate (${KIND[c.kind] ?? c.kind})`) : ui2.c("dim", "not on airgate"),
+        l ? `this laptop: ${l.kind === "chatgpt" ? "ChatGPT plan" : l.from}${st.laptop.connected && st.laptop.vendors.includes(v) ? ui2.c("ok", " \xB7 relaying") : ""}` : ui2.c("dim", "not on this laptop")
+      ];
+    });
+    ui2.table(rows2, { head: ["model", "airgate", "laptop"] });
+    ui2.out();
+    ui2.out(ui2.c("dim", "a pod uses, in order: a sign-in made inside it \xB7 a connected laptop (airgate relay) \xB7 one connected to airgate."));
+    if (!st.connected.length && !Object.keys(local).length) ui2.out(ui2.c("dim", "set one up: airgate models connect claude --laptop (airgate holds nothing) or airgate models connect claude."));
+    if (!hasSavedFile(ctx.io.env) && Object.keys(local).length) ui2.out(ui2.c("dim", "this laptop signs from its environment variables."));
+  }
+};
+var relay = {
+  name: "relay",
+  group: "account",
+  usage: "",
+  summary: "sign your pods' model calls from this laptop while it runs: airgate never holds your sign-in",
+  example: "airgate relay",
+  notes: [
+    "uses this laptop's Claude / OpenAI sign-in (see airgate models). only pods with no sign-in of their own use it, and only while this runs.",
+    "airgate run and airgate mcp start it on their own when this laptop has a sign-in."
+  ],
+  async run(ctx) {
+    const { ui: ui2 } = ctx;
+    const auth = localAuth(ctx.io.env);
+    if (!Object.keys(auth).length) throw new CliError("no model sign-in on this laptop", "airgate models connect claude --laptop (or set CLAUDE_CODE_OAUTH_TOKEN / ANTHROPIC_API_KEY / OPENAI_API_KEY)");
+    const r = startRelay({ io: ctx.io, url: ctx.api.relayUrl(), fetch: ctx.fetch, auth, say: (l) => ui2.err(ui2.ce("warn", l)) });
+    const stop = () => r.stop();
+    ctx.io.signals.on("SIGINT", stop);
+    ctx.io.signal?.addEventListener("abort", stop);
+    if (!ctx.json) {
+      ui2.out(`relaying ${r.vendors.map(vendorLabel).join(" and ")} for your pods from this laptop. ${ui2.c("dim", "ctrl-c to stop.")}`);
+      for (const v of r.vendors) ui2.out(ui2.c("dim", `  ${vendorLabel(v)}: ${auth[v].from}`));
+    }
+    try {
+      await r.done;
+    } finally {
+      ctx.io.signals.off("SIGINT", stop);
+      ctx.io.signal?.removeEventListener("abort", stop);
+    }
+    if (ctx.json) return ui2.json({ signed: r.count() });
+    ui2.out(`stopped. ${r.count()} model call(s) signed.`);
+  }
+};
+
+// src/commands/run.ts
+var MODEL = {
+  "claude-code": { vendor: "anthropic", secrets: ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"] },
+  codex: { vendor: "openai", secrets: ["OPENAI_API_KEY"] }
 };
 var shortId = () => randomBytes(2).toString("hex");
 var runName = (base) => `${base.slice(0, 52)}-run-${shortId()}`;
-async function signInWarning(ctx, agent) {
-  const need2 = SIGN_IN[agent];
-  if (!need2) return null;
+async function signInWarning(ctx, agent, relaying) {
+  const m = MODEL[agent];
+  if (!m || relaying.includes(m.vendor)) return null;
+  const st = await ctx.api.modelsAuth().catch(() => null);
+  if (st?.connected.some((c) => c.vendor === m.vendor)) return null;
   const list2 = await ctx.api.secrets().catch(() => null);
-  if (!list2) return null;
-  if (list2.account.some((s2) => need2.names.includes(s2.name))) return null;
-  return `no ${need2.names.join(" or ")} secret: ${AGENTS[agent].label} may not be signed in inside the pod. fix once for every pod: ${need2.fix}`;
+  if (list2?.account.some((s2) => m.secrets.includes(s2.name))) return null;
+  if (!st && !list2) return null;
+  const who = m.vendor === "anthropic" ? "claude" : "chatgpt";
+  return `${AGENTS[agent].label} has no sign-in for a fresh pod. pick one: airgate models connect ${who} --laptop (this laptop signs; airgate holds nothing), or airgate models connect ${who} (kept on airgate)`;
 }
 async function finish(ctx, pod, keep) {
   if (keep === "destroy") await ctx.ui.spin(`deleting ${pod.spec.name}`, ctx.api.destroy(pod.id));
@@ -8673,7 +9093,7 @@ var runTask = {
     "--no-apply prints the patch instead of applying it (the pod sleeps, so `airgate down --pod <it>` can still apply it); --keep keeps the pod (asleep).",
     "--repo owner/name (or a github link): runs on the repo itself instead (private repos need GitHub connected: airgate github connect). the work stays on a branch in the pod; --pr asks the agent to open a pull request, which waits in your airlock. the pod sleeps afterwards (free).",
     "if the task fails, the patch does not apply, or it runs past --timeout (default 60 minutes), the pod is kept so nothing is lost.",
-    "the agent needs a sign-in that works in any pod: for Claude Code run `claude setup-token`, then `airgate secrets set CLAUDE_CODE_OAUTH_TOKEN`."
+    "the pod's agent needs a model sign-in: while run runs, this laptop signs for it if it has one (airgate models connect claude --laptop); or connect one to airgate (airgate models connect claude). see: airgate help models"
   ],
   flags: {
     repo: { type: "string", value: "owner/name", help: "run on a GitHub repo instead of this folder" },
@@ -8698,109 +9118,118 @@ var runTask = {
     if (!Number.isFinite(minutes) || minutes <= 0) throw new UsageError("--timeout: minutes, e.g. 30");
     const repo = str(ctx.args, "repo");
     const warnings = [];
-    const warn = await signInWarning(ctx, agent);
+    const relayer = relayIfSignedIn(ctx);
+    if (relayer && !ctx.json) ui2.err(ui2.ce("dim", `this laptop signs the pod's ${relayer.vendors.map(vendorLabel).join(" / ")} calls while it runs (airgate holds nothing)`));
+    const warn = await signInWarning(ctx, agent, relayer?.vendors ?? []);
     if (warn) {
       warnings.push(warn);
       if (!ctx.json) ui2.err(ui2.ce("warn", warn));
     }
-    const work = async (pod2, text3) => {
-      let r2 = await ui2.spin(`handing ${pod2.spec.name} the task`, ctx.api.startTask(pod2.id, text3));
-      r2 = await ui2.spin(`${pod2.spec.name} is working (${AGENTS[agent].label})`, () => waitRun(ctx, pod2.id, r2, minutes * 6e4));
-      const log2 = await ctx.api.runLog(pod2.id, r2.id).catch(() => "");
-      return { run: r2, log: log2, done: r2.endedAt !== void 0, ok: r2.endedAt !== void 0 && r2.exitCode === 0 };
-    };
-    if (repo) {
-      if (dirArg) throw new UsageError("a folder or --repo, not both");
-      const look = await ctx.api.inspectRepo(repo).catch((e) => {
-        if (e instanceof ApiError && e.status === 404) return null;
-        throw e;
-      });
-      if (look && !look.reachable) {
-        const gh = await ctx.api.github().catch(() => null);
-        if (gh && !gh.configured) throw new CliError(`${look.repo} is private, and private repos need the Airgate GitHub App, which isn't set up on this gateway yet`, 'run it from a local clone instead: cd into it, then airgate run "\u2026"');
-        throw new CliError(`airgate can't reach ${look.repo} (private, and not shared with Airgate)`, "connect GitHub and install the app on it: airgate github connect");
+    try {
+      return await go();
+    } finally {
+      relayer?.stop();
+    }
+    async function go() {
+      const work = async (pod2, text3) => {
+        let r2 = await ui2.spin(`handing ${pod2.spec.name} the task`, ctx.api.startTask(pod2.id, text3));
+        r2 = await ui2.spin(`${pod2.spec.name} is working (${AGENTS[agent].label})`, () => waitRun(ctx, pod2.id, r2, minutes * 6e4));
+        const log2 = await ctx.api.runLog(pod2.id, r2.id).catch(() => "");
+        return { run: r2, log: log2, done: r2.endedAt !== void 0, ok: r2.endedAt !== void 0 && r2.exitCode === 0 };
+      };
+      if (repo) {
+        if (dirArg) throw new UsageError("a folder or --repo, not both");
+        const look = await ctx.api.inspectRepo(repo).catch((e) => {
+          if (e instanceof ApiError && e.status === 404) return null;
+          throw e;
+        });
+        if (look && !look.reachable) {
+          const gh = await ctx.api.github().catch(() => null);
+          if (gh && !gh.configured) throw new CliError(`${look.repo} is private, and private repos need the Airgate GitHub App, which isn't set up on this gateway yet`, 'run it from a local clone instead: cd into it, then airgate run "\u2026"');
+          throw new CliError(`airgate can't reach ${look.repo} (private, and not shared with Airgate)`, "connect GitHub and install the app on it: airgate github connect");
+        }
+        const name2 = runName((look?.repo ?? repo).split("/").pop() ?? "repo");
+        const spec = { name: name2, agent, size: size2, repo: look?.repo ?? repo, masking: true, network: "allowlist", allow: DEFAULT_ALLOW, autoStopMinutes: null, autoCheckpoint: true };
+        const pod2 = await ui2.spin(`launching ${name2} on ${spec.repo}`, async () => waitReady(ctx, await ctx.api.launch(spec)));
+        const envFile2 = str(ctx.args, "env");
+        if (envFile2) await ui2.spin(`sending ${envFile2} as secrets`, sendDotenv(ctx, envFile2, pod2.id));
+        const text3 = task2 + (bool(ctx.args, "pr") ? '\n\nWhen you are done: commit on a new branch and open a pull request with `airgate pr --title "\u2026"` (it waits for my approval).' : "\n\nWhen you are done: commit your work on a new branch here and say which branch.");
+        const r2 = await work(pod2, text3);
+        await finish(ctx, pod2, r2.done ? "sleep" : "running");
+        if (ctx.json) return ui2.json({ pod: { id: pod2.id, name: name2 }, repo: spec.repo, run: r2.run, ok: r2.ok, log: r2.log, pod_state: r2.done ? "sleeping" : "running", warnings });
+        ctx.io.stdout.write(r2.log.endsWith("\n") || !r2.log ? r2.log : r2.log + "\n");
+        if (!r2.done) ui2.err(ui2.ce("warn", `still working after ${minutes} min; it carries on. follow it: airgate log ${name2}`));
+        ui2.out(`${r2.ok ? ui2.c("ok", "done") : ui2.c("bad", "failed")} on ${name2}${r2.done ? " (asleep now, free)" : ""}. look: airgate attach ${name2}${bool(ctx.args, "pr") ? " \xB7 the pull request: airgate airlock" : ""}`);
+        return r2.ok ? 0 : 1;
       }
-      const name2 = runName((look?.repo ?? repo).split("/").pop() ?? "repo");
-      const spec = { name: name2, agent, size: size2, repo: look?.repo ?? repo, masking: true, network: "allowlist", allow: DEFAULT_ALLOW, autoStopMinutes: null, autoCheckpoint: true };
-      const pod2 = await ui2.spin(`launching ${name2} on ${spec.repo}`, async () => waitReady(ctx, await ctx.api.launch(spec)));
-      const envFile2 = str(ctx.args, "env");
-      if (envFile2) await ui2.spin(`sending ${envFile2} as secrets`, sendDotenv(ctx, envFile2, pod2.id));
-      const text3 = task2 + (bool(ctx.args, "pr") ? '\n\nWhen you are done: commit on a new branch and open a pull request with `airgate pr --title "\u2026"` (it waits for my approval).' : "\n\nWhen you are done: commit your work on a new branch here and say which branch.");
-      const r2 = await work(pod2, text3);
-      await finish(ctx, pod2, r2.done ? "sleep" : "running");
-      if (ctx.json) return ui2.json({ pod: { id: pod2.id, name: name2 }, repo: spec.repo, run: r2.run, ok: r2.ok, log: r2.log, pod_state: r2.done ? "sleeping" : "running", warnings });
-      ctx.io.stdout.write(r2.log.endsWith("\n") || !r2.log ? r2.log : r2.log + "\n");
-      if (!r2.done) ui2.err(ui2.ce("warn", `still working after ${minutes} min; it carries on. follow it: airgate log ${name2}`));
-      ui2.out(`${r2.ok ? ui2.c("ok", "done") : ui2.c("bad", "failed")} on ${name2}${r2.done ? " (asleep now, free)" : ""}. look: airgate attach ${name2}${bool(ctx.args, "pr") ? " \xB7 the pull request: airgate airlock" : ""}`);
-      return r2.ok ? 0 : 1;
-    }
-    const projectDir = resolve5(ctx.io.cwd, dirArg ?? ".");
-    if (!existsSync4(projectDir) || !statSync3(projectDir).isDirectory()) throw new CliError(`no directory ${projectDir}`);
-    const noApply = bool(ctx.args, "no-apply");
-    if (!noApply && !gitTopLevel(projectDir)) {
-      throw new CliError(`${projectDir} isn't a git repo, so the result can't come back as a patch`, "git init && git add -A && git commit -m base, or use --no-apply");
-    }
-    const sp = statePath(projectDir);
-    const before = existsSync4(sp) ? readFileSync6(sp, "utf8") : null;
-    const restoreState = () => {
-      try {
-        if (before !== null) writeFileSync4(sp, before);
-        else rmSync3(sp, { force: true });
-      } catch {
+      const projectDir = resolve5(ctx.io.cwd, dirArg ?? ".");
+      if (!existsSync5(projectDir) || !statSync3(projectDir).isDirectory()) throw new CliError(`no directory ${projectDir}`);
+      const noApply = bool(ctx.args, "no-apply");
+      if (!noApply && !gitTopLevel(projectDir)) {
+        throw new CliError(`${projectDir} isn't a git repo, so the result can't come back as a patch`, "git init && git add -A && git commit -m base, or use --no-apply");
       }
-    };
-    const name = runName(podDirName(projectDir));
-    const upArgv = [projectDir, "--name", name, "--agent", agent, "--memory", size2, "--no-session", "--yes"];
-    const envFile = str(ctx.args, "env");
-    if (envFile) upArgv.push("--env", envFile);
-    const sent = await ui2.spin(`sending ${basename2(projectDir)} to a fresh pod`, runCommand(ctx, up, upArgv, ctx.io.cwd));
-    const pod = sent.pod;
-    const text2 = `Work in ~/${sent.dir} (a project sent from my laptop). ${task2}
+      const sp = statePath(projectDir);
+      const before = existsSync5(sp) ? readFileSync8(sp, "utf8") : null;
+      const restoreState = () => {
+        try {
+          if (before !== null) writeFileSync5(sp, before);
+          else rmSync4(sp, { force: true });
+        } catch {
+        }
+      };
+      const name = runName(podDirName(projectDir));
+      const upArgv = [projectDir, "--name", name, "--agent", agent, "--memory", size2, "--no-session", "--yes"];
+      const envFile = str(ctx.args, "env");
+      if (envFile) upArgv.push("--env", envFile);
+      const sent = await ui2.spin(`sending ${basename2(projectDir)} to a fresh pod`, runCommand(ctx, up, upArgv, ctx.io.cwd));
+      const pod = sent.pod;
+      const text2 = `Work in ~/${sent.dir} (a project sent from my laptop). ${task2}
 
 When you are done, leave your changes in the files there (no need to commit or push): they are brought back to my laptop as a patch.`;
-    let r;
-    try {
-      r = await work(pod, text2);
-    } catch (e) {
-      await finish(ctx, pod, "sleep");
-      throw e;
-    }
-    const keepNote = (why) => `${why}. the pod is kept (asleep): airgate attach ${name} \xB7 bring it back: airgate down --pod ${name} \xB7 delete it: airgate destroy ${name}`;
-    const out = (o) => ui2.json({ pod: { id: pod.id, name }, run: r.run, ok: r.ok, log: r.log, warnings, ...o });
-    if (!r.ok) {
-      await finish(ctx, pod, r.done ? "sleep" : "running");
-      if (ctx.json) return out({ applied: false, pod_state: r.done ? "sleeping" : "running" });
-      ctx.io.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : r.log + "\n");
-      ui2.err(ui2.ce("bad", r.done ? keepNote(`the task failed (exit ${r.run.exitCode ?? "?"})`) : `still working after ${minutes} min; it carries on. follow it: airgate log ${name}, then: airgate down --pod ${name}`));
-      return 1;
-    }
-    let result;
-    try {
-      result = await ui2.spin(`bringing the changes back from ${name}`, runCommand(ctx, down2, ["--pod", name, "--no-session", ...noApply ? ["--dry-run"] : ["--yes"]], projectDir));
-    } catch (e) {
-      await finish(ctx, pod, "sleep");
-      const why = e instanceof Error ? e.message.split("\n")[0] : String(e);
-      if (ctx.json) return out({ applied: false, error: why, pod_state: "sleeping" });
+      let r;
+      try {
+        r = await work(pod, text2);
+      } catch (e) {
+        await finish(ctx, pod, "sleep");
+        throw e;
+      }
+      const keepNote = (why) => `${why}. the pod is kept (asleep): airgate attach ${name} \xB7 bring it back: airgate down --pod ${name} \xB7 delete it: airgate destroy ${name}`;
+      const out = (o) => ui2.json({ pod: { id: pod.id, name }, run: r.run, ok: r.ok, log: r.log, warnings, ...o });
+      if (!r.ok) {
+        await finish(ctx, pod, r.done ? "sleep" : "running");
+        if (ctx.json) return out({ applied: false, pod_state: r.done ? "sleeping" : "running" });
+        ctx.io.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : r.log + "\n");
+        ui2.err(ui2.ce("bad", r.done ? keepNote(`the task failed (exit ${r.run.exitCode ?? "?"})`) : `still working after ${minutes} min; it carries on. follow it: airgate log ${name}, then: airgate down --pod ${name}`));
+        return 1;
+      }
+      let result;
+      try {
+        result = await ui2.spin(`bringing the changes back from ${name}`, runCommand(ctx, down2, ["--pod", name, "--no-session", ...noApply ? ["--dry-run"] : ["--yes"]], projectDir));
+      } catch (e) {
+        await finish(ctx, pod, "sleep");
+        const why = e instanceof Error ? e.message.split("\n")[0] : String(e);
+        if (ctx.json) return out({ applied: false, error: why, pod_state: "sleeping" });
+        ctx.io.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : r.log + "\n");
+        ui2.err(ui2.ce("bad", keepNote(`the task finished, but its changes didn't come back: ${why}`)));
+        return 1;
+      }
+      const files = result.files ?? [];
+      const keep = noApply || bool(ctx.args, "keep");
+      await finish(ctx, pod, keep ? "sleep" : "destroy");
+      if (!keep) restoreState();
+      if (ctx.json) return out({ applied: !noApply && files.length > 0, files, ...noApply ? { patch: result.patch ?? "" } : {}, pod_state: keep ? "sleeping" : "deleted" });
       ctx.io.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : r.log + "\n");
-      ui2.err(ui2.ce("bad", keepNote(`the task finished, but its changes didn't come back: ${why}`)));
-      return 1;
-    }
-    const files = result.files ?? [];
-    const keep = noApply || bool(ctx.args, "keep");
-    await finish(ctx, pod, keep ? "sleep" : "destroy");
-    if (!keep) restoreState();
-    if (ctx.json) return out({ applied: !noApply && files.length > 0, files, ...noApply ? { patch: result.patch ?? "" } : {}, pod_state: keep ? "sleeping" : "deleted" });
-    ctx.io.stdout.write(r.log.endsWith("\n") || !r.log ? r.log : r.log + "\n");
-    if (noApply) {
-      ctx.io.stdout.write(result.patch ?? "");
-      ui2.err(`${files.length} file(s) changed, not applied. apply: airgate down --pod ${name} \xB7 delete the pod: airgate destroy ${name}`);
+      if (noApply) {
+        ctx.io.stdout.write(result.patch ?? "");
+        ui2.err(`${files.length} file(s) changed, not applied. apply: airgate down --pod ${name} \xB7 delete the pod: airgate destroy ${name}`);
+        return 0;
+      }
+      const risky = files.filter((f) => f.risky).length;
+      ui2.out(
+        `${ui2.c("ok", "done")}: ${files.length ? `${files.length} file(s) changed here${risky ? `, ${risky} risky` : ""}. review: git status \xB7 git diff` : "no changes came back"}` + (keep ? ` \xB7 the pod is kept (asleep): ${name}` : " \xB7 the pod is deleted")
+      );
       return 0;
     }
-    const risky = files.filter((f) => f.risky).length;
-    ui2.out(
-      `${ui2.c("ok", "done")}: ${files.length ? `${files.length} file(s) changed here${risky ? `, ${risky} risky` : ""}. review: git status \xB7 git diff` : "no changes came back"}` + (keep ? ` \xB7 the pod is kept (asleep): ${name}` : " \xB7 the pod is deleted")
-    );
-    return 0;
   }
 };
 
@@ -9176,6 +9605,10 @@ var mcp = {
     const rl = createInterface({ input: ctx.io.stdin, crlfDelay: Infinity, terminal: false });
     const pending = /* @__PURE__ */ new Set();
     if (!ctx.api.signedIn) ctx.io.stderr.write("airgate mcp: not signed in; tools will say so. run: airgate login\n");
+    const relayer = relayIfSignedIn(ctx, (l) => ctx.io.stderr.write(`airgate mcp: ${l}
+`));
+    if (relayer) ctx.io.stderr.write(`airgate mcp: signing pods' ${relayer.vendors.join(" / ")} calls from this laptop while this runs
+`);
     for await (const line2 of rl) {
       if (!line2.trim()) continue;
       let msg;
@@ -9193,13 +9626,14 @@ var mcp = {
       void job2.finally(() => pending.delete(job2));
     }
     await Promise.all(pending);
+    relayer?.stop();
   }
 };
 
 // src/commands/misc.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 var PAGES = ["pods", "airlock", "usage", "settings", "mask", "chat", "notes", "data", "status"];
 var open = {
   name: "open",
@@ -9275,12 +9709,12 @@ var skill = {
     if (!text2.startsWith("---")) throw new CliError(`${url} isn't a skill file`);
     if (action === "show") return void ctx.io.stdout.write(text2);
     if (action !== "install") throw new UsageError(`unknown action "${action}"`, "airgate skill install [--project] | airgate skill show");
-    const base = bool(ctx.args, "project") ? join5(ctx.io.cwd, ".claude") : join5(ctx.io.env.HOME ?? homedir3(), ".claude");
-    const dir = join5(base, "skills", "airgate");
-    mkdirSync4(dir, { recursive: true });
-    writeFileSync5(join5(dir, "SKILL.md"), text2);
-    if (ctx.json) return ctx.ui.json({ installed: join5(dir, "SKILL.md") });
-    ctx.ui.out(`${ctx.ui.c("ok", "installed")} the airgate skill: ${join5(dir, "SKILL.md")}`);
+    const base = bool(ctx.args, "project") ? join7(ctx.io.cwd, ".claude") : join7(ctx.io.env.HOME ?? homedir3(), ".claude");
+    const dir = join7(base, "skills", "airgate");
+    mkdirSync5(dir, { recursive: true });
+    writeFileSync6(join7(dir, "SKILL.md"), text2);
+    if (ctx.json) return ctx.ui.json({ installed: join7(dir, "SKILL.md") });
+    ctx.ui.out(`${ctx.ui.c("ok", "installed")} the airgate skill: ${join7(dir, "SKILL.md")}`);
     ctx.ui.out(ctx.ui.c("dim", 'claude code picks it up in its next session. ask it to "move this to an airgate pod".'));
   }
 };
@@ -10585,7 +11019,7 @@ function formModal(c, s2, f) {
   const t = TEMPLATES[formTemplate(f)];
   const builtin = formBuiltin(f);
   const plan2 = s2.me?.plan === "pro" ? "pro" : "payg";
-  const models = s2.catalog?.models ?? [];
+  const models2 = s2.catalog?.models ?? [];
   fields.forEach((id, i) => {
     const y = b2.y + 1 + i;
     if (y >= b2.y + b2.h - 3) return;
@@ -10623,7 +11057,7 @@ function formModal(c, s2, f) {
         v = `[${f.builtin ? "x" : " "}] built-in model, no subscription`;
         break;
       case "model":
-        v = `\u2039 ${models[f.model]?.id ?? `default${s2.catalog?.defaultModel ? ` (${s2.catalog.defaultModel})` : ""}`} \u203A`;
+        v = `\u2039 ${models2[f.model]?.id ?? `default${s2.catalog?.defaultModel ? ` (${s2.catalog.defaultModel})` : ""}`} \u203A`;
         break;
       case "schedule": {
         const p = SCHEDULE_LIST[f.schedule];
@@ -11057,6 +11491,8 @@ var COMMANDS = [
   up,
   down2,
   runTask,
+  models,
+  relay,
   usage,
   plan,
   upgrade,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airgate",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Give your AI its own computer: the airgate command line.",
   "type": "module",
   "bin": {