UNPKG

@fntio/infra-client

Version:

Self-hosted AWS access portal: credential vending, target-account trust, and grant-driven private networking as CDK stacks and constructs.

1,642 lines • 65.4 kB
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// ../infra-client-plugin-sdk/src/contracts/manifest.ts
var PLUGIN_PERMISSIONS, PLUGIN_ID_PATTERN, AWS_ACCOUNT_PATTERN;
var init_manifest = __esm({
  "../infra-client-plugin-sdk/src/contracts/manifest.ts"() {
    "use strict";
    PLUGIN_PERMISSIONS = ["user", "admin"];
    PLUGIN_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
    AWS_ACCOUNT_PATTERN = /^\d{12}$/;
  }
});

// ../infra-client-plugin-sdk/src/contracts/validate.ts
var init_validate = __esm({
  "../infra-client-plugin-sdk/src/contracts/validate.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/contracts/canonical.ts
var init_canonical = __esm({
  "../infra-client-plugin-sdk/src/contracts/canonical.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/contracts/paths.ts
var init_paths = __esm({
  "../infra-client-plugin-sdk/src/contracts/paths.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/contracts/access.ts
function parsePluginTargetKey(key) {
  if (!key.startsWith(PLUGIN_TARGET_PREFIX)) return null;
  const parts = key.slice(PLUGIN_TARGET_PREFIX.length).split("#");
  if (parts.length !== 3) return null;
  const [pluginId, accountNumber, permission] = parts;
  if (!PLUGIN_ID_PATTERN.test(pluginId) || !AWS_ACCOUNT_PATTERN.test(accountNumber)) return null;
  if (!PLUGIN_PERMISSIONS.includes(permission)) return null;
  return { pluginId, accountNumber, permission };
}
var PLUGIN_TARGET_PREFIX;
var init_access = __esm({
  "../infra-client-plugin-sdk/src/contracts/access.ts"() {
    "use strict";
    init_manifest();
    PLUGIN_TARGET_PREFIX = "plugin#";
  }
});

// ../infra-client-plugin-sdk/src/contracts/catalog.ts
var init_catalog = __esm({
  "../infra-client-plugin-sdk/src/contracts/catalog.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/contracts/discovery.ts
var init_discovery = __esm({
  "../infra-client-plugin-sdk/src/contracts/discovery.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/contracts/authorizer.ts
var init_authorizer = __esm({
  "../infra-client-plugin-sdk/src/contracts/authorizer.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/backend/context.ts
var init_context = __esm({
  "../infra-client-plugin-sdk/src/backend/context.ts"() {
    "use strict";
  }
});

// ../infra-client-plugin-sdk/src/backend/index.ts
var init_backend = __esm({
  "../infra-client-plugin-sdk/src/backend/index.ts"() {
    "use strict";
    init_manifest();
    init_validate();
    init_canonical();
    init_paths();
    init_access();
    init_catalog();
    init_discovery();
    init_authorizer();
    init_context();
  }
});

// lambdacode/api/services/access.ts
function parsePrincipal(p) {
  if (p.startsWith("user#")) return { kind: "user", userId: p.slice(5) };
  if (p.startsWith("group#")) return { kind: "group", groupId: p.slice(6) };
  return null;
}
function parseTarget(t) {
  if (t.startsWith("role#")) {
    const rest = t.slice(5);
    const hash = rest.indexOf("#");
    if (hash < 0) return null;
    return { kind: "role", accountNumber: rest.slice(0, hash), roleName: rest.slice(hash + 1) };
  }
  if (t.startsWith("resource#")) return { kind: "resource", resourceId: t.slice(9) };
  if (t.startsWith("share#")) return { kind: "share", shareId: t.slice(6) };
  if (t.startsWith("plugin#")) {
    const p = parsePluginTargetKey(t);
    return p ? { kind: "plugin", ...p } : null;
  }
  if (t.startsWith("member#")) return { kind: "member", groupId: t.slice(7) };
  if (t.startsWith("pref#role#")) {
    const rest = t.slice(10);
    const hash = rest.indexOf("#");
    if (hash < 0) return null;
    return { kind: "pref", accountNumber: rest.slice(0, hash), roleName: rest.slice(hash + 1) };
  }
  return null;
}
function isExpired(row, now = Date.now()) {
  return Boolean(row.expiresAt) && !(Date.parse(row.expiresAt) > now);
}
async function scanAll(opts = {}) {
  const rows = [];
  const prefixes = opts.targetPrefixes ?? [];
  const filter = prefixes.length ? {
    FilterExpression: prefixes.map((_, i) => `begins_with(#t, :p${i})`).join(" OR "),
    ExpressionAttributeNames: { "#t": "target" },
    ExpressionAttributeValues: Object.fromEntries(prefixes.map((p, i) => [`:p${i}`, p]))
  } : {};
  let ExclusiveStartKey;
  do {
    const page = await ddb.send(
      new import_lib_dynamodb.ScanCommand({ TableName: ACCESS_TABLE_NAME, ExclusiveStartKey, ...filter })
    );
    rows.push(...page?.Items ?? []);
    ExclusiveStartKey = page?.LastEvaluatedKey;
  } while (ExclusiveStartKey);
  return rows;
}
function entryOf(target, direct, groups, now) {
  const d = direct ? { grantedBy: direct.grantedBy, grantedAt: direct.grantedAt, expiresAt: direct.expiresAt } : void 0;
  const directActive = Boolean(direct && !isExpired(direct, now));
  const active = directActive || groups.length > 0;
  return {
    target,
    direct: d,
    groups,
    active,
    expiresAt: groups.length === 0 && directActive ? direct?.expiresAt : void 0
  };
}
function buildSnapshot(rows, now = Date.now()) {
  const groupTargets = /* @__PURE__ */ new Map();
  const groupMembers = /* @__PURE__ */ new Map();
  const directRows = /* @__PURE__ */ new Map();
  const userRows = [];
  const presence = /* @__PURE__ */ new Map();
  for (const r of rows) {
    const p = parsePrincipal(r.principal);
    if (!p) continue;
    if (p.kind === "user" && r.target === PRESENCE_TARGET) {
      if (typeof r.lastSeenAt === "string") presence.set(p.userId, r.lastSeenAt);
      continue;
    }
    if (p.kind === "group") {
      if (!isGrantTarget(r.target) || isExpired(r, now)) continue;
      const list = groupTargets.get(p.groupId) ?? [];
      list.push(r.target);
      groupTargets.set(p.groupId, list);
    } else if (r.target.startsWith("member#")) {
      const g = r.target.slice("member#".length);
      const list = groupMembers.get(g) ?? [];
      list.push(p.userId);
      groupMembers.set(g, list);
    } else if (isGrantTarget(r.target)) {
      const m = directRows.get(p.userId) ?? /* @__PURE__ */ new Map();
      m.set(r.target, r);
      directRows.set(p.userId, m);
      userRows.push(r);
    }
  }
  const users = /* @__PURE__ */ new Map();
  const groupsByUserTarget = /* @__PURE__ */ new Map();
  for (const [g, members] of groupMembers) {
    for (const u of members) {
      const m = groupsByUserTarget.get(u) ?? /* @__PURE__ */ new Map();
      for (const t of groupTargets.get(g) ?? []) {
        const list = m.get(t) ?? [];
        list.push(g);
        m.set(t, list);
      }
      groupsByUserTarget.set(u, m);
    }
  }
  const userIds = /* @__PURE__ */ new Set([...directRows.keys(), ...groupsByUserTarget.keys()]);
  for (const u of userIds) {
    const direct = directRows.get(u) ?? /* @__PURE__ */ new Map();
    const viaGroups = groupsByUserTarget.get(u) ?? /* @__PURE__ */ new Map();
    const targets = /* @__PURE__ */ new Set([...direct.keys(), ...viaGroups.keys()]);
    const m = /* @__PURE__ */ new Map();
    for (const t of targets) m.set(t, entryOf(t, direct.get(t), viaGroups.get(t) ?? [], now));
    users.set(u, m);
  }
  return { users, groupTargets, groupMembers, userRows, presence };
}
var import_client_dynamodb, import_lib_dynamodb, ddb, ACCESS_TABLE_NAME, SHARE_DEF_PRINCIPAL, PRESENCE_TARGET, isGrantTarget, isShareDefRow;
var init_access2 = __esm({
  "lambdacode/api/services/access.ts"() {
    "use strict";
    import_client_dynamodb = require("@aws-sdk/client-dynamodb");
    init_backend();
    import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
    ddb = import_lib_dynamodb.DynamoDBDocumentClient.from(new import_client_dynamodb.DynamoDBClient({}));
    ACCESS_TABLE_NAME = process.env.ACCESS_TABLE_NAME;
    SHARE_DEF_PRINCIPAL = "sharedef";
    PRESENCE_TARGET = "pref#presence";
    isGrantTarget = (t) => t.startsWith("role#") || t.startsWith("resource#") || t.startsWith("share#") || t.startsWith("plugin#");
    isShareDefRow = (r) => r.principal === SHARE_DEF_PRINCIPAL && typeof r.shareId === "string" && typeof r.ownerSub === "string" && typeof r.port === "number" && typeof r.siteId === "string" && typeof r.expiresAt === "string";
  }
});

// lambdacode/network/naming.ts
var headscaleUserName, NODE_NAME_LABEL, NODE_NAME_RE, nodeAnswersTo, DEFAULT_RESOURCE_PREFIX, parseConnectorVpcs, connectorHostname, sgManagerFnName, tailnetResolverFnName, aclReconcilerRelayFnName;
var init_naming = __esm({
  "lambdacode/network/naming.ts"() {
    "use strict";
    headscaleUserName = (cognitoSub) => `u-${cognitoSub}`;
    NODE_NAME_LABEL = "[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?";
    NODE_NAME_RE = new RegExp(`^${NODE_NAME_LABEL}$`);
    nodeAnswersTo = (node, name) => (node.givenName ?? "").toLowerCase() === name || (node.name ?? "").toLowerCase() === name;
    DEFAULT_RESOURCE_PREFIX = "infra-client";
    parseConnectorVpcs = (json) => new Map(
      Object.entries(JSON.parse(json ?? "{}")).filter(
        ([, v]) => Array.isArray(v)
      )
    );
    connectorHostname = (account, name) => name ? `connector-${account}-${name}` : `connector-${account}`;
    sgManagerFnName = (prefix, name) => name ? `${prefix}-sg-manager-${name}` : `${prefix}-sg-manager`;
    tailnetResolverFnName = (prefix, siteId, name) => name ? `${prefix}-tailnet-resolver-${siteId}-${name}` : `${prefix}-tailnet-resolver-${siteId}`;
    aclReconcilerRelayFnName = (prefix) => `${prefix}-acl-reconciler-relay`;
  }
});

// lambdacode/api/services/actorContext.ts
function runAsActor(actor, fn) {
  return store.run(actor, fn);
}
function currentActor() {
  return store.getStore();
}
var import_async_hooks, store, systemActor;
var init_actorContext = __esm({
  "lambdacode/api/services/actorContext.ts"() {
    "use strict";
    import_async_hooks = require("async_hooks");
    store = new import_async_hooks.AsyncLocalStorage();
    systemActor = (job, name) => ({
      kind: "system",
      id: `system:${job}`,
      name: name ?? job
    });
  }
});

// lambdacode/api/services/httpErrors.ts
var init_httpErrors = __esm({
  "lambdacode/api/services/httpErrors.ts"() {
    "use strict";
  }
});

// lambdacode/api/services/pluginCatalog.ts
var import_client_dynamodb2, import_lib_dynamodb2, ddb2;
var init_pluginCatalog = __esm({
  "lambdacode/api/services/pluginCatalog.ts"() {
    "use strict";
    import_client_dynamodb2 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb2 = require("@aws-sdk/lib-dynamodb");
    ddb2 = import_lib_dynamodb2.DynamoDBDocumentClient.from(new import_client_dynamodb2.DynamoDBClient({}));
  }
});

// lambdacode/api/services/pluginAccess.ts
var init_pluginAccess = __esm({
  "lambdacode/api/services/pluginAccess.ts"() {
    "use strict";
    init_access2();
    init_pluginCatalog();
  }
});

// lambdacode/api/services/revocationsService.ts
var import_client_dynamodb3, import_lib_dynamodb3, ddb3, REVOCATIONS_TABLE_NAME;
var init_revocationsService = __esm({
  "lambdacode/api/services/revocationsService.ts"() {
    "use strict";
    import_client_dynamodb3 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb3 = require("@aws-sdk/lib-dynamodb");
    ddb3 = import_lib_dynamodb3.DynamoDBDocumentClient.from(new import_client_dynamodb3.DynamoDBClient({}));
    REVOCATIONS_TABLE_NAME = process.env.REVOCATIONS_TABLE_NAME;
  }
});

// lambdacode/api/services/auditService.ts
function retentionDays() {
  const n = Number(process.env.AUDIT_RETENTION_DAYS);
  return Number.isInteger(n) && n > 0 ? n : DEFAULT_RETENTION_DAYS;
}
function tableOr() {
  const table = tableName();
  if (table) return table;
  if (!warnedNoTable) {
    warnedNoTable = true;
    log("WARN: AUDIT_TABLE_NAME unset \u2014 activity is not recorded");
  }
  return void 0;
}
function compact(value) {
  if (Array.isArray(value)) return value.map(compact);
  if (value && typeof value === "object" && !(value instanceof Set)) {
    const out = {};
    for (const [k, v] of Object.entries(value)) {
      if (v !== void 0) out[k] = compact(v);
    }
    return out;
  }
  return value;
}
function toRow(input, now) {
  const bound = input.actor ?? currentActor();
  if (!bound) log("ERROR: activity row without a bound actor (missing runAsActor?)", { action: input.action, target: input.target });
  const actor = bound ?? UNKNOWN_ACTOR;
  const token = actor.token;
  const details = input.details ? { ...input.details } : void 0;
  if (details?.note !== void 0) details.note = String(details.note).slice(0, NOTE_MAX);
  if (details?.affected && details.affected.length > AFFECTED_CAP) {
    details.affectedCount = details.affected.length;
    details.affected = details.affected.slice(0, AFFECTED_CAP);
  }
  if (details?.unchanged && details.unchanged.length > AFFECTED_CAP) {
    details.unchangedCount = details.unchanged.length;
    details.unchanged = details.unchanged.slice(0, AFFECTED_CAP);
  }
  const accountNumber = input.accountNumber ?? accountOf(input.target);
  return compact({
    ...input,
    eventId: (0, import_crypto.randomUUID)(),
    outcome: input.outcome ?? "OK",
    reason: input.reason === void 0 ? void 0 : String(input.reason).slice(0, REASON_MAX),
    actor: {
      kind: actor.kind,
      id: actor.id,
      name: actor.name,
      claims: actor.claims && Object.keys(actor.claims).length ? actor.claims : void 0,
      token: token && { id: token.id, name: token.name }
    },
    accountNumber,
    details,
    at: now.toISOString(),
    day: now.toISOString().slice(0, 10),
    userId: input.subject?.id,
    actorId: SESSION_ACTIONS.has(input.action) && input.subject?.kind === "user" ? input.subject.id : actor.id,
    expiresAt: Math.floor(now.getTime() / 1e3) + retentionDays() * 24 * 60 * 60
  });
}
function accountOf(target) {
  if (!target) return void 0;
  const p = parseTarget(target);
  if (p?.kind === "role" || p?.kind === "plugin") return p.accountNumber;
  if (target.startsWith("account#")) return target.slice("account#".length);
  return void 0;
}
async function recordEvents(inputs) {
  if (!inputs.length) return;
  const table = tableOr();
  if (!table) return;
  const start = Date.now();
  const rows = inputs.map((input, i) => toRow(input, new Date(start + i)));
  for (let i = 0; i < rows.length; i += 25) {
    let requests = rows.slice(i, i + 25).map((Item) => ({ PutRequest: { Item } }));
    try {
      for (let attempt = 0; attempt < 3 && requests.length; attempt++) {
        const res = await ddb4.send(new import_lib_dynamodb4.BatchWriteCommand({ RequestItems: { [table]: requests } }));
        requests = res.UnprocessedItems?.[table] ?? [];
      }
      if (requests.length) log("ERROR: activity batch left unprocessed rows", { count: requests.length });
    } catch (err) {
      log("ERROR: activity batch write failed (mutation unaffected)", { count: requests.length, error: err.message });
    }
  }
  log("activity batch recorded", { count: rows.length, actions: [...new Set(rows.map((r) => r.action))] });
}
var import_crypto, import_client_dynamodb4, import_lib_dynamodb4, ddb4, tableName, log, DEFAULT_RETENTION_DAYS, REASON_MAX, NOTE_MAX, AFFECTED_CAP, DAY_MS, newBatchId, UNKNOWN_ACTOR, warnedNoTable, SESSION_ACTIONS;
var init_auditService = __esm({
  "lambdacode/api/services/auditService.ts"() {
    "use strict";
    import_crypto = require("crypto");
    import_client_dynamodb4 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb4 = require("@aws-sdk/lib-dynamodb");
    init_actorContext();
    init_access2();
    ddb4 = import_lib_dynamodb4.DynamoDBDocumentClient.from(new import_client_dynamodb4.DynamoDBClient({}));
    tableName = () => process.env.AUDIT_TABLE_NAME ?? "";
    log = (msg, extra = {}) => console.log(JSON.stringify({ msg, ...extra }));
    DEFAULT_RETENTION_DAYS = 400;
    REASON_MAX = 300;
    NOTE_MAX = 500;
    AFFECTED_CAP = 50;
    DAY_MS = 24 * 60 * 60 * 1e3;
    newBatchId = () => (0, import_crypto.randomUUID)();
    UNKNOWN_ACTOR = { kind: "system", id: "system:unknown" };
    warnedNoTable = false;
    SESSION_ACTIONS = /* @__PURE__ */ new Set(["vpn.connect", "vpn.disconnect"]);
  }
});

// lambdacode/api/services/accessNotices.ts
var init_accessNotices = __esm({
  "lambdacode/api/services/accessNotices.ts"() {
    "use strict";
    init_access2();
    init_pluginAccess();
    init_revocationsService();
    init_auditService();
  }
});

// lambdacode/api/services/grantsService.ts
var import_client_dynamodb5, import_lib_dynamodb5, ddb5, ROLES_TABLE_NAME, EXPIRING_WINDOW_MS;
var init_grantsService = __esm({
  "lambdacode/api/services/grantsService.ts"() {
    "use strict";
    import_client_dynamodb5 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb5 = require("@aws-sdk/lib-dynamodb");
    init_httpErrors();
    init_access2();
    init_accessNotices();
    init_auditService();
    ddb5 = import_lib_dynamodb5.DynamoDBDocumentClient.from(new import_client_dynamodb5.DynamoDBClient({}));
    ROLES_TABLE_NAME = process.env.ROLES_TABLE_NAME;
    EXPIRING_WINDOW_MS = 24 * 60 * 60 * 1e3;
  }
});

// lambdacode/api/services/resourceGrantsService.ts
var import_client_dynamodb6, import_lib_dynamodb6, ddb6, RESOURCES_TABLE_NAME;
var init_resourceGrantsService = __esm({
  "lambdacode/api/services/resourceGrantsService.ts"() {
    "use strict";
    import_client_dynamodb6 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb6 = require("@aws-sdk/lib-dynamodb");
    init_httpErrors();
    init_access2();
    init_accessNotices();
    init_auditService();
    init_grantsService();
    init_resourcesService();
    ddb6 = import_lib_dynamodb6.DynamoDBDocumentClient.from(new import_client_dynamodb6.DynamoDBClient({}));
    RESOURCES_TABLE_NAME = process.env.RESOURCES_TABLE_NAME;
  }
});

// lambdacode/api/services/accountOrder.ts
var init_accountOrder = __esm({
  "lambdacode/api/services/accountOrder.ts"() {
    "use strict";
  }
});

// lambdacode/api/services/dimensions.ts
var init_dimensions = __esm({
  "lambdacode/api/services/dimensions.ts"() {
    "use strict";
  }
});

// lambdacode/api/services/catalogIndex.ts
var import_client_dynamodb7, import_lib_dynamodb7, ddb7, ACCOUNTS_TABLE_NAME, ROLES_TABLE_NAME2, GROUPS_TABLE_NAME, RESOURCES_TABLE_NAME2;
var init_catalogIndex = __esm({
  "lambdacode/api/services/catalogIndex.ts"() {
    "use strict";
    import_client_dynamodb7 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb7 = require("@aws-sdk/lib-dynamodb");
    init_accountOrder();
    init_dimensions();
    ddb7 = import_lib_dynamodb7.DynamoDBDocumentClient.from(new import_client_dynamodb7.DynamoDBClient({}));
    ACCOUNTS_TABLE_NAME = process.env.ACCOUNTS_TABLE_NAME;
    ROLES_TABLE_NAME2 = process.env.ROLES_TABLE_NAME;
    GROUPS_TABLE_NAME = process.env.GROUPS_TABLE_NAME;
    RESOURCES_TABLE_NAME2 = process.env.RESOURCES_TABLE_NAME;
  }
});

// lambdacode/api/services/groupsService.ts
var import_client_dynamodb8, import_lib_dynamodb8, ddb8, GROUPS_TABLE_NAME2, ROLES_TABLE_NAME3, RESOURCES_TABLE_NAME3;
var init_groupsService = __esm({
  "lambdacode/api/services/groupsService.ts"() {
    "use strict";
    import_client_dynamodb8 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb8 = require("@aws-sdk/lib-dynamodb");
    init_httpErrors();
    init_access2();
    init_accessNotices();
    init_auditService();
    init_catalogIndex();
    init_resourcesService();
    ddb8 = import_lib_dynamodb8.DynamoDBDocumentClient.from(new import_client_dynamodb8.DynamoDBClient({}));
    GROUPS_TABLE_NAME2 = process.env.GROUPS_TABLE_NAME;
    ROLES_TABLE_NAME3 = process.env.ROLES_TABLE_NAME;
    RESOURCES_TABLE_NAME3 = process.env.RESOURCES_TABLE_NAME;
  }
});

// lambdacode/api/services/resourcesService.ts
var import_client_dynamodb9, import_lib_dynamodb9, ddb9, RESOURCES_TABLE_NAME4, ACCOUNTS_TABLE_NAME2, isSentinelRow;
var init_resourcesService = __esm({
  "lambdacode/api/services/resourcesService.ts"() {
    "use strict";
    import_client_dynamodb9 = require("@aws-sdk/client-dynamodb");
    import_lib_dynamodb9 = require("@aws-sdk/lib-dynamodb");
    init_httpErrors();
    init_resourceGrantsService();
    init_groupsService();
    init_access2();
    init_auditService();
    init_accessNotices();
    ddb9 = import_lib_dynamodb9.DynamoDBDocumentClient.from(new import_client_dynamodb9.DynamoDBClient({}));
    RESOURCES_TABLE_NAME4 = process.env.RESOURCES_TABLE_NAME;
    ACCOUNTS_TABLE_NAME2 = process.env.ACCOUNTS_TABLE_NAME;
    isSentinelRow = (resourceId) => String(resourceId).startsWith("__");
  }
});

// lambdacode/network/acl-reconciler.ts
var acl_reconciler_exports = {};
__export(acl_reconciler_exports, {
  RECONCILER_STATUS_KEY: () => RECONCILER_STATUS_KEY,
  cidrContains: () => cidrContains,
  handler: () => handler,
  isPrivateCidr: () => isPrivateCidr
});
module.exports = __toCommonJS(acl_reconciler_exports);
var import_client_dynamodb10 = require("@aws-sdk/client-dynamodb");

// lambdacode/network/headscale-http.ts
var https = __toESM(require("node:https"));
var import_client_ssm = require("@aws-sdk/client-ssm");
var ssm = new import_client_ssm.SSMClient({});
var sources = /* @__PURE__ */ new Map();
var cached = /* @__PURE__ */ new Map();
var CERT_TTL_MS = 6e4;
function trustHeadscale(url, certParam) {
  if (certParam) sources.set(new URL(url).origin, certParam);
}
async function certificateFor(origin, fresh) {
  const param = sources.get(origin);
  if (!param) throw new Error(`no certificate source registered for ${origin}`);
  const hit = cached.get(param);
  if (!fresh && hit && Date.now() - hit.at < CERT_TTL_MS) return hit.pem;
  const out = await ssm.send(new import_client_ssm.GetParameterCommand({ Name: param }));
  const pem = out.Parameter?.Value;
  if (!pem) throw new Error(`certificate parameter ${param} is empty`);
  cached.set(param, { pem, at: Date.now() });
  return pem;
}
var TLS_FAILURES = /* @__PURE__ */ new Set([
  "DEPTH_ZERO_SELF_SIGNED_CERT",
  "SELF_SIGNED_CERT_IN_CHAIN",
  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
  "CERT_SIGNATURE_FAILURE",
  "CERT_HAS_EXPIRED",
  "ERR_TLS_CERT_ALTNAME_INVALID"
]);
var isTlsFailure = (err) => TLS_FAILURES.has(String(err?.code));
function request2(url, init, ca) {
  return new Promise((resolve, reject) => {
    const headers = {};
    new Headers(init.headers ?? {}).forEach((v, k) => headers[k] = v);
    const req = https.request(
      url,
      { method: init.method ?? "GET", headers, ca: [ca] },
      (res) => {
        const chunks = [];
        res.on("data", (c) => chunks.push(c));
        res.on("error", reject);
        res.on(
          "end",
          () => resolve(
            new Response(Buffer.concat(chunks), {
              status: res.statusCode ?? 0,
              headers: Object.entries(res.headers).flatMap(
                ([k, v]) => v === void 0 ? [] : [v].flat().map((x) => [k, x])
              )
            })
          )
        );
      }
    );
    req.on("error", reject);
    const signal = init.signal;
    if (signal) {
      const abort = () => req.destroy(
        signal.reason instanceof Error ? signal.reason : new Error("aborted")
      );
      if (signal.aborted) abort();
      else signal.addEventListener("abort", abort, { once: true });
    }
    if (init.body !== void 0 && init.body !== null)
      req.write(init.body);
    req.end();
  });
}
async function headscaleFetch(url, init = {}) {
  if (!url.startsWith("https:")) return fetch(url, init);
  const origin = new URL(url).origin;
  try {
    return await request2(url, init, await certificateFor(origin, false));
  } catch (err) {
    if (!isTlsFailure(err)) throw err;
    return request2(url, init, await certificateFor(origin, true));
  }
}

// lambdacode/network/acl-reconciler.ts
var import_lib_dynamodb10 = require("@aws-sdk/lib-dynamodb");
var import_client_servicediscovery = require("@aws-sdk/client-servicediscovery");
var import_client_lambda2 = require("@aws-sdk/client-lambda");
var import_promises = require("node:dns/promises");
init_access2();
init_naming();

// lambdacode/network/invoke.ts
var import_client_lambda = require("@aws-sdk/client-lambda");
var INVOKE_TIMEOUT_MS = 1e4;
async function invokeParsed(client, functionName, payload, timeoutMs) {
  try {
    const res = await client.send(
      new import_client_lambda.InvokeCommand({ FunctionName: functionName, Payload: JSON.stringify(payload) }),
      { abortSignal: AbortSignal.timeout(timeoutMs) }
    );
    if (res.FunctionError) return { error: `function error: ${res.FunctionError}` };
    return { body: JSON.parse(new TextDecoder().decode(res.Payload)) };
  } catch (err) {
    return { error: err.message };
  }
}

// lambdacode/network/acl-reconciler.ts
init_actorContext();
init_resourcesService();
init_auditService();
var PREFIX = process.env.RESOURCE_PREFIX ?? DEFAULT_RESOURCE_PREFIX;
var HUB_ACCOUNT = process.env.HUB_ACCOUNT;
var RELAY_FN = aclReconcilerRelayFnName(PREFIX);
var connectorVpcs = /* @__PURE__ */ new Map();
var UNNAMED_HUB_VPC = [{}];
var inConfig = (account) => connectorVpcs.has(account);
var targetsOf = (account) => connectorVpcs.get(account) ?? UNNAMED_HUB_VPC;
var regionOfTarget = (t) => t.region ?? process.env.AWS_REGION;
var vpcNameOf = (account, nodeName) => targetsOf(account).find((t) => {
  if (!t.name) return false;
  const host = connectorHostname(account, t.name);
  return nodeName === host || nodeName.startsWith(`${host}-`);
})?.name;
var approvedRoutesByVpc = /* @__PURE__ */ new Map();
var vpcKey = (account, name) => `${account}#${name ?? ""}`;
var ownerOf = (account, cidr) => {
  const targets = targetsOf(account);
  if (targets.length === 1) return targets[0];
  return targets.find(
    (t) => (approvedRoutesByVpc.get(vpcKey(account, t.name)) ?? []).some(
      (route) => cidrContains(cidr, route)
    )
  );
};
var declaredRoutesByVpc = /* @__PURE__ */ new Map();
var declaredRoutesOf = (siteAccounts, account, nodeName) => {
  const own = declaredRoutesByVpc.get(vpcKey(account, vpcNameOf(account, nodeName)));
  if (own) return own;
  const siteDeclares = [...declaredRoutesByVpc.keys()].some(
    (k) => siteAccounts === null || siteAccounts.has(k.slice(0, k.indexOf("#")))
  );
  return siteDeclares ? [] : void 0;
};
var ddb10 = import_lib_dynamodb10.DynamoDBDocumentClient.from(new import_client_dynamodb10.DynamoDBClient({}));
var sd = new import_client_servicediscovery.ServiceDiscoveryClient({});
var lambda = new import_client_lambda2.LambdaClient({});
var RECONCILER_STATUS_KEY = "__reconciler-status__";
var RESOURCES_TABLE_NAME5 = process.env.RESOURCES_TABLE_NAME;
var STALE_CONNECTOR_MS = 15 * 60 * 1e3;
var CONNECTOR_PRUNE_MS = 24 * 60 * 60 * 1e3;
var DEVICE_IDLE_EXPIRE_MS = 7 * 24 * 60 * 60 * 1e3;
var log2 = (msg, extra = {}) => console.log(JSON.stringify({ msg, ...extra }));
function newPassAudit() {
  const enabled = Boolean(process.env.AUDIT_TABLE_NAME);
  const batchId = enabled ? newBatchId() : "";
  const rows = [];
  return {
    enabled,
    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
    rows,
    push(input) {
      if (!enabled) return;
      rows.push({ ...input, category: "network", details: { ...input.details, batchId } });
    }
  };
}
function sitesFromEnv() {
  const raw = process.env.HEADSCALE_SITES;
  if (!raw) {
    trustHeadscale(process.env.HEADSCALE_API_URL, process.env.HEADSCALE_TLS_PARAM);
    return [
      {
        id: "",
        apiUrl: process.env.HEADSCALE_API_URL,
        auth: { Authorization: `Bearer ${process.env.HEADSCALE_API_KEY}` },
        accounts: null,
        resolvers: (process.env.SPLIT_DNS_RESOLVERS ?? "").split(",").map((ip) => ip.trim()).filter(Boolean),
        sentinelKey: RECONCILER_STATUS_KEY
      }
    ];
  }
  const planes = JSON.parse(raw);
  for (const p of Object.values(planes)) trustHeadscale(p.url, p.certParam);
  const siteOfAccount = JSON.parse(process.env.SITE_ACCOUNTS ?? "{}");
  const splitBySite = JSON.parse(
    process.env.SPLIT_DNS_BY_SITE ?? "{}"
  );
  const names = JSON.parse(process.env.SITE_NAMES ?? "{}");
  return Object.keys(planes).sort().map((id) => ({
    id,
    displayName: typeof names[id] === "string" ? names[id] : void 0,
    apiUrl: planes[id].url,
    auth: { Authorization: `Bearer ${planes[id].key}` },
    accounts: new Set(
      Object.entries(siteOfAccount).filter(([, s]) => s === id).map(([a]) => a)
    ),
    resolvers: splitBySite[id] ?? [],
    sentinelKey: `${RECONCILER_STATUS_KEY}${id}`
  }));
}
var HEADSCALE_TIMEOUT_MS = 1e4;
var HEADSCALE_POLICY_TIMEOUT_MS = 3e4;
var DNS_HOLD_MS = 24 * 60 * 60 * 1e3;
var headscaleFetch2 = (url, init = {}, timeoutMs = HEADSCALE_TIMEOUT_MS) => headscaleFetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) });
var POLICY_MAX_BYTES = 39e5;
var CIDR_RE = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\/(\d{1,2})$/;
function parseCidr(cidr) {
  if (typeof cidr !== "string") return null;
  const m = cidr.trim().match(CIDR_RE);
  if (!m) return null;
  const octets = m.slice(1, 5).map(Number);
  const prefix = Number(m[5]);
  if (octets.some((o) => o > 255) || prefix > 32) return null;
  const base = (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
  return { base, prefix };
}
function cidrContains(inner, outer) {
  const a = parseCidr(inner);
  const b = parseCidr(outer);
  if (!a || !b) return false;
  if (a.prefix < b.prefix) return false;
  const mask = b.prefix === 0 ? 0 : ~0 << 32 - b.prefix >>> 0;
  return (a.base & mask) >>> 0 === (b.base & mask) >>> 0;
}
var PRIVATE_SPACE = ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"];
function isPrivateCidr(cidr) {
  return PRIVATE_SPACE.some((space) => cidrContains(cidr, space));
}
function isIpv4(s) {
  const m = s.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
  return m !== null && m.slice(1).every((o) => Number(o) <= 255);
}
async function resolveCloudMapIps(dnsName) {
  const dot = dnsName.indexOf(".");
  if (dot <= 0) return [];
  try {
    const res = await Promise.race([
      sd.send(
        new import_client_servicediscovery.DiscoverInstancesCommand({
          ServiceName: dnsName.slice(0, dot),
          NamespaceName: dnsName.slice(dot + 1),
          MaxResults: 10
        })
      ),
      new Promise(
        (_, reject) => setTimeout(() => reject(new Error("cloud map timeout")), 3e3)
      )
    ]);
    return (res.Instances ?? []).map((i) => i.Attributes?.AWS_INSTANCE_IPV4).filter((ip) => Boolean(ip));
  } catch {
    return [];
  }
}
async function resolveDnsIps(dnsName) {
  try {
    const ips = await Promise.race([
      (0, import_promises.resolve4)(dnsName),
      new Promise(
        (_, reject) => setTimeout(() => reject(new Error("dns timeout")), 3e3)
      )
    ]);
    return ips.slice(0, 8);
  } catch {
    return [];
  }
}
async function invokeByName(account, fnName, payload, region) {
  if (region === process.env.AWS_REGION) {
    return invokeParsed(
      lambda,
      `arn:aws:lambda:${region}:${account}:function:${fnName}`,
      payload,
      INVOKE_TIMEOUT_MS
    );
  }
  const { body, error } = await invokeParsed(
    lambda,
    RELAY_FN,
    { region, account, fnName, payload },
    INVOKE_TIMEOUT_MS + 3e3
  );
  return error ? { error } : body;
}
var RESOLVER_BATCH = 64;
async function resolveRemoteIps(account, fnName, names, region) {
  const out = {};
  for (let i = 0; i < names.length; i += RESOLVER_BATCH) {
    const { body, error } = await invokeByName(
      account,
      fnName,
      { names: names.slice(i, i + RESOLVER_BATCH) },
      region
    );
    if (error) {
      log2("WARN: tailnet-resolver invoke failed", { account, fnName, error });
      return out;
    }
    const ips = body?.ips ?? {};
    for (const [name, list] of Object.entries(ips)) {
      const clean = (Array.isArray(list) ? list : []).filter(isIpv4).slice(0, 8);
      if (clean.length) out[name] = clean;
    }
  }
  return out;
}
var SG_FAILURE_REASON = {
  error: "the connector account's firewall manager could not update the group",
  "sg-sync-failed": "the connector account's firewall manager could not be reached",
  "not-found": "security group not found in the connector account",
  invalid: "malformed security group id"
};
async function syncSecurityGroups(resources, statusByResource, prior, audit) {
  const hub = process.env.AWS_REGION;
  const byAccount = /* @__PURE__ */ new Map();
  for (const r of resources) {
    if (!r.securityGroupId) continue;
    const list = byAccount.get(r.accountNumber) ?? [];
    list.push(r);
    byAccount.set(r.accountNumber, list);
  }
  const keep = new Set(byAccount.keys());
  for (const account of prior.accounts) {
    if (!byAccount.has(account)) byAccount.set(account, []);
  }
  const sameTarget = (a, b) => (a.name ?? null) === (b.name ?? null) && regionOfTarget(a) === regionOfTarget(b);
  const targetsByAccount = /* @__PURE__ */ new Map();
  for (const [account, rs] of byAccount) {
    const configured = inConfig(account);
    const wanted = rs.length || configured ? targetsOf(account) : prior.targets[account] ?? UNNAMED_HUB_VPC;
    const reachable = wanted.filter((t) => configured || regionOfTarget(t) === hub);
    for (const t of wanted) {
      if (reachable.includes(t)) continue;
      log2("ERROR: departed connector VPC in another region is unreachable \u2014 revoke its managed SG rules by hand", {
        account,
        ...t
      });
    }
    if (configured) {
      for (const before of prior.targets[account] ?? []) {
        if (wanted.some((t) => sameTarget(t, before))) continue;
        log2("WARN: a connector VPC left config \u2014 managed SG rules left there must be revoked by hand", {
          account,
          ...before
        });
      }
    }
    if (!reachable.length) {
      byAccount.delete(account);
      continue;
    }
    targetsByAccount.set(account, reachable);
  }
  const RANK = { ok: 3, "other-vpc": 0 };
  const rank = (status) => RANK[status] ?? 1;
  const toRule = (r) => ({
    securityGroupId: r.securityGroupId,
    // Same bounds as the ACL dst filter — the manager re-validates anyway.
    ports: (Array.isArray(r.ports) ? r.ports : []).filter(
      (p) => Number.isInteger(p) && p >= 1 && p <= 65535
    )
  });
  await Promise.all(
    [...byAccount].map(async ([account, rs]) => {
      const targets2 = targetsByAccount.get(account);
      const ownerOfResource = /* @__PURE__ */ new Map();
      const rulesFor = new Map(targets2.map((t) => [t, []]));
      for (const r of rs) {
        const owner = ownerOf(account, r.cidr);
        ownerOfResource.set(r.resourceId, owner);
        for (const t of owner ? [owner] : targets2) rulesFor.get(t)?.push(toRule(r));
      }
      const verdicts = /* @__PURE__ */ new Map();
      const failed = /* @__PURE__ */ new Map();
      await Promise.all(
        targets2.map(async (t) => {
          const { body, error: failure } = await invokeByName(
            account,
            sgManagerFnName(PREFIX, t.name),
            { rules: rulesFor.get(t) ?? [] },
            regionOfTarget(t)
          );
          if (failure) {
            failed.set(t, failure);
            log2("WARN: sg-manager sync failed", { account, ...t, error: failure });
            return;
          }
          verdicts.set(
            t,
            body?.statuses ?? {}
          );
        })
      );
      if (failed.size) keep.add(account);
      for (const t of targets2) {
        for (const [sgId, v] of Object.entries(verdicts.get(t) ?? {})) {
          if (v?.status !== "ok") continue;
          const served = rs.filter((r) => r.securityGroupId === sgId);
          const base = {
            target: `sg#${sgId}`,
            targetName: served.map((r) => r.name).join(", ") || void 0,
            accountNumber: account,
            details: {
              ...served.length === 1 ? { resourceId: served[0].resourceId } : {},
              resourceIds: served.map((r) => r.resourceId),
              vpcName: t.name,
              protocol: "tcp"
            }
          };
          if (typeof v.added === "number" && v.added > 0) {
            const ports = [...new Set((rulesFor.get(t) ?? []).filter((x) => x.securityGroupId === sgId).flatMap((x) => x.ports))];
            audit.push({ ...base, action: "sg.rule.add", details: { ...base.details, ports, added: v.added } });
          }
          if (typeof v.removed === "number" && v.removed > 0) {
            audit.push({ ...base, action: "sg.rule.remove", details: { ...base.details, removed: v.removed } });
          }
        }
      }
      for (const r of rs) {
        const entry = statusByResource[r.resourceId] ??= { status: "unknown" };
        const owner = ownerOfResource.get(r.resourceId);
        const asked = owner ? [owner] : targets2;
        let best;
        for (const t of asked) {
          const status = verdicts.get(t)?.[r.securityGroupId]?.status;
          if (status !== void 0 && (best === void 0 || rank(status) > rank(best))) best = status;
        }
        entry.sg = best !== void 0 && (best !== "other-vpc" || !asked.some((t) => failed.has(t))) ? best : "sg-sync-failed";
        entry.sgId = r.securityGroupId;
        const reason = SG_FAILURE_REASON[entry.sg];
        const before = prior.sgVerdicts.get(r.resourceId);
        if (!reason || before?.sg === entry.sg && before.sgId === r.securityGroupId) continue;
        const error = entry.sg === "sg-sync-failed" ? asked.map((t) => failed.get(t)).find(Boolean) : asked.map((t) => verdicts.get(t)?.[r.securityGroupId]).find((v) => v?.status === entry.sg)?.error;
        audit.push({
          action: "sg.rule.add",
          outcome: "FAILED",
          reason,
          target: `sg#${r.securityGroupId}`,
          targetName: r.name,
          accountNumber: account,
          details: { resourceId: r.resourceId, vpcName: owner?.name, protocol: "tcp", ports: toRule(r).ports, error }
        });
      }
    })
  );
  const accounts = [...keep].sort();
  const targets = {};
  for (const account of accounts) targets[account] = targetsByAccount.get(account) ?? [];
  return { accounts, targets };
}
function recordSiteActivity(audit, o, prev) {
  if (!audit.enabled) return;
  const target = `site#${o.site.id}`;
  const targetName = o.site.displayName ?? o.site.id;
  const connectorDetails = (c) => ({
    nodeName: c.name,
    nodeId: c.nodeId,
    accountNumber: c.account,
    vpcName: c.vpcName,
    trusted: c.trusted
  });
  for (const c of o.pruned) {
    audit.push({ action: "connector.prune", target, targetName, accountNumber: c.account, details: connectorDetails(c) });
  }
  if (!prev || typeof prev !== "object") return;
  const now = o.topology.devices;
  const was = prev.devices && typeof prev.devices === "object" ? prev.devices : {};
  const session = (sub, action) => audit.push({
    action,
    subject: { kind: "user", id: sub },
    target,
    targetName,
    details: { siteId: o.site.id, devices: now[sub]?.count ?? 0, observedAt: audit.observedAt, granularity: "5m" }
  });
  for (const [sub, d] of Object.entries(now)) {
    if (d.online && was[sub]?.online !== true) session(sub, "vpn.connect");
  }
  for (const [sub, d] of Object.entries(was)) {
    if (d?.online === true && now[sub]?.online !== true) session(sub, "vpn.disconnect");
  }
  const key = (c) => c.nodeId ?? c.name;
  const onlineBefore = new Set((Array.isArray(prev.connectors) ? prev.connectors : []).filter((c) => c?.online === true).map(key));
  for (const c of o.topology.connectors) {
    if (c.online && !onlineBefore.has(key(c))) {
      audit.push({ action: "connector.online", target, targetName, accountNumber: c.account, details: connectorDetails(c) });
    }
  }
}
var handler = () => runAsActor(systemActor("reconciler"), reconcile);
async function reconcile() {
  const audit = newPassAudit();
  const sites = sitesFromEnv();
  if (!sites.length) throw new Error("no sites configured (HEADSCALE_SITES empty)");
  connectorVpcs = parseConnectorVpcs(process.env.CONNECTOR_VPCS);
  declaredRoutesByVpc = new Map(
    Object.entries(JSON.parse(process.env.CONNECTOR_ROUTES ?? "{}")).filter(
      ([, v]) => Array.isArray(v)
    )
  );
  approvedRoutesByVpc = /* @__PURE__ */ new Map();
  const usersByResource = /* @__PURE__ */ new Map();
  const usersByShare = /* @__PURE__ */ new Map();
  const accessRows = await scanAll({ targetPrefixes: ["resource#", "share#", "member#"] });
  const graph = buildSnapshot(accessRows);
  const liveShares = accessRows.filter(isShareDefRow).filter((d) => !isExpired(d));
  for (const [userId, entries] of graph.users) {
    for (const e of entries.values()) {
      const parsed = parseTarget(e.target);
      if (!e.active) continue;
      if (parsed?.kind === "resource") {
        if (!usersByResource.has(parsed.resourceId)) usersByResource.set(parsed.resourceId, /* @__PURE__ */ new Set());
        usersByResource.get(parsed.resourceId).add(userId);
      } else if (parsed?.kind === "share") {
        if (!usersByShare.has(parsed.shareId)) usersByShare.set(parsed.shareId, /* @__PURE__ */ new Set());
        usersByShare.get(parsed.shareId).add(userId);
      }
    }
  }
  let cursor;
  const resources = [];
  const priorSgAccounts = /* @__PURE__ */ new Set();
  const priorSgTargets = {};
  const seenSentinelIds = [];
  const priorTopology = /* @__PURE__ */ new Map();
  const priorSgVerdicts = /* @__PURE__ */ new Map();
  const priorAddrs = /* @__PURE__ */ new Map();
  const passStartedAt = (/* @__PURE__ */ new Date()).toISOString();
  cursor = void 0;
  do {
    const page = await ddb10.send(
      new import_lib_dynamodb10.ScanCommand({
        TableName: RESOURCES_TABLE_NAME5,
        ExclusiveStartKey: cursor,
        ProjectionExpression: "resourceId, accountNumber, #name, cidr, ports, dnsName, securityGroupId, sgAccounts, sgTargets, sgRegions, topology, #statuses",
        ExpressionAttributeNames: { "#name": "name", "#statuses": "statuses" }
      })
    );
    for (const row of page.Items ?? []) {
      const rid = String(row.resourceId ?? "");
      if (rid.startsWith("__") && !rid.startsWith(RECONCILER_STATUS_KEY)) continue;
      if (rid.startsWith(RECONCILER_STATUS_KEY)) {
        if (row.topology && typeof row.topology === "object") {
          priorTopology.set(rid, row.topology);
        }
        if (row.statuses && typeof row.statuses === "object") {
          for (const [id, s] of Object.entries(row.statuses)) {
            if (s?.sg) priorSgVerdicts.set(id, { sg: s.sg, sgId: s.sgId });
            const recorded = Array.isArray(s?.addrIps) ? s.addrIps : s?.addr === "dns" ? [s.addrIp] : [];
            const ips = recorded.filter((ip) => typeof ip === "string" && isIpv4(ip));
            if (s?.addrName && ips.length) {
              priorAddrs.set(id, { name: s.addrName, ips, at: typeof s.addrAt === "string" ? s.addrAt : passStartedAt });
            }
          }
        }
        if (Array.isArray(row.sgAccounts)) {
          for (const a of row.sgAccounts) priorSgAccounts.add(a);
        }
        if (row.sgTargets && typeof row.sgTargets === "object") {
          for (const [a, list] of Object.entries(row.sgTargets)) {
            if (Array.isArray(list)) priorSgTargets[a] = list;
          }
        }
        if (row.sgRegions && typeof row.sgRegions === "object") {
          for (const [a, region] of Object.entries(row.sgRegions)) {
            priorSgTargets[a] ??= [{ region }];
          }
        }
        seenSentinelIds.push(rid);
        continue;
      }
      if (isSentinelRow(rid)) continue;
      resources.push(row);
    }
    cursor = page.LastEvaluatedKey;
  } while (cursor);
  const statusByResource = {};
  const skipped = [];
  const notEnrolled = /* @__PURE__ */ new Set();
  const autoApproved = [];
  const expiredDevices = [];
  const prunedConnectors = [];
  const outcomes = [];
  const mappedAccounts = sites[0].accounts === null ? null : new Set(sites.flatMap((s) => [...s.accounts]));
  for (const r of resources) {
    if (mappedAccounts && !mappedAccounts.has(r.accountNumber)) {
      statusByResource[r.resourceId] = { status: "no-site" };
      skipped.push({ resourceId: r.resourceId, reason: "no-site" });
    }
  }
  for (const site of sites) {
    const outcome = {
      site,
      acls: [],
      resourcesLive: 0,
      sharesLive: 0,
      shareStatuses: {},
      staleConnectors: [],
      supersededConnectors: [],
      pruned: [],
      resourceIds: /* @__PURE__ */ new Set(),
      topology: { connectors: [], devices: {} }
    };
    outcomes.push(outcome);
    const siteResources = site.accounts === null ? resources : resources.filter((r) => site.accounts.has(r.accountNumber));
    for (const r of siteResources) outcome.resourceIds.add(r.resourceId);
    try {
      const nodesRes = await headscaleFetch2(`${site.apiUrl}/api/v1/node`, {
        headers: site.auth
      });
      if (!nodesRes.ok) throw new Error(`node list: ${nodesRes.status}`);
      const { nodes = [] } = await nodesRes.json();
      const usersRes = await headscaleFetch2(`${site.apiUrl}/api/v1/user`, {
        headers: site.auth
      });
      if (!usersRes.ok) throw new Error(`user list: ${usersRes.status}`);
      const { users = [] } = await usersRes.json();
      const enrolledUsers = new Set(
        users.map((u) => u.name).filter((n) => Boolean(n))
      );
      const approvedByAccount = /* @__PURE__ */ new Map();
      const offlineTooLong = /* @__PURE__ */ new Set();
      const ipsByOwner = /* @__PURE__ */ new Map();
      const nodesByOwner = /* @__PURE__ */ new Map();
      for (const node of nodes) {
        const name = node.givenName || node.name || "";
        const owner = node.user?.name;
        const expired = Boolean(
          node.expiry && Date.parse(node.expiry) <= Date.now()
        );
        if (owner?.startsWith("u-") && !expired) {
          const set = ipsByOwner.get(owner) ?? /* @__PURE__ */ new Set();
          for (const ip of (node.ipAddresses ?? []).filter(isIpv4)) set.add(ip);
          if (set.size) ipsByOwner.set(owner, set);
          nodesByOwner.set(owner, [...nodesByOwner.get(owner) ?? [], node]);
        }
        if (owner?.startsWith("u-") && !expired) {
          const sub = owner.slice(2);
          const d = outcome.topology.devices[sub] ?? { count: 0, online: false };
          d.count++;
          d.online = d.online || node.online === true;
          if (node.lastSeen && (!d.lastSeen || node.lastSeen > d.lastSeen)) {
            d.lastSeen = node.lastSeen;
          }
          outcome.topology.devices[sub] = d;
        }
        if (owner && owner !== "infra" && node.id) {
          const idleSince = node.lastSeen ? Date.parse(node.lastSeen) : NaN;
          if (node.online === false && !expired && !Number.isNaN(idleSince) && Date.now() - idleSince > DEVICE_IDLE_EXPIRE_MS) {
            const res2 = await headscaleFetch2(
              `${site.apiUrl}/api/v1/node/${node.id}/expire`,
              { method: "POST", headers: site.auth }
            );
            if (res2.ok) expiredDevices.push(name);
            else log2("WARN: device expiry failed", { name, status: res2.status });
          }
        }
        const m = name.match(/^connector-(\d+)(?:-|$)/);
        if (!m) continue;
        const account = m[1];
        if (site.accounts !== null && !site.accounts.has(account)) {
          log2("WARN: connector account not in this site", {
            site: site.id,
            name,
            account
          });
          continue;
        }
        let approved = node.approvedRoutes ?? [];
        const advertised = node.availableRoutes ?? node.subnetRoutes ?? [];
        const unapproved = advertised.filter((r) => !approved.includes(r));
        const declared = declaredRoutesOf(site.accounts, account, name);
        const allowed = (r) => isPrivateCidr(r) && (declared === void 0 || declared.some((d) => cidrContains(r, d)));
        const wanted = unapproved.filter(allowed);
        const refused = unapproved.filter((r) => !allowed(r));
        if (node.user?.name === "infra" && refused.length) {
          log2("WARN: connector advertises routes that are not private or not declared for its VPC; not approved", { name, refused });
        }
        const undeclared = node.user?.name === "infra" ? approved.filter((r) => !allowed(r)) : [];
        if (undeclared.length) {
          log2("WARN: connector holds approved routes outside its VPC's declared ones", { name, undeclared });
        }
        if (node.user?.name === "infra" && node.id && wanted.length) {
          const res2 = await headscaleFetch2(
            `${site.apiUrl}/api/v1/node/${node.id}/approve_routes`,
            {
              method: "POST",
              headers: { ...site.auth, "Content-Type": "application/json" },
              body: JSON.stringify({ routes: [...approved, ...wanted] })
            }
          );
          if (res2.ok) {
            approved = [...approved, ...wanted];
            autoApproved.push(`${name}:${wanted.join("|")}`);
          } else {
            log2("WARN: route auto-approval failed", { name, status: res2.status });
          }
        }
        const vpcName = vpcNameOf(account, name);
        outcome.topology.connectors.push({
          account,
          name,
          ...vpcName ? { vpcName } : {},
          nodeId: node.id,
          trusted: node.user?.name === "infra",
          online: node.online === true,
          lastSeen: node.lastSeen,
          advertisedRoutes: advertised,
          approvedRoutes: approved
        });
        if (!approved.length) continue;
        const lastSeen = node.lastSeen ? Date.parse(node.lastSeen) : NaN;
        if (node.online === false && !Number.isNaN(lastSeen) && Date.now() - lastSeen > STALE_CONNECTOR_MS) {
          offlineTooLong.add(name);
        }
        const prior = approvedByAccount.get(account) ?? [];
        approvedByAccount.set(account, [.../* @__PURE__ */ new Set([...prior, ...approved])]);
        const key = vpcKey(account, vpcName);
        approvedRoutesByVpc.set(key, [.../* @__PURE__ */ new Set([...approvedRoutesByVpc.get(key) ?? [], ...approved])]);
      }
      const hasLiveReplacement = (c, forwarding) => outcome.topology.connectors.some(
        (o) => o.account === c.account && o.vpcName === c.vpcName && o.trusted && o.online && (!forwarding || o.approvedRoutes.length > 0)
      );
      for (const c of outcome.topology.connectors) {
        if (!offlineTooLong.has(c.name)) continue;
        const superseded = c.trusted && hasLiveReplacement(c, true);
        (superseded ? outcome.supersededConnectors : outcome.staleConnectors).push(c.name);
      }
      const prunedHere = [];
      for (const c of outcome.topology.connectors) {
        if (!c.trusted || c.online || !c.nodeId) continue;
        const seen = c.lastSeen ? Date.parse(c.lastSeen) : NaN;
        if (!hasLiveReplacement(c, false) || Number.isNaN(seen) || Date.now() - seen < CONNECTOR_PRUNE_MS) {
          continue;
        }
        const res2 = await headscaleFetch2(`${site.apiUrl}/api/v1/node/${c.nodeId}`, {
          method: "DELETE",
          headers: site.auth
        });
        if (res2.ok) prunedHere.push(c);
        else log2("WARN: connector prune failed", { name: c.name, status: res2.status });
      }
      if (prunedHere.length) {
        outcome.pruned = prunedHere;
        prunedConnectors.push(...prunedHere.map((c) => c.name));
        const notPruned = (n) => !prunedHere.some((c) => c.name === n);
        outcome.staleConnectors = outcome.staleConnectors.filter(notPruned);
        outcome.supersededConnectors = outcome.supersededConnectors.filter(notPruned);
        outcome.topology.connectors = outcome.topology.connectors.filter((c) => !prunedHere.includes(c));
      }
      const namesByTarget = /* @__PURE__ */ new Map();
      if (site.id) {
        for (const r of siteResources) {
          if (!r.dnsName || !usersByResource.has(r.resourceId)) continue;
          if (!approvedByAccount.has(r.accountNumber)) continue;
          const owner = ownerOf(r.accountNumber, r.cidr);
          const perTarget = namesByTarget.get(r.accountNumber) ?? /* @__PURE__ */ new Map();
          for (const t of owner ? [owner] : targetsOf(r.accountNumber)) {
            const set = perTarget.get(t) ?? /* @__PURE__ */ new Set();
            set.add(r.dnsName);
            perTarget.set(t, set);
          }
          namesByTarget.set(r.accountNumber, perTarget);
        }
      }
      const remoteIps = /* @__PURE__ */ new Map();
      await Promise.all(
        [...namesByTarget].flatMap(
          ([account, perTarget]) => [...perTarget].map(async ([t, names]) => {
            const m = await resolveRemoteIps(
              account,
              tailnetResolverFnName(PREFIX, site.id, t.name),
              [...names],
              regionOfTarget(t)
            );
            for (const [n, ips] of Object.entries(m)) {
              const key = `${account}#${n}`;
              if (!remoteIps.has(key)) remoteIps.set(key, ips);
            }
          })
        )
      );
      for (const r of siteResources) {
        const prior = priorAddrs.get(r.resourceId);
        const remembered = prior && prior.name === r.dnsName ? { addrName: prior.name, addrIps: prior.ips, addrAt: prior.at } : {};
        const users2 = usersByResource.get(r.resourceId);
        if (!users2) {
          statusByResource[r.resourceId] = { status: "no-grants", ...remembered };
          continue;
        }
        const approved = approvedByAccount.get(r.accountNumber);
        if (!approved) {
          skipped.push({ resourceId: r.resourceId, reason: "no-connector" });
          statusByResource[r.resourceId] = { status: "no-connector", ...remembered };
          continue;
        }
        let dstCidrs = [r.cidr];
        const addrInfo = {};
        if (r.dnsName) {
          addrInfo.addrName = r.dnsName;
          const hubOwned = r.accountNumber === HUB_ACCOUNT;
          let live = hubOwned ? await resolveCloudMapIps(r.dnsName) : [];
          if (!live.length) {
            live = remoteIps.get(`${r.accountNumber}#${r.dnsName}`) ?? [];
          }
          if (!live.length && (hubOwned || !(await resolveCloudMapIps(r.dnsName)).length)) {
            live = await resolveDnsIps(r.dnsName);
          }
          if (live.length) {
            dstCidrs = live.map((ip) => `${ip}/32`);
            addrInfo.addr = "dns";
          } else {
            addrInfo.addr = "dns-stale";
            const expired = !(Date.now() - Date.parse(remembered.addrAt ?? "") <= DNS_HOLD_MS);
            if (!remembered.addrIps || expired) {
              skipped.push({ resourceId: r.resourceId, reason: "dns-unresolved" });
              statusByResource[r.resourceId] = { status: "dns-unresolved", ...addrInfo };
              continue;
            }
            dstCidrs = remembered.addrIps.map((ip) => `${ip}/32`);
            addrInfo.addrIps = remembered.addrIps;
            addrInfo.addrAt = remembered.addrAt;
          }
        }
        const contained = dstCidrs.filter(
          (c) => approved.some((route) => cidrContains(c, route))
        );
        if (addrInfo.addr) {
          addrInfo.addrIp = (contained[0] ?? dstCidrs[0]).replace(/\/\d+$/, "");
          if (addrInfo.addr === "dns" && contained.length) {
            addrInfo.addrIps = contained.map((c) => c.replace(/\/\d+$/, ""));
            addrInfo.addrAt = passStartedAt;
          }
        }
        if (!contained.length) {
          skipped.push({
            resourceId: r.resourceId,
            reason: "outside-approved-routes"
          });
          statusByResource[r.resourceId] = { status: "outside-approved-routes", ...addrInfo };
          continue;
        }
        const ports = (Array.isArray(r.ports) ? r.ports : []).filter(
          (p) => Number.isInteger(p) && p >= 1 && p <= 65535
        );
        if (!ports.length) {
          skipped.push({ resourceId: r.resourceId, reason: "no-valid-ports" });
          statusByResource[r.resourceId] = { status: "no-valid-ports", ...addrInfo };
          continue;
        }
        outcome.resourcesLive++;
        statusByResource[r.resourceId] = {
          status: "live",
          users: [...users2].filter(
            (u) => enrolledUsers.has(headscaleUserName(u))
          ).length,
          ...addrInfo
        };
        for (const user of users2) {
          if (!enrolledUsers.has(headscaleUserName(user))) {
            notEnrolled.add(user);
            continue;
          }
          outcome.acls.push({
            action: "accept",
            src: [`${headscaleUserName(user)}@`],
            dst: contained.flatMap((c) => ports.map((p) => `${c}:${p}`))
          });
        }
      }
      const siteShares = site.accounts === null ? liveShares : liveShares.filter((sh) => sh.siteId === site.id);
      for (const sh of siteShares) {
        const entry = { status: "live" };
        outcome.shareStatuses[sh.shareId] = entry;
        const port = sh.port;
        if (!Number.isInteger(port) || port < 1 || port > 65535) {
          entry.status = "invalid-port";
          continue;
        }
        const ownerIps = sh.device ? [
          ...new Set(
            (nodesByOwner.get(headscaleUserName(sh.ownerSub)) ?? []).filter((n) => nodeAnswersTo(n, sh.device)).flatMap((n) => (n.ipAddresses ?? []).filter(isIpv4))
          )
        ] : [...ipsByOwner.get(headscaleUserName(sh.ownerSub)) ?? []];
        if (!ownerIps.length) {
          entry.status = sh.device ? "device-not-enrolled" : "owner-not-enrolled";
          continue;
        }
        const grantees = [...usersByShare.get(sh.shareId) ?? []].filter((u) => u !== sh.ownerSub);
        const enrolled = grantees.filter((u) => enrolledUsers.has(headscaleUserName(u)));
        for (const u of grantees) if (!enrolledUsers.has(headscaleUserName(u))) notEnrolled.add(u);
        if (sh.device) enrolled.push(sh.ownerSub);
        if (!enrolled.length) {
          entry.status = grantees.length ? "no-enrolled-grantees" : "no-grantees";
          continue;
        }
        entry.users = enrolled.filter((u) => u !== sh.ownerSub).length;
        outcome.sharesLive++;
        for (const u of enrolled) {
          outcome.acls.push({
            action: "accept",
            src: [`${headscaleUserName(u)}@`],
            dst: ownerIps.map((ip) => `${ip}/32:${port}`)
          });
        }
      }
      for (const ip of site.resolvers) {
        if (!isIpv4(ip)) {
          log2("WARN: skipping non-IPv4 split-DNS resolver", {
            site: site.id,
            value: ip
          });
          continue;
        }
        outcome.acls.push({ action: "accept", src: ["*"], dst: [`${ip}/32:53`] });
      }
      const policy = JSON.stringify({ acls: outcome.acls });
      const policyBytes = Buffer.byteLength(policy);
      if (policyBytes > POLICY_MAX_BYTES) {
        throw new Error(
          `policy is ${policyBytes} bytes, over the control server's ${POLICY_MAX_BYTES}-byte limit; grant through fewer, wider resources or split the site`
        );
      }
      if (policyBytes > POLICY_MAX_BYTES * 0.75) {
        log2("WARN: policy is near the control server's size limit", { site: site.id, policyBytes, limit: POLICY_MAX_BYTES });
      }
      const res = await headscaleFetch2(`${site.apiUrl}/api/v1/policy`, {
        method: "PUT",
        headers: { ...site.auth, "Content-Type": "application/json" },
        body: JSON.stringify({ policy })
      }, HEADSCALE_POLICY_TIMEOUT_MS);
      if (!res.ok) {
        const detail = await res.text().catch(() => "");
        throw new Error(`policy put: ${res.status} ${detail}`);
      }
    } catch (err) {
      outcome.putError = err.message;
      log2("ERROR: site pass failed", { site: site.id, error: outcome.putError });
    }
  }
  const sg = await syncSecurityGroups(
    resources,
    statusByResource,
    { accounts: [...priorSgAccounts].sort(), targets: priorSgTargets, sgVerdicts: priorSgVerdicts },
    audit
  );
  const carrierSiteId = outcomes.find((o) => !o.putError)?.site.id;
  for (const o of outcomes) {
    if (o.putError) continue;
    recordSiteActivity(audit, o, priorTopology.get(o.site.sentinelKey));
    const isCarrier = o.site.id === carrierSiteId;
    const siteStatuses = {};
    for (const [rid, entry] of Object.entries(statusByResource)) {
      const noSite = entry.status === "no-site";
      if (o.resourceIds.has(rid) || noSite && isCarrier) {
        siteStatuses[rid] = entry;
      }
    }
    try {
      await ddb10.send(
        new import_lib_dynamodb10.PutCommand({
          TableName: RESOURCES_TABLE_NAME5,
          Item: {
            resourceId: o.site.sentinelKey,
            ...o.site.id ? { siteId: o.site.id } : {},
            at: (/* @__PURE__ */ new Date()).toISOString(),
            statuses: siteStatuses,
            staleConnectors: o.staleConnectors,
            supersededConnectors: o.supersededConnectors,
            resourcesLive: o.resourcesLive,
            rules: o.acls.length,
            sharesLive: o.sharesLive,
            shares: o.shareStatuses,
            topology: o.topology,
            // Accounts (possibly still) holding our managed SG rules (+ which named / foreign-region VPCs) —
            // read back next pass to sweep departed ones. One carrier row (SG sync is global; reads union all rows).
            ...isCarrier ? { sgAccounts: sg.accounts, sgTargets: sg.targets } : {}
          }
        })
      );
    } catch (err) {
      log2("WARN: status write failed", {
        site: o.site.id,
        error: err.message
      });
    }
  }
  const currentKeys = new Set(sites.map((s) => s.sentinelKey));
  for (const rid of seenSentinelIds) {
    if (currentKeys.has(rid)) continue;
    try {
      await ddb10.send(
        new import_lib_dynamodb10.DeleteCommand({
          TableName: RESOURCES_TABLE_NAME5,
          Key: { resourceId: rid }
        })
      );
      log2("removed stale reconciler sentinel", { resourceId: rid });
    } catch (err) {
      log2("WARN: stale sentinel delete failed", {
        resourceId: rid,
        error: err.message
      });
    }
  }
  if (audit.rows.length) await recordEvents(audit.rows);
  const staleConnectors = outcomes.flatMap((o) => o.staleConnectors);
  const supersededConnectors = outcomes.flatMap((o) => o.supersededConnectors);
  console.log(
    JSON.stringify({
      _aws: {
        Timestamp: Date.now(),
        CloudWatchMetrics: [
          {
            Namespace: "InfraClient/Network",
            Dimensions: [[]],
            Metrics: [{ Name: "StaleConnectors", Unit: "Count" }]
          }
        ]
      },
      StaleConnectors: staleConnectors.length,
      staleConnectors,
      supersededConnectors
    })
  );
  const rules = outcomes.reduce((n, o) => n + o.acls.length, 0);
  log2("reconciled", {
    sites: outcomes.map((o) => ({
      site: o.site.id,
      rules: o.acls.length,
      resourcesLive: o.resourcesLive,
      sharesLive: o.sharesLive,
      shares: o.shareStatuses,
      error: o.putError
    })),
    resources: resources.length,
    resourcesSkipped: skipped,
    usersNotEnrolled: [...notEnrolled],
    autoApprovedRoutes: autoApproved,
    expiredIdleDevices: expiredDevices,
    prunedConnectors,
    staleConnectors,
    supersededConnectors,
    usersWithGrants: new Set(
      [...usersByResource.values()].flatMap((s) => [...s])
    ).size,
    rules,
    activityRows: audit.rows.length
  });
  const failed = outcomes.filter((o) => o.putError);
  if (failed.length) {
    throw new Error(
      failed.map((o) => `${o.site.id ? `site ${o.site.id}: ` : ""}${o.putError}`).join("; ")
    );
  }
  return { rules };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  RECONCILER_STATUS_KEY,
  cidrContains,
  handler,
  isPrivateCidr
});