@astrasyncai/verification-gateway 5.15.0 → 5.17.0

package/dist/bin/astrasync-guard.js

@@ -233,9 +233,9 @@ function requireType() {
   }
   function Type2(tag, options) {
     options = options || {};
-    Object.keys(options).forEach(function(name) {
-      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
-        throw new YAMLException2('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+    Object.keys(options).forEach(function(name2) {
+      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name2) === -1) {
+        throw new YAMLException2('Unknown option "' + name2 + '" is met in definition of "' + tag + '" YAML type.');
       }
     });
     this.options = options;
@@ -268,9 +268,9 @@ function requireSchema() {
   hasRequiredSchema = 1;
   const YAMLException2 = requireException();
   const Type2 = requireType();
-  function compileList(schema2, name) {
+  function compileList(schema2, name2) {
     const result = [];
-    schema2[name].forEach(function(currentType) {
+    schema2[name2].forEach(function(currentType) {
       let newIndex = result.length;
       result.forEach(function(previousType, previousIndex) {
         if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) {
@@ -1179,18 +1179,18 @@ function requireLoader() {
       state.onWarning.call(null, generateError(state, message));
     }
   }
-  function storeAnchor(state, name, value) {
+  function storeAnchor(state, name2, value) {
     const transactions = state.anchorMapTransactions;
     if (transactions.length !== 0) {
       const transaction = transactions[transactions.length - 1];
-      if (!_hasOwnProperty.call(transaction, name)) {
-        transaction[name] = {
-          existed: _hasOwnProperty.call(state.anchorMap, name),
-          value: state.anchorMap[name]
+      if (!_hasOwnProperty.call(transaction, name2)) {
+        transaction[name2] = {
+          existed: _hasOwnProperty.call(state.anchorMap, name2),
+          value: state.anchorMap[name2]
         };
       }
     }
-    state.anchorMap[name] = value;
+    state.anchorMap[name2] = value;
   }
   function beginAnchorTransaction(state) {
     state.anchorMapTransactions.push(/* @__PURE__ */ Object.create(null));
@@ -1202,9 +1202,9 @@ function requireLoader() {
     const parent = transactions[transactions.length - 1];
     const names = Object.keys(transaction);
     for (let index = 0, length = names.length; index < length; index += 1) {
-      const name = names[index];
-      if (!_hasOwnProperty.call(parent, name)) {
-        parent[name] = transaction[name];
+      const name2 = names[index];
+      if (!_hasOwnProperty.call(parent, name2)) {
+        parent[name2] = transaction[name2];
       }
     }
   }
@@ -1245,7 +1245,7 @@ function requireLoader() {
     state.result = snapshot.result;
   }
   const directiveHandlers = {
-    YAML: function handleYamlDirective(state, name, args) {
+    YAML: function handleYamlDirective(state, name2, args) {
       if (state.version !== null) {
         throwError(state, "duplication of %YAML directive");
       }
@@ -1267,7 +1267,7 @@ function requireLoader() {
         throwWarning(state, "unsupported YAML version of the document");
       }
     },
-    TAG: function handleTagDirective(state, name, args) {
+    TAG: function handleTagDirective(state, name2, args) {
       let prefix;
       if (args.length !== 2) {
         throwError(state, "TAG directive accepts exactly two arguments");
@@ -3573,10 +3573,10 @@ ${category.label}
       scope.blockedResources = additionalBlocked;
     }
     this.print("");
-    const name = (await this.ask("Policy name [default: local-guard]: ")).trim() || "local-guard";
+    const name2 = (await this.ask("Policy name [default: local-guard]: ")).trim() || "local-guard";
     const policy = {
       version: "1.0",
-      name,
+      name: name2,
       purposes,
       ...scope && { scope },
       ...limits && { limits },
@@ -3713,7 +3713,7 @@ Policy saved to ${outputPath}`);
 };
 
 // src/version.ts
-var SDK_VERSION = "5.15.0";
+var SDK_VERSION = "5.17.0";
 
 // src/http.ts
 var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;
@@ -3725,10 +3725,10 @@ function withUserAgent(initHeaders) {
     return copy;
   }
   if (Array.isArray(initHeaders)) {
-    const has2 = initHeaders.some(([name]) => name.toLowerCase() === "user-agent");
+    const has2 = initHeaders.some(([name2]) => name2.toLowerCase() === "user-agent");
     return has2 ? initHeaders : [...initHeaders, ["user-agent", SDK_USER_AGENT]];
   }
-  const has = Object.keys(initHeaders).some((name) => name.toLowerCase() === "user-agent");
+  const has = Object.keys(initHeaders).some((name2) => name2.toLowerCase() === "user-agent");
   return has ? initHeaders : { "user-agent": SDK_USER_AGENT, ...initHeaders };
 }
 var sdkFetch = (input, init) => fetch(input, { ...init, headers: withUserAgent(init?.headers) });
@@ -4303,8 +4303,8 @@ function extractBacktickSubstitutions(text, collect) {
 }
 function basename(token) {
   const slash = Math.max(token.lastIndexOf("/"), token.lastIndexOf("\\"));
-  const name = slash === -1 ? token : token.slice(slash + 1);
-  return name.replace(/\.(exe|cmd|bat|ps1)$/i, "");
+  const name2 = slash === -1 ? token : token.slice(slash + 1);
+  return name2.replace(/\.(exe|cmd|bat|ps1)$/i, "");
 }
 function matchSegment(segment, list) {
   const tokens = segment.split(/\s+/).filter((t) => /[a-z0-9]/.test(t));
@@ -4754,6 +4754,8 @@ function getCacheKey(request2, counterpartyId) {
     request2.durationRequired ?? "",
     request2.invocationProtocol || "",
     request2.enableRuntimeChallenge ? "1" : "0",
+    // 5.16.0: route policy changes the verdict (owners / challenge).
+    request2.routePolicy ? JSON.stringify(request2.routePolicy) : "",
     // callerMetadata fields contribute to risk model; include the ones
     // backend reads. sourceIp/userAgent/forwardedFor change per-request
     // so their inclusion effectively forces a re-check for any varying
@@ -4926,6 +4928,7 @@ async function callVerifyAccessAPI(config, request2) {
   if (requestData.subAgentDepth !== void 0) body.subAgentDepth = requestData.subAgentDepth;
   if (requestData.enableRuntimeChallenge)
     body.enableRuntimeChallenge = requestData.enableRuntimeChallenge;
+  if (requestData.routePolicy) body.routePolicy = requestData.routePolicy;
   if (requestData.createSession) body.createSession = requestData.createSession;
   if (requestData.durationRequired) body.durationRequired = requestData.durationRequired;
   if (requestData.counterpartyType) body.counterpartyType = requestData.counterpartyType;
@@ -6426,7 +6429,7 @@ function ensureGuardSelfProtection(policyPath) {
   (0, import_fs5.writeFileSync)(policyPath, toYaml(parsed.policy), "utf-8");
   return true;
 }
-function buildDefaultClaudeCodePolicy(name = "claude-code-local-guard") {
+function buildDefaultClaudeCodePolicy(name2 = "claude-code-local-guard") {
   const recommendedCommands = DEFAULT_BLOCKED_COMMANDS.filter((c) => c.recommended).map(
     (c) => c.pattern
   );
@@ -6434,7 +6437,7 @@ function buildDefaultClaudeCodePolicy(name = "claude-code-local-guard") {
   const permissive = RISK_PRESETS.find((p) => p.name === "permissive");
   return {
     version: "1.0",
-    name,
+    name: name2,
     description: "AstraSync Local Guard for Claude Code \u2014 default coding-agent policy. Edit freely; the hook re-reads this file on every tool call.",
     purposes: [
       {
@@ -6981,6 +6984,454 @@ function writeManagedSettings(files, outDir) {
   });
 }
 
+// src/fleet/git-route.ts
+var import_child_process2 = require("child_process");
+var realGit = (args) => (0, import_child_process2.execFileSync)("git", args, { encoding: "utf-8" });
+function gitRouteConfig(opts) {
+  const base2 = opts.checkpoint.replace(/\/+$/, "");
+  if (!/^https:\/\//.test(base2) && !/^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(base2)) {
+    throw new Error("--checkpoint must be an https:// URL");
+  }
+  if (!/^ASTRA-[A-Za-z0-9_-]{8,64}$/.test(opts.agent))
+    throw new Error("--agent must be an ASTRA-id");
+  if (!/^[A-Za-z0-9_-]{4,120}$/.test(opts.slug))
+    throw new Error("--slug must be the connector slug");
+  const upstream = opts.upstream ?? "github";
+  return [
+    [`url.${base2}/a/${opts.slug}/git/${upstream}/.insteadOf`, opts.host ?? "https://github.com/"],
+    [`credential.${base2}.helper`, "!astrasync guard git-credential"],
+    ["astrasync.agent", opts.agent],
+    ["astrasync.checkpoint", base2]
+  ];
+}
+function applyGitRoute(opts, git = realGit) {
+  const entries = gitRouteConfig(opts);
+  for (const [key, value] of entries) git(["config", "--global", key, value]);
+  return entries.map(([k, v]) => `${k} = ${v}`);
+}
+function removeGitRoute(git = realGit) {
+  let base2 = "";
+  try {
+    base2 = git(["config", "--global", "--get", "astrasync.checkpoint"]).trim();
+  } catch {
+    return [];
+  }
+  const removed = [];
+  const unset = (args) => {
+    try {
+      git(["config", "--global", ...args]);
+      removed.push(args[args.length - 1]);
+    } catch {
+    }
+  };
+  let urls = "";
+  try {
+    urls = git(["config", "--global", "--get-regexp", "^url\\..*\\.insteadof$"]);
+  } catch {
+  }
+  for (const line of urls.split("\n")) {
+    const key = line.split(" ")[0];
+    if (key && key.toLowerCase().startsWith(`url.${base2}/`.toLowerCase())) unset(["--unset", key]);
+  }
+  unset(["--unset", `credential.${base2}.helper`]);
+  unset(["--unset", "astrasync.agent"]);
+  unset(["--unset", "astrasync.checkpoint"]);
+  return removed;
+}
+function gitCredentialAnswer(action, input, deps) {
+  if (action !== "get" || !deps.agent || !deps.checkpoint || !deps.deviceCredential) return "";
+  const fields = Object.fromEntries(
+    input.split("\n").map((l) => l.split("=")).filter((p) => p.length >= 2).map(([k, ...v]) => [k, v.join("=")])
+  );
+  const host = new URL(deps.checkpoint).host;
+  if (fields.host && fields.host !== host) return "";
+  return `username=${deps.agent}
+password=${deps.deviceCredential}
+`;
+}
+function runGitCredential(action, input, git = realGit) {
+  const read = (key) => {
+    try {
+      return git(["config", "--global", "--get", key]).trim();
+    } catch {
+      return void 0;
+    }
+  };
+  const loaded = loadEnrolment(fleetPaths());
+  const deviceCredential = loaded && "enrolment" in loaded ? loaded.enrolment.credential : void 0;
+  return gitCredentialAnswer(action, input, {
+    agent: read("astrasync.agent"),
+    checkpoint: read("astrasync.checkpoint"),
+    deviceCredential
+  });
+}
+
+// src/fleet/browse-proxy.ts
+var import_node_http = __toESM(require("http"));
+var import_node_https = __toESM(require("https"));
+var import_node_net = __toESM(require("net"));
+var import_node_tls = __toESM(require("tls"));
+
+// src/fleet/local-cert.ts
+var import_node_crypto5 = __toESM(require("crypto"));
+function len(n) {
+  if (n < 128) return Buffer.from([n]);
+  const bytes = [];
+  while (n > 0) {
+    bytes.unshift(n & 255);
+    n >>= 8;
+  }
+  return Buffer.from([128 | bytes.length, ...bytes]);
+}
+var tlv = (tag, body) => Buffer.concat([Buffer.from([tag]), len(body.length), body]);
+var seq2 = (...parts) => tlv(48, Buffer.concat(parts));
+var set2 = (...parts) => tlv(49, Buffer.concat(parts));
+var ctx = (n, body) => tlv(160 + n, body);
+function oid(dotted) {
+  const parts = dotted.split(".").map(Number);
+  const out = [parts[0] * 40 + parts[1]];
+  for (const p of parts.slice(2)) {
+    const enc = [p & 127];
+    let v = p >> 7;
+    while (v > 0) {
+      enc.unshift(v & 127 | 128);
+      v >>= 7;
+    }
+    out.push(...enc);
+  }
+  return tlv(6, Buffer.from(out));
+}
+function integer(buf) {
+  const b = buf[0] & 128 ? Buffer.concat([Buffer.from([0]), buf]) : buf;
+  return tlv(2, b);
+}
+function utcTime(d) {
+  const s = d.toISOString().replace(/[-:T]/g, "").slice(2, 14) + "Z";
+  return tlv(23, Buffer.from(s, "ascii"));
+}
+var ECDSA_SHA256 = seq2(oid("1.2.840.10045.4.3.2"));
+function name(cn) {
+  return seq2(set2(seq2(oid("2.5.4.3"), tlv(12, Buffer.from(cn, "utf8")))));
+}
+function createLocalCert(hosts, days = 30) {
+  const { privateKey, publicKey } = import_node_crypto5.default.generateKeyPairSync("ec", { namedCurve: "P-256" });
+  const spki = publicKey.export({ type: "spki", format: "der" });
+  const now = Date.now();
+  const san = seq2(...hosts.map((h) => tlv(130, Buffer.from(h, "ascii"))));
+  const extensions = ctx(
+    3,
+    seq2(
+      seq2(oid("2.5.29.17"), tlv(4, san)),
+      // subjectAltName
+      seq2(oid("2.5.29.19"), tlv(4, seq2()))
+      // basicConstraints: not a CA
+    )
+  );
+  const subject = name("AstraSync Local Guard (browse)");
+  const tbs = seq2(
+    ctx(0, integer(Buffer.from([2]))),
+    // v3
+    integer(import_node_crypto5.default.randomBytes(16)),
+    ECDSA_SHA256,
+    subject,
+    seq2(utcTime(new Date(now - 6e4)), utcTime(new Date(now + days * 864e5))),
+    subject,
+    spki,
+    extensions
+  );
+  const signature = import_node_crypto5.default.sign("sha256", tbs, privateKey);
+  const der = seq2(tbs, ECDSA_SHA256, tlv(3, Buffer.concat([Buffer.from([0]), signature])));
+  const b64 = der.toString("base64").match(/.{1,64}/g).join("\n");
+  return {
+    cert: `-----BEGIN CERTIFICATE-----
+${b64}
+-----END CERTIFICATE-----
+`,
+    key: privateKey.export({ type: "pkcs8", format: "pem" }).toString()
+  };
+}
+
+// src/fleet/browse-proxy.ts
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "proxy-connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "te",
+  "trailer",
+  "proxy-authorization"
+]);
+function cleanHeaders(h) {
+  const out = {};
+  for (const [k, v] of Object.entries(h)) if (!HOP_BY_HOP.has(k) && v !== void 0) out[k] = v;
+  return out;
+}
+async function startBrowseProxy(opts) {
+  const hosts = new Set(opts.hosts.map((h) => h.toLowerCase()));
+  const deviceHeader = `Device ${opts.deviceCredential}`;
+  const { cert, key } = createLocalCert([...hosts]);
+  function forward(req, res, target) {
+    const headers = cleanHeaders(req.headers);
+    headers["x-astra-device"] = deviceHeader;
+    const mod = target.protocol === "https:" ? import_node_https.default : import_node_http.default;
+    const upstream = mod.request(
+      {
+        host: target.host,
+        port: target.port,
+        method: req.method,
+        path: target.path,
+        headers,
+        servername: target.protocol === "https:" ? String(req.headers.host ?? target.host).split(":")[0] : void 0,
+        rejectUnauthorized: target.rejectUnauthorized ?? true
+      },
+      (up) => {
+        res.writeHead(up.statusCode ?? 502, cleanHeaders(up.headers));
+        up.pipe(res);
+      }
+    );
+    upstream.on("error", () => {
+      if (!res.headersSent) res.writeHead(502, { "content-type": "text/plain" });
+      res.end("AstraSync browse proxy: upstream unreachable");
+    });
+    req.pipe(upstream);
+  }
+  function forwardUpgrade(req, socket, head, target) {
+    const headers = { ...req.headers };
+    delete headers["proxy-connection"];
+    delete headers["proxy-authorization"];
+    delete headers["x-astra-device"];
+    if (target.addDevice) headers["x-astra-device"] = deviceHeader;
+    const lines = [`${req.method} ${target.path} HTTP/1.1`];
+    for (const [k, v] of Object.entries(headers)) {
+      if (v === void 0) continue;
+      for (const one of Array.isArray(v) ? v : [v]) lines.push(`${k}: ${one}`);
+    }
+    const onConnect = () => {
+      upstream.write(lines.join("\r\n") + "\r\n\r\n");
+      if (head.length) upstream.write(head);
+      upstream.pipe(socket);
+      socket.pipe(upstream);
+    };
+    const upstream = target.protocol === "https:" ? import_node_tls.default.connect(
+      {
+        host: target.host,
+        port: target.port,
+        servername: String(req.headers.host ?? target.host).split(":")[0],
+        rejectUnauthorized: target.rejectUnauthorized ?? true
+      },
+      onConnect
+    ) : import_node_net.default.connect(target.port, target.host, onConnect);
+    upstream.on("error", () => socket.destroy());
+    socket.on("error", () => upstream.destroy());
+  }
+  const inner = import_node_http.default.createServer((req, res) => {
+    const hostHeader = String(req.headers.host ?? "");
+    const [h, p] = hostHeader.split(":");
+    const port2 = Number(p) || 443;
+    const up = opts.upstreamFor?.(h, port2) ?? { host: h, port: port2 };
+    forward(req, res, {
+      protocol: "https:",
+      host: up.host,
+      port: up.port,
+      path: req.url ?? "/",
+      rejectUnauthorized: up.rejectUnauthorized
+    });
+  });
+  const plainInner = import_node_http.default.createServer((req, res) => {
+    const [h, p] = String(req.headers.host ?? "").split(":");
+    forward(req, res, { protocol: "http:", host: h, port: Number(p) || 80, path: req.url ?? "/" });
+  });
+  plainInner.on("upgrade", (req, socket, head) => {
+    const [h, p] = String(req.headers.host ?? "").split(":");
+    forwardUpgrade(req, socket, head, {
+      protocol: "http:",
+      host: h,
+      port: Number(p) || 80,
+      path: req.url ?? "/",
+      addDevice: true
+    });
+  });
+  const server = import_node_http.default.createServer((req, res) => {
+    let url;
+    try {
+      url = new URL(req.url ?? "");
+    } catch {
+      res.writeHead(400).end("absolute URL required");
+      return;
+    }
+    if (hosts.has(url.hostname.toLowerCase())) {
+      forward(req, res, {
+        protocol: "http:",
+        host: url.hostname,
+        port: Number(url.port) || 80,
+        path: `${url.pathname}${url.search}`
+      });
+      return;
+    }
+    const upstream = import_node_http.default.request(
+      {
+        host: url.hostname,
+        port: Number(url.port) || 80,
+        method: req.method,
+        path: `${url.pathname}${url.search}`,
+        headers: cleanHeaders(req.headers)
+      },
+      (up) => {
+        res.writeHead(up.statusCode ?? 502, cleanHeaders(up.headers));
+        up.pipe(res);
+      }
+    );
+    upstream.on("error", () => res.writeHead(502).end());
+    req.pipe(upstream);
+  });
+  inner.on("upgrade", (req, socket, head) => {
+    const [h, p] = String(req.headers.host ?? "").split(":");
+    const port2 = Number(p) || 443;
+    const up = opts.upstreamFor?.(h, port2) ?? { host: h, port: port2 };
+    forwardUpgrade(req, socket, head, {
+      protocol: "https:",
+      host: up.host,
+      port: up.port,
+      path: req.url ?? "/",
+      addDevice: true,
+      rejectUnauthorized: up.rejectUnauthorized
+    });
+  });
+  server.on("upgrade", (req, socket, head) => {
+    let url;
+    try {
+      url = new URL(req.url ?? "");
+    } catch {
+      socket.destroy();
+      return;
+    }
+    forwardUpgrade(req, socket, head, {
+      protocol: "http:",
+      host: url.hostname,
+      port: Number(url.port) || 80,
+      path: `${url.pathname}${url.search}`,
+      addDevice: hosts.has(url.hostname.toLowerCase())
+    });
+  });
+  server.on("connect", (req, socket, head) => {
+    const [host, portStr] = String(req.url ?? "").split(":");
+    const port2 = Number(portStr) || 443;
+    if (hosts.has(host.toLowerCase())) {
+      socket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      const start = (first) => {
+        const s = socket;
+        s.pause();
+        s.unshift(first);
+        if (first[0] === 22) {
+          const tlsSocket = new import_node_tls.default.TLSSocket(s, {
+            isServer: true,
+            secureContext: import_node_tls.default.createSecureContext({ cert, key })
+          });
+          inner.emit("connection", tlsSocket);
+          tlsSocket.on("error", () => socket.destroy());
+        } else {
+          plainInner.emit("connection", s);
+          s.resume();
+        }
+      };
+      if (head.length) start(head);
+      else socket.once("data", (chunk) => start(chunk));
+      return;
+    }
+    const upstream = import_node_net.default.connect(port2, host, () => {
+      socket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      if (head.length) upstream.write(head);
+      upstream.pipe(socket);
+      socket.pipe(upstream);
+    });
+    upstream.on("error", () => socket.destroy());
+    socket.on("error", () => upstream.destroy());
+  });
+  await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+  const port = server.address().port;
+  return {
+    port,
+    close: () => new Promise((resolve) => {
+      inner.close();
+      plainInner.close();
+      server.close(() => resolve());
+      server.closeAllConnections?.();
+    })
+  };
+}
+
+// src/fleet/browse.ts
+async function runBrowse(paths, opts) {
+  const log = opts.log ?? ((l) => console.log(l));
+  const f = opts.fetchImpl ?? fetch;
+  const loaded = loadEnrolment(paths);
+  if (!loaded || !("enrolment" in loaded)) {
+    throw new Error("This machine is not enrolled. Run: astrasync guard enroll <token>");
+  }
+  const { credential, apiBaseUrl } = loaded.enrolment;
+  if (!opts.checkpoint || !opts.slug) throw new Error("--checkpoint and --slug are required");
+  const appOrigin = new URL(apiBaseUrl).origin;
+  const hosts = [new URL(apiBaseUrl).hostname, ...opts.extraHosts ?? []];
+  const device = `Device ${credential}`;
+  const proxy = await startBrowseProxy({ hosts, deviceCredential: credential, port: opts.port });
+  try {
+    const base2 = opts.checkpoint.replace(/\/+$/, "");
+    const signin = await f(
+      `${base2}/a/${encodeURIComponent(opts.slug)}/h/${encodeURIComponent(opts.upstream ?? "astrasync-api")}/agent-sessions`,
+      {
+        method: "POST",
+        headers: { authorization: device, "content-type": "application/json" },
+        body: "{}"
+      }
+    );
+    const body = await signin.json().catch(() => ({}));
+    if (signin.status !== 201 && signin.status !== 202) {
+      throw new Error(
+        `Sign-in refused (${signin.status}${body.code ? ` ${body.code}` : ""}): ${body.message ?? "no detail"}`
+      );
+    }
+    const sessionId = String(body.data?.sessionId ?? "");
+    let code = body.data?.code;
+    if (!code) {
+      log("Waiting for the owner to approve this sign-in with their passkey\u2026");
+      const deadline = Date.now() + (opts.waitMs ?? 10 * 6e4);
+      while (!code) {
+        if (Date.now() > deadline) throw new Error("The owner did not approve in time.");
+        await new Promise((r) => setTimeout(r, opts.pollIntervalMs ?? 3e3));
+        const poll = await f(
+          `${apiBaseUrl.replace(/\/+$/, "")}/agent-sessions/${sessionId}/status`,
+          {
+            headers: { "x-astra-device": device }
+          }
+        );
+        const p = await poll.json().catch(() => ({}));
+        const status = p.data?.status;
+        if (status === "approved") code = p.data?.code;
+        else if (status === "denied" || status === "ended")
+          throw new Error(`Sign-in ${status === "denied" ? "was not approved" : "ended"}.`);
+      }
+    }
+    const openUrl = `${appOrigin}/agent-session#code=${code}`;
+    log("");
+    log(`Signed in. Open this once (within 2 minutes), through the proxy:`);
+    log(`  ${openUrl}`);
+    log("");
+    log(
+      `Device proxy: http://127.0.0.1:${proxy.port}  (adds this machine's credential for ${hosts.join(", ")})`
+    );
+    log("Playwright:");
+    log(
+      `  chromium.launch({ proxy: { server: 'http://127.0.0.1:${proxy.port}' } }) + newContext({ ignoreHTTPSErrors: true })`
+    );
+    log("Requests that skip the proxy end the session. Ctrl-C stops the proxy.");
+    return { proxy, openUrl, sessionId };
+  } catch (err) {
+    await proxy.close();
+    throw err;
+  }
+}
+
 // src/cli/guard.ts
 var DEFAULT_POLICY_PATH = "./local-policy.yaml";
 var DEFAULT_CONFIG_DIR = ".astrasync";
@@ -7516,6 +7967,54 @@ async function cmdFleetStatus() {
   const status = await getFleetStatus(fleetPaths());
   for (const line of formatFleetStatus(status)) console.log(line);
 }
+async function cmdBrowse() {
+  try {
+    const port = flagValue("--port");
+    const { proxy } = await runBrowse(fleetPaths(), {
+      checkpoint: flagValue("--checkpoint") ?? "",
+      slug: flagValue("--slug") ?? "",
+      upstream: flagValue("--upstream"),
+      port: port ? Number(port) : void 0,
+      extraHosts: flagValue("--host") ? [flagValue("--host")] : []
+    });
+    const stop = async () => {
+      await proxy.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    await new Promise(() => void 0);
+  } catch (err) {
+    console.error(`browse failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function cmdGitRoute() {
+  try {
+    if (process.argv.includes("--undo")) {
+      const removed = removeGitRoute();
+      console.log(removed.length ? `Removed: ${removed.join(", ")}` : "No git route was set.");
+      return;
+    }
+    const lines = applyGitRoute({
+      checkpoint: flagValue("--checkpoint") ?? "",
+      slug: flagValue("--slug") ?? "",
+      agent: flagValue("--agent") ?? "",
+      upstream: flagValue("--upstream")
+    });
+    console.log("git now fetches and pushes github.com through your Workforce Guard checkpoint:");
+    for (const l of lines) console.log(`  ${l}`);
+    console.log("Commits still run your local hooks. Undo with: astrasync guard git-route --undo");
+  } catch (err) {
+    console.error(`git-route failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function cmdGitCredential() {
+  const action = process.argv[process.argv.indexOf("git-credential") + 1] ?? "";
+  const input = fs.readFileSync(0, "utf-8");
+  process.stdout.write(runGitCredential(action, input));
+}
 async function cmdManagedSettings() {
   const targets = [];
   if (process.argv.includes("--claude")) targets.push("claude");
@@ -7584,6 +8083,15 @@ async function main() {
     case "managed-settings":
       await cmdManagedSettings();
       break;
+    case "git-route":
+      await cmdGitRoute();
+      break;
+    case "browse":
+      await cmdBrowse();
+      break;
+    case "git-credential":
+      await cmdGitCredential();
+      break;
     default:
       console.log("AstraSync Local Guard\n");
       console.log("Usage: astrasync guard <command>\n");
@@ -7604,10 +8112,21 @@ async function main() {
       console.log("  install-codex          Install the Local Guard hook for OpenAI Codex CLI");
       console.log("                         (same flags; policy shared with Claude Code)");
       console.log("  uninstall-codex        Remove the Codex hook (--project for project scope)");
+      console.log(
+        "  browse                 Sign an agent in to your dashboard from this machine and"
+      );
+      console.log(
+        "                         run its device proxy (--checkpoint <url> --slug <agent>)"
+      );
       console.log("  enroll <token>         Enrol this machine in your organisation fleet");
       console.log("                         (--api-base-url <url>, --system for machine scope)");
       console.log("  fleet-status           Show fleet enrolment, signed policy and heartbeat");
       console.log("  managed-settings       Print MDM templates (--claude, --codex, --out <dir>)");
+      console.log("  git-route              Route git through your Workforce Guard checkpoint");
+      console.log(
+        "                         (--checkpoint <url> --slug <connector> --agent <ASTRA-id>;"
+      );
+      console.log("                          --undo to remove)");
       console.log("");
       process.exit(command ? 1 : 0);
   }