@deployfoundation/foundation-deploy 0.2.51 → 0.2.53

package/dist/chunk-nvsj7bbw.js

@@ -0,0 +1,259 @@
+import {
+  instanceNames,
+  loadInstanceFile
+} from "./chunk-fjdgxw8h.js";
+
+// src/deploy/aws.ts
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// src/deploy/instance.ts
+import { dirname } from "node:path";
+var INSTANCE_FILE_ENV = "FOUNDATION_INSTANCE_FILE";
+function resolveInstanceFilePath(argv = [], env = {}) {
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    if (arg === "--instance") {
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("-"))
+        throw new Error("--instance needs a path, e.g. --instance .foundation/instance.yaml");
+      return next;
+    }
+    if (arg.startsWith("--instance=")) {
+      const value = arg.slice("--instance=".length);
+      if (value === "")
+        throw new Error("--instance needs a path");
+      return value;
+    }
+  }
+  const fromEnv = env[INSTANCE_FILE_ENV];
+  if (fromEnv !== undefined && fromEnv !== "")
+    return fromEnv;
+  throw new Error(`--instance <path> is required (or set ${INSTANCE_FILE_ENV}); it is the path to the deployment's instance YAML`);
+}
+function loadInstanceContext(path, cwd = process.cwd()) {
+  const file = loadInstanceFile(path, cwd);
+  return { ...file, root: dirname(file.path) };
+}
+function loadInstanceFromArgs(argv = process.argv.slice(2), env = process.env) {
+  return loadInstanceContext(resolveInstanceFilePath(argv, env));
+}
+function instanceBanner(context) {
+  const { instance } = context;
+  return `instance: ${instance.name} (account ${instance.aws.account}, region ${instance.aws.region})
+  file: ${context.path}
+  config: ${context.configPath}`;
+}
+
+// src/deploy/sh.ts
+import { spawn as nodeSpawn } from "node:child_process";
+function formatCommand(cmd, env) {
+  const prefix = Object.entries(env ?? {}).map(([k, v]) => `${k}=${quote(v)}`).join(" ");
+  const body = cmd.map(quote).join(" ");
+  return prefix === "" ? body : `${prefix} ${body}`;
+}
+function quote(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function start(cmd, opts, stdout) {
+  const [bin, ...rest] = cmd;
+  if (bin === undefined)
+    throw new Error("run: empty command");
+  const child = nodeSpawn(bin, rest, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+    stdio: [
+      opts.stdin === undefined ? "ignore" : "pipe",
+      stdout,
+      stdout === "inherit" ? "inherit" : "pipe"
+    ]
+  });
+  if (opts.stdin !== undefined && child.stdin !== null) {
+    child.stdin.end(opts.stdin);
+  }
+  return child;
+}
+function exited(child) {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve(code ?? (signal === null ? 1 : 128)));
+  });
+}
+function collect(stream) {
+  if (stream === null)
+    return Promise.resolve("");
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (c) => chunks.push(c));
+    stream.once("error", reject);
+    stream.once("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+async function run(cmd, opts = {}) {
+  if (opts.dryRun === true) {
+    console.log(`  $ ${formatCommand(cmd, opts.env)}`);
+    return;
+  }
+  const code = await exited(start(cmd, opts, "inherit"));
+  if (code !== 0)
+    throw new Error(`${formatCommand(cmd)} exited ${code}`);
+}
+async function runCapture(cmd, opts = {}) {
+  const child = start(cmd, opts, "pipe");
+  const [out, err, code] = await Promise.all([
+    collect(child.stdout),
+    collect(child.stderr),
+    exited(child)
+  ]);
+  if (code !== 0)
+    throw new Error(`${formatCommand(cmd)} exited ${code}: ${err.trim()}`);
+  return out.trim();
+}
+
+// src/deploy/aws.ts
+function resolveProfile(fallback, explicit, env = process.env) {
+  if (env.FOUNDATION_NO_PROFILE === "1")
+    return "";
+  if (explicit !== undefined)
+    return explicit;
+  if (env.AWS_PROFILE !== undefined && env.AWS_PROFILE !== "")
+    return env.AWS_PROFILE;
+  if (env.GITHUB_ACTIONS === "true")
+    return "";
+  return fallback;
+}
+function awsContext(overrides = {}) {
+  const env = overrides.env ?? process.env;
+  const paths = overrides.paths ?? loadInstanceFromArgs();
+  const instance = paths.instance;
+  return {
+    profile: resolveProfile(instance.aws.profile, overrides.profile, env),
+    region: overrides.region ?? env.AWS_REGION ?? instance.aws.region,
+    dryRun: overrides.dryRun ?? false,
+    instance,
+    paths,
+    names: instanceNames(instance)
+  };
+}
+function argv(ctx, args) {
+  const profile = ctx.profile === "" ? [] : ["--profile", ctx.profile];
+  return ["aws", ...args, ...profile, "--region", ctx.region];
+}
+function cdkEnv(ctx) {
+  return {
+    ...ctx.profile === "" ? {} : { AWS_PROFILE: ctx.profile },
+    AWS_REGION: ctx.region,
+    CDK_DEFAULT_REGION: ctx.region
+  };
+}
+async function aws(ctx, args, stdin) {
+  return runCapture(argv(ctx, args), { stdin });
+}
+async function awsMutate(ctx, args, stdin) {
+  if (ctx.dryRun === true) {
+    console.log(`  $ ${argv(ctx, args).join(" ")}${stdin === undefined ? "" : " < (stdin)"}`);
+    return;
+  }
+  await run(argv(ctx, args), { stdin });
+}
+async function stackOutput(ctx, stack, key) {
+  const value = await aws(ctx, [
+    "cloudformation",
+    "describe-stacks",
+    "--stack-name",
+    stack,
+    "--query",
+    `Stacks[0].Outputs[?OutputKey=='${key}'].OutputValue`,
+    "--output",
+    "text"
+  ]);
+  if (value === "" || value === "None")
+    throw new Error(`stack ${stack} has no output ${key} — has it been deployed?`);
+  return value;
+}
+async function stackExists(ctx, stack) {
+  try {
+    await aws(ctx, [
+      "cloudformation",
+      "describe-stacks",
+      "--stack-name",
+      stack,
+      "--output",
+      "text"
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function secretExists(ctx, secretId) {
+  try {
+    await aws(ctx, [
+      "secretsmanager",
+      "describe-secret",
+      "--secret-id",
+      secretId,
+      "--output",
+      "text"
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readSecretString(ctx, secretId) {
+  return aws(ctx, [
+    "secretsmanager",
+    "get-secret-value",
+    "--secret-id",
+    secretId,
+    "--query",
+    "SecretString",
+    "--output",
+    "text"
+  ]);
+}
+async function readSecretJson(ctx, secretId) {
+  return JSON.parse(await readSecretString(ctx, secretId));
+}
+async function putSecretString(ctx, secretId, value) {
+  await throughSecretFile(value, (file) => awsMutate(ctx, [
+    "secretsmanager",
+    "put-secret-value",
+    "--secret-id",
+    secretId,
+    "--secret-string",
+    `file://${file}`
+  ]));
+}
+async function createSecretString(ctx, secretId, value, description) {
+  await throughSecretFile(value, (file) => awsMutate(ctx, [
+    "secretsmanager",
+    "create-secret",
+    "--name",
+    secretId,
+    "--description",
+    description,
+    "--secret-string",
+    `file://${file}`
+  ]));
+}
+async function throughSecretFile(value, body) {
+  const dir = mkdtempSync(join(tmpdir(), "foundation-secret-"));
+  const file = join(dir, "value.json");
+  try {
+    writeFileSync(file, value, { mode: 384 });
+    await body(file);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+async function putSecretJson(ctx, secretId, value) {
+  await putSecretString(ctx, secretId, JSON.stringify(value));
+}
+async function callerAccountId(ctx) {
+  return aws(ctx, ["sts", "get-caller-identity", "--query", "Account", "--output", "text"]);
+}
+
+export { resolveInstanceFilePath, loadInstanceContext, instanceBanner, run, runCapture, awsContext, argv, cdkEnv, aws, awsMutate, stackOutput, stackExists, secretExists, readSecretString, readSecretJson, putSecretString, createSecretString, putSecretJson, callerAccountId };

package/dist/chunk-p7zkm4pp.js

@@ -0,0 +1,151 @@
+import {
+  CRM_MAX_ATTRIBUTE_STRING_CHARS,
+  CRM_NOTE_ACTIVITY,
+  CRM_OUTREACH_DRAFTED_ACTIVITY,
+  CRM_OUTREACH_REPLY_ACTIVITY,
+  CRM_OUTREACH_SENT_ACTIVITY,
+  CrmInputError
+} from "./chunk-3614v9rr.js";
+
+// ../capability-crm/src/proxy/policy.ts
+class CrmPolicyRefusedError extends Error {
+  code;
+  constructor(code) {
+    super(`CRM policy refused the request: ${code}`);
+    this.code = code;
+    this.name = "CrmPolicyRefusedError";
+  }
+}
+function checkStatusChange(policy, recordType, current, next) {
+  const rule = policy[recordType];
+  if (rule === undefined)
+    return;
+  const personOwned = rule.respectHumanChanges && (current.setBy ?? "person") === "person";
+  if (personOwned) {
+    if (rule.personSet === "lock")
+      return "status_locked";
+    const from = rule.ladder.indexOf(current.status);
+    const to = rule.ladder.indexOf(next);
+    if (from < 0 || to <= from)
+      return "status_locked";
+  } else if (current.status === next) {
+    return;
+  }
+  const exits = Object.hasOwn(rule.agentTransitions, current.status) ? rule.agentTransitions[current.status] : undefined;
+  return exits?.includes(next) === true ? undefined : "transition_not_allowed";
+}
+function personOwnedStatuses(rule, statuses) {
+  if (rule === undefined)
+    return [];
+  const reachable = new Set;
+  for (const [from, targets] of Object.entries(rule.agentTransitions)) {
+    if (targets.length > 0)
+      reachable.add(from);
+    for (const target of targets)
+      reachable.add(target);
+  }
+  return statuses.filter((status) => !reachable.has(status));
+}
+function checkSuppressed(suppressed, contact, company) {
+  if (contact.doNotContact === true || suppressed.contact.includes(contact.status) || company?.doNotContact === true || company !== undefined && suppressed.company.includes(company.status)) {
+    return "suppressed";
+  }
+  return;
+}
+function checkDraft(policy, touch, counters, kind) {
+  if (kind === "first_touch") {
+    if (touch !== null)
+      return "already_contacted";
+    if (counters.firstTouch >= policy.weeklyLimit)
+      return "weekly_limit_reached";
+    return;
+  }
+  if (touch === null)
+    return "not_contacted";
+  if (touch.followUps >= policy.maxFollowUps)
+    return "max_follow_ups_reached";
+  if (counters.followUp >= policy.followUpLimit)
+    return "follow_up_limit_reached";
+  return;
+}
+function checkDraftedStatus(policy, recordType, currentStatus, next, touched, counters) {
+  if (policy.draftedStatus === undefined || recordType !== "contact" || next !== policy.draftedStatus || currentStatus === policy.draftedStatus || touched) {
+    return;
+  }
+  return counters.firstTouch >= policy.weeklyLimit ? "weekly_limit_reached" : undefined;
+}
+function movesToDraftedStatus(policy, recordType, currentStatus, next) {
+  return policy.draftedStatus !== undefined && recordType === "contact" && next === policy.draftedStatus && currentStatus !== policy.draftedStatus;
+}
+function classifyOutreach(args, outreachConfigured) {
+  if (!outreachConfigured)
+    return;
+  if (args.activityType === CRM_OUTREACH_DRAFTED_ACTIVITY) {
+    if (args.recordType !== "contact") {
+      throw new CrmInputError("email_drafted must be logged on the contact, not the company");
+    }
+    const kind = args.attributes?.kind;
+    if (kind !== "first_touch" && kind !== "follow_up") {
+      throw new CrmInputError("email_drafted attributes.kind must be first_touch or follow_up");
+    }
+    const threadId = boundedAttribute(args.attributes?.threadId);
+    const draftId = boundedAttribute(args.attributes?.draftId);
+    return {
+      type: "drafted",
+      kind,
+      ...threadId === undefined ? {} : { threadId },
+      ...draftId === undefined ? {} : { draftId }
+    };
+  }
+  if (args.recordType !== "contact")
+    return;
+  if (args.activityType === CRM_OUTREACH_SENT_ACTIVITY) {
+    const threadId = boundedAttribute(args.attributes?.threadId);
+    return threadId === undefined ? { type: "sent" } : { type: "sent", threadId };
+  }
+  if (args.activityType === CRM_OUTREACH_REPLY_ACTIVITY)
+    return { type: "reply" };
+  return;
+}
+function checkNoteEdit(activity, unattributed) {
+  if (activity.activityType !== CRM_NOTE_ACTIVITY)
+    return "not_editable";
+  const by = activity.attributes?.by ?? unattributed;
+  return by === "agent" ? undefined : "not_editable";
+}
+function boundedAttribute(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= CRM_MAX_ATTRIBUTE_STRING_CHARS ? value : undefined;
+}
+var WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+
+class CrmOutreachTimezoneError extends Error {
+  constructor() {
+    super("CRM outreach timezone is unusable");
+    this.name = "CrmOutreachTimezoneError";
+  }
+}
+function outreachWeekStart(now, timezone) {
+  let parts;
+  try {
+    parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      weekday: "short"
+    }).formatToParts(now);
+  } catch {
+    throw new CrmOutreachTimezoneError;
+  }
+  const part = (type) => parts.find((entry) => entry.type === type)?.value;
+  const weekday = WEEKDAYS.indexOf(part("weekday"));
+  const year = Number(part("year"));
+  const month = Number(part("month"));
+  const day = Number(part("day"));
+  if (weekday < 0 || !Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
+    throw new CrmOutreachTimezoneError;
+  }
+  return new Date(Date.UTC(year, month - 1, day - weekday)).toISOString().slice(0, 10);
+}
+
+export { CrmPolicyRefusedError, checkStatusChange, personOwnedStatuses, checkSuppressed, checkDraft, checkDraftedStatus, movesToDraftedStatus, classifyOutreach, checkNoteEdit, outreachWeekStart };