@integrity-labs/agt-cli 0.28.575 → 0.28.577

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-Q76HILWC.js";
+} from "../chunk-FOMHYTFV.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -4853,7 +4853,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.575" : "dev";
+var cliVersion = true ? "0.28.577" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6031,7 +6031,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.575" : "dev";
+var cliVersion2 = true ? "0.28.577" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-Q76HILWC.js → chunk-FOMHYTFV.js}

@@ -617,31 +617,344 @@ function writeXurlStoreForIntegrations(integrations, filePath = getXurlStorePath
 
 // ../../packages/core/dist/crypto/secret.js
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
-var ALGORITHM = "aes-256-gcm";
-var AUTH_TAG_LENGTH = 16;
+
+// ../../packages/core/dist/crypto/envelope.js
+import { createHash } from "crypto";
+
+// ../../packages/core/dist/crypto/envelope-cbor.js
+var MAJOR_UINT = 0;
+var MAJOR_TSTR = 3;
+var MAJOR_ARRAY = 4;
+var MAJOR_MAP = 5;
+var CborDecodeError = class extends Error {
+};
+function readHead(buf, offset) {
+  if (offset >= buf.length)
+    throw new CborDecodeError("cbor: truncated (expected head)");
+  const first = buf[offset];
+  const major = first >> 5;
+  const ai = first & 31;
+  if (ai < 24)
+    return { major, arg: ai, next: offset + 1 };
+  if (ai === 24) {
+    if (offset + 2 > buf.length)
+      throw new CborDecodeError("cbor: truncated uint8 arg");
+    const arg = buf[offset + 1];
+    if (arg < 24)
+      throw new CborDecodeError("cbor: non-canonical (uint8 < 24)");
+    return { major, arg, next: offset + 2 };
+  }
+  if (ai === 25) {
+    if (offset + 3 > buf.length)
+      throw new CborDecodeError("cbor: truncated uint16 arg");
+    const arg = buf.readUInt16BE(offset + 1);
+    if (arg < 256)
+      throw new CborDecodeError("cbor: non-canonical (uint16 < 256)");
+    return { major, arg, next: offset + 3 };
+  }
+  if (ai === 26) {
+    if (offset + 5 > buf.length)
+      throw new CborDecodeError("cbor: truncated uint32 arg");
+    const arg = buf.readUInt32BE(offset + 1);
+    if (arg < 65536)
+      throw new CborDecodeError("cbor: non-canonical (uint32 < 65536)");
+    return { major, arg, next: offset + 5 };
+  }
+  throw new CborDecodeError(`cbor: unsupported additional-info ${ai}`);
+}
+function decodeValue(buf, offset) {
+  const head = readHead(buf, offset);
+  switch (head.major) {
+    case MAJOR_UINT:
+      return { value: head.arg, next: head.next };
+    case MAJOR_TSTR: {
+      const end = head.next + head.arg;
+      if (end > buf.length)
+        throw new CborDecodeError("cbor: truncated text string");
+      const bytes = buf.subarray(head.next, end);
+      const str = bytes.toString("utf8");
+      if (!Buffer.from(str, "utf8").equals(bytes)) {
+        throw new CborDecodeError("cbor: invalid UTF-8 in text string");
+      }
+      return { value: str, next: end };
+    }
+    case MAJOR_ARRAY: {
+      const arr = [];
+      let cursor = head.next;
+      for (let i = 0; i < head.arg; i++) {
+        const decoded = decodeValue(buf, cursor);
+        arr.push(decoded.value);
+        cursor = decoded.next;
+      }
+      return { value: arr, next: cursor };
+    }
+    case MAJOR_MAP: {
+      const obj = {};
+      let cursor = head.next;
+      let prevKeyBytes = null;
+      for (let i = 0; i < head.arg; i++) {
+        const keyStart = cursor;
+        const keyHead = readHead(buf, cursor);
+        if (keyHead.major !== MAJOR_TSTR) {
+          throw new CborDecodeError("cbor: map keys must be text strings");
+        }
+        const keyDecoded = decodeValue(buf, cursor);
+        const keyBytes = buf.subarray(keyStart, keyDecoded.next);
+        if (prevKeyBytes !== null && Buffer.compare(keyBytes, prevKeyBytes) <= 0) {
+          throw new CborDecodeError("cbor: map keys not in canonical order or duplicated");
+        }
+        prevKeyBytes = Buffer.from(keyBytes);
+        const valDecoded = decodeValue(buf, keyDecoded.next);
+        obj[keyDecoded.value] = valDecoded.value;
+        cursor = valDecoded.next;
+      }
+      return { value: obj, next: cursor };
+    }
+    default:
+      throw new CborDecodeError(`cbor: unsupported major type ${head.major}`);
+  }
+}
+function decodeCanonicalCbor(buf) {
+  const { value, next } = decodeValue(buf, 0);
+  if (next !== buf.length) {
+    throw new CborDecodeError(`cbor: ${buf.length - next} trailing byte(s) after top-level item`);
+  }
+  return value;
+}
+
+// ../../packages/core/dist/crypto/secret-errors.js
+var SecretDecryptError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+};
+var MalformedEnvelopeError = class extends SecretDecryptError {
+  code = "MalformedEnvelope";
+  scope = "row";
+};
+var UnknownSchemeError = class extends SecretDecryptError {
+  code = "UnknownScheme";
+  scope = "row";
+};
+var AppKeyNotInKeyringError = class extends SecretDecryptError {
+  code = "AppKeyNotInKeyring";
+  scope = "app-key";
+};
+var PlatformKekUnavailableError = class extends SecretDecryptError {
+  code = "PlatformKekUnavailable";
+  scope = "all-tenants";
+};
+var CustomerKekUnavailableError = class extends SecretDecryptError {
+  code = "CustomerKekUnavailable";
+  scope = "one-org";
+};
+var AeadAuthFailureError = class extends SecretDecryptError {
+  code = "AeadAuthFailure";
+  scope = "row";
+};
+var DecryptContextRequiredError = class extends SecretDecryptError {
+  code = "DecryptContextRequired";
+  scope = "caller";
+};
+
+// ../../packages/core/dist/crypto/envelope.js
 var PREFIX = "enc:";
-function getKey() {
-  const hex = process.env["AUTH_ENCRYPTION_KEY"];
-  if (!hex || hex.length !== 64) {
-    throw new Error("AUTH_ENCRYPTION_KEY must be a 64-char hex string (32 bytes)");
+var V2_MARKER = "2";
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+var KID_RE = /^[0-9a-f]{8}$/;
+function deriveKid(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 8);
+}
+function isPlainRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function decodeWrapList(w) {
+  if (!Array.isArray(w) || w.length === 0) {
+    throw new MalformedEnvelopeError("envelope: scheme k/c header requires a non-empty wrap list");
+  }
+  return w.map((entry) => {
+    if (!isPlainRecord(entry)) {
+      throw new MalformedEnvelopeError("envelope: wrap entry must be a map");
+    }
+    const keys = Object.keys(entry).sort();
+    if (keys.length !== 2 || keys[0] !== "dek" || keys[1] !== "ref") {
+      throw new MalformedEnvelopeError("envelope: wrap entry must have exactly {ref, dek}");
+    }
+    if (typeof entry.ref !== "string" || typeof entry.dek !== "string") {
+      throw new MalformedEnvelopeError("envelope: wrap entry ref/dek must be strings");
+    }
+    return { ref: entry.ref, dek: entry.dek };
+  });
+}
+function decodeHeader(bytes) {
+  let decoded;
+  try {
+    decoded = decodeCanonicalCbor(bytes);
+  } catch (cause) {
+    throw new MalformedEnvelopeError("envelope: header is not canonical CBOR", { cause });
+  }
+  if (!isPlainRecord(decoded) || typeof decoded.s !== "string") {
+    throw new MalformedEnvelopeError("envelope: header must be a map with a string `s`");
+  }
+  const keys = Object.keys(decoded).sort();
+  if (decoded.s === "a") {
+    if (keys.length !== 2 || keys[0] !== "kid" || keys[1] !== "s") {
+      throw new MalformedEnvelopeError("envelope: scheme a header must have exactly {s, kid}");
+    }
+    if (typeof decoded.kid !== "string" || !KID_RE.test(decoded.kid)) {
+      throw new MalformedEnvelopeError("envelope: scheme a kid must be 8 lowercase hex chars");
+    }
+    return { s: "a", kid: decoded.kid };
   }
-  return Buffer.from(hex, "hex");
+  if (decoded.s === "k" || decoded.s === "c") {
+    if (keys.length !== 2 || keys[0] !== "s" || keys[1] !== "w") {
+      throw new MalformedEnvelopeError("envelope: scheme k/c header must have exactly {s, w}");
+    }
+    return { s: decoded.s, w: decodeWrapList(decoded.w) };
+  }
+  throw new UnknownSchemeError(`envelope: unknown scheme ${JSON.stringify(decoded.s)}`);
+}
+function decodeStrict(part, encoding, what) {
+  const buf = Buffer.from(part, encoding);
+  if (buf.length === 0)
+    throw new MalformedEnvelopeError(`envelope: empty ${what}`);
+  if (buf.toString(encoding) !== part) {
+    throw new MalformedEnvelopeError(`envelope: non-canonical ${encoding} in ${what}`);
+  }
+  return buf;
 }
-function decryptSecret(encoded) {
+function assertShape(iv, data) {
+  if (iv.length !== IV_LENGTH) {
+    throw new MalformedEnvelopeError(`envelope: iv must be ${IV_LENGTH} bytes, got ${iv.length}`);
+  }
+  if (data.length < AUTH_TAG_LENGTH) {
+    throw new MalformedEnvelopeError("envelope: ciphertext shorter than the auth tag");
+  }
+}
+function parseEnvelope(encoded) {
   if (!encoded.startsWith(PREFIX)) {
-    return encoded;
+    throw new MalformedEnvelopeError("envelope: missing enc: prefix");
   }
-  const key = getKey();
   const parts = encoded.slice(PREFIX.length).split(":");
-  if (parts.length !== 2)
-    throw new Error("Invalid encrypted secret format");
-  const iv = Buffer.from(parts[0], "base64");
-  const data = Buffer.from(parts[1], "base64");
-  const ciphertext = data.subarray(0, data.length - AUTH_TAG_LENGTH);
-  const tag = data.subarray(data.length - AUTH_TAG_LENGTH);
-  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
+  if (parts.length === 2) {
+    const iv = decodeStrict(parts[0], "base64", "iv");
+    const data = decodeStrict(parts[1], "base64", "ciphertext");
+    assertShape(iv, data);
+    return { version: 1, iv, data };
+  }
+  if (parts.length === 4 && parts[0] === V2_MARKER) {
+    const headerBytes = decodeStrict(parts[1], "base64url", "header");
+    const header = decodeHeader(headerBytes);
+    const iv = decodeStrict(parts[2], "base64", "iv");
+    const data = decodeStrict(parts[3], "base64", "ciphertext");
+    assertShape(iv, data);
+    return { version: 2, header, headerBytes, iv, data };
+  }
+  throw new MalformedEnvelopeError("envelope: unrecognised layout");
+}
+function contextString(ctx) {
+  return `org:${ctx.orgId}:${ctx.table}:${ctx.column}:${ctx.field}:${ctx.rowId}`;
+}
+function buildAad(headerBytes, ctx) {
+  return Buffer.concat([headerBytes, Buffer.from(contextString(ctx), "utf8")]);
+}
+
+// ../../packages/core/dist/crypto/keyring.js
+var ACTIVE_ENV = "AUTH_ENCRYPTION_KEY";
+var PREVIOUS_ENV = "AUTH_ENCRYPTION_KEY_PREVIOUS";
+var HEX_KEY_RE = /^[0-9a-fA-F]{64}$/;
+var derivationCache = /* @__PURE__ */ new Map();
+function deriveEntry(hex) {
+  if (!hex || !HEX_KEY_RE.test(hex))
+    return null;
+  const cached = derivationCache.get(hex);
+  if (cached)
+    return cached;
+  const key = Buffer.from(hex, "hex");
+  const entry = { kid: deriveKid(key), key };
+  derivationCache.set(hex, entry);
+  return entry;
+}
+function getKeyring() {
+  const active = deriveEntry(process.env[ACTIVE_ENV]);
+  const retiring = deriveEntry(process.env[PREVIOUS_ENV]);
+  const byKid = /* @__PURE__ */ new Map();
+  const trialOrder = [];
+  for (const entry of [active, retiring]) {
+    if (!entry)
+      continue;
+    if (!byKid.has(entry.kid)) {
+      byKid.set(entry.kid, entry);
+      trialOrder.push(entry);
+    }
+  }
+  return { active, byKid, trialOrder };
+}
+function resolveKeyByKid(kid) {
+  return getKeyring().byKid.get(kid);
+}
+
+// ../../packages/core/dist/crypto/secret.js
+var ALGORITHM = "aes-256-gcm";
+var AUTH_TAG_LENGTH2 = 16;
+function gcmDecrypt(key, iv, data, aad) {
+  const ciphertext = data.subarray(0, data.length - AUTH_TAG_LENGTH2);
+  const tag = data.subarray(data.length - AUTH_TAG_LENGTH2);
+  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH2 });
+  if (aad)
+    decipher.setAAD(aad);
   decipher.setAuthTag(tag);
-  return decipher.update(ciphertext) + decipher.final("utf8");
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+}
+function decryptSecret(encoded, context) {
+  if (!encoded.startsWith(PREFIX)) {
+    return encoded;
+  }
+  const parsed = parseEnvelope(encoded);
+  if (parsed.version === 1) {
+    return decryptV1(parsed.iv, parsed.data);
+  }
+  switch (parsed.header.s) {
+    case "a": {
+      const entry = resolveKeyByKid(parsed.header.kid);
+      if (!entry) {
+        throw new AppKeyNotInKeyringError(`no app key with kid ${parsed.header.kid} in the keyring`);
+      }
+      if (!context) {
+        throw new DecryptContextRequiredError("decryptSecret: a v2 envelope requires a DecryptContext to reconstruct its AAD");
+      }
+      const aad = buildAad(parsed.headerBytes, context);
+      try {
+        return gcmDecrypt(entry.key, parsed.iv, parsed.data, aad);
+      } catch (cause) {
+        throw new AeadAuthFailureError(`scheme-a decrypt failed authentication for kid ${parsed.header.kid} (AAD mismatch or tampering)`, { cause });
+      }
+    }
+    // Schemes k/c are grammar this build parses but cannot unwrap — the KEK/DEK
+    // path is ADR-0062. A blob under either cannot exist in a 0061-only fleet
+    // (the writer never emits them); these throw so dispatch is total and typed.
+    case "k":
+      throw new PlatformKekUnavailableError("scheme k (platform-CMK DEK) unwrap is not available in this build (ADR-0062)");
+    case "c":
+      throw new CustomerKekUnavailableError("scheme c (customer-CMK DEK) unwrap is not available in this build (ADR-0062)");
+  }
+}
+function decryptV1(iv, data) {
+  const { trialOrder } = getKeyring();
+  if (trialOrder.length === 0) {
+    throw new AppKeyNotInKeyringError("the app-key keyring is empty (AUTH_ENCRYPTION_KEY unset)");
+  }
+  let lastError;
+  for (const entry of trialOrder) {
+    try {
+      return gcmDecrypt(entry.key, iv, data);
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw new AppKeyNotInKeyringError("no keyring key could decrypt a v1 blob (writing key absent or ciphertext corrupt)", { cause: lastError });
 }
 function isEncrypted(value) {
   return value.startsWith(PREFIX);
@@ -5646,7 +5959,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.575" : "dev";
+var agtCliVersion = true ? "0.28.577" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -8130,9 +8443,9 @@ async function gatherSessionToolBindProbe(agent, integrations, projectDir, opts)
 }
 
 // ../../packages/core/dist/provisioning/provisioner.js
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function sha256(content) {
-  return createHash("sha256").update(content, "utf8").digest("hex");
+  return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function provision(input, frameworkId = "claude-code") {
   const adapter = getFramework(frameworkId);
@@ -9015,4 +9328,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-Q76HILWC.js.map
+//# sourceMappingURL=chunk-FOMHYTFV.js.map