@astrasyncai/verification-gateway 5.16.0 → 5.17.0

package/dist/bin/astrasync.js

@@ -36,7 +36,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    SDK_VERSION = "5.16.0";
+    SDK_VERSION = "5.17.0";
   }
 });
 
@@ -49,10 +49,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 SDK_USER_AGENT, sdkFetch;
@@ -611,9 +611,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;
@@ -644,9 +644,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) {
@@ -1520,18 +1520,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));
@@ -1543,9 +1543,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];
       }
     }
   }
@@ -1586,7 +1586,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");
       }
@@ -1608,7 +1608,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");
@@ -3938,10 +3938,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 },
@@ -4662,8 +4662,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));
@@ -7617,7 +7617,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
   );
@@ -7625,7 +7625,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: [
       {
@@ -8344,6 +8344,390 @@ var init_git_route = __esm({
   }
 });
 
+// src/fleet/local-cert.ts
+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]);
+}
+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"));
+}
+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()
+  };
+}
+var import_node_crypto5, tlv, seq2, set2, ctx, ECDSA_SHA256;
+var init_local_cert = __esm({
+  "src/fleet/local-cert.ts"() {
+    "use strict";
+    import_node_crypto5 = __toESM(require("crypto"));
+    tlv = (tag, body) => Buffer.concat([Buffer.from([tag]), len(body.length), body]);
+    seq2 = (...parts) => tlv(48, Buffer.concat(parts));
+    set2 = (...parts) => tlv(49, Buffer.concat(parts));
+    ctx = (n, body) => tlv(160 + n, body);
+    ECDSA_SHA256 = seq2(oid("1.2.840.10045.4.3.2"));
+  }
+});
+
+// src/fleet/browse-proxy.ts
+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?.();
+    })
+  };
+}
+var import_node_http, import_node_https, import_node_net, import_node_tls, HOP_BY_HOP;
+var init_browse_proxy = __esm({
+  "src/fleet/browse-proxy.ts"() {
+    "use strict";
+    import_node_http = __toESM(require("http"));
+    import_node_https = __toESM(require("https"));
+    import_node_net = __toESM(require("net"));
+    import_node_tls = __toESM(require("tls"));
+    init_local_cert();
+    HOP_BY_HOP = /* @__PURE__ */ new Set([
+      "connection",
+      "proxy-connection",
+      "keep-alive",
+      "transfer-encoding",
+      "upgrade",
+      "te",
+      "trailer",
+      "proxy-authorization"
+    ]);
+  }
+});
+
+// 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;
+  }
+}
+var init_browse = __esm({
+  "src/fleet/browse.ts"() {
+    "use strict";
+    init_enrolment_store();
+    init_browse_proxy();
+  }
+});
+
 // src/cli/guard.ts
 var guard_exports = {};
 function createPrompt() {
@@ -8878,6 +9262,28 @@ 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")) {
@@ -8975,6 +9381,9 @@ async function main() {
     case "git-route":
       await cmdGitRoute();
       break;
+    case "browse":
+      await cmdBrowse();
+      break;
     case "git-credential":
       await cmdGitCredential();
       break;
@@ -8998,6 +9407,12 @@ 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");
@@ -9030,6 +9445,7 @@ var init_guard = __esm({
     init_cli();
     init_enrolment_store();
     init_git_route();
+    init_browse();
     DEFAULT_POLICY_PATH = "./local-policy.yaml";
     DEFAULT_CONFIG_DIR = ".astrasync";
     main().catch((err) => {
@@ -9065,6 +9481,7 @@ COMMANDS:
   guard enroll <token>  Enrol this machine in your organisation's fleet
                         (--api-base-url <url>, --system for machine scope)
   guard fleet-status    Fleet enrolment, signed policy and heartbeat state
+  guard browse          Sign an agent in to your dashboard via this machine's device proxy
   guard managed-settings  MDM templates for Claude Code / Codex (--claude, --codex, --out <dir>)
 
 REGISTER OPTIONS:
@@ -9148,13 +9565,13 @@ async function main2() {
       baseUrl: config.baseUrl
     });
     if (command === "register") {
-      const name = commandArgs["name"];
-      if (!name) {
+      const name2 = commandArgs["name"];
+      if (!name2) {
         console.error("Error: --name is required for register command");
         process.exit(1);
       }
       const options = {
-        name,
+        name: name2,
         ...commandArgs["description"] && { description: commandArgs["description"] },
         ...commandArgs["agent-type"] && { agentType: commandArgs["agent-type"] },
         ...commandArgs["api-endpoint"] && { apiEndpoint: commandArgs["api-endpoint"] }

package/dist/browser/background.js

@@ -3988,7 +3988,7 @@ function getTrustLevel(score) {
 }
 
 // src/version.ts
-var SDK_VERSION = "5.16.0";
+var SDK_VERSION = "5.17.0";
 
 // src/http.ts
 var SDK_USER_AGENT = `astrasync-sdk/${SDK_VERSION}`;