@oxygen-agent/cli 1.377.3 → 1.575.19

package/node_modules/@oxygen/shared/dist/index.d.ts

@@ -2,11 +2,15 @@ export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_V
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export { WORKFLOW_STATUS_CHANGE_METADATA_KEY, type WorkflowStatusChange, type WorkflowStatusChangeActor, type WorkflowStatusChangeSource, describeWorkflowStatusChange, formatWorkflowStatusChangeTimestamp, parseWorkflowStatusChange, readWorkflowStatusChange, } from "./workflow-status-change.js";
 export * from "./billing.js";
+export * from "./billing-anchors.js";
 export * from "./budget-scopes.js";
+export * from "./plan-limits.js";
+export * from "./spend-safety.js";
 export * from "./cell-format.js";
 export * from "./cli-envelope.js";
 export * from "./cli-login-code.js";
 export * from "./cli-result.js";
+export * from "./crm-reply-events.js";
 export * from "./column-types.js";
 export * from "./copilot-journeys.js";
 export * from "./credit-guidance.js";
@@ -23,11 +27,16 @@ export * from "./knowledge-seed-content.js";
 export * from "./langfuse.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
+export * from "./linkedin-quota-denial.js";
 export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
+export * from "./microsoft-consent-url.js";
 export * from "./networks.js";
 export * from "./recipes.js";
 export * from "./sequence-template.js";
+export * from "./sequence-crm-events.js";
+export * from "./call-outcomes.js";
+export * from "./dial-guardrail-overrides.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./log.js";

package/node_modules/@oxygen/shared/dist/index.js

@@ -2,11 +2,15 @@ export { MANAGED_INBOX_MINIMUM_CLI_VERSION, OXYGEN_MINIMUM_CLI_VERSION, OXYGEN_V
 export { WORKFLOW_TRIGGER_AUTO_PAUSE_METADATA_KEYS, clearWorkflowTriggerAutoPauseMetadata, } from "./workflow-trigger-metadata.js";
 export { WORKFLOW_STATUS_CHANGE_METADATA_KEY, describeWorkflowStatusChange, formatWorkflowStatusChangeTimestamp, parseWorkflowStatusChange, readWorkflowStatusChange, } from "./workflow-status-change.js";
 export * from "./billing.js";
+export * from "./billing-anchors.js";
 export * from "./budget-scopes.js";
+export * from "./plan-limits.js";
+export * from "./spend-safety.js";
 export * from "./cell-format.js";
 export * from "./cli-envelope.js";
 export * from "./cli-login-code.js";
 export * from "./cli-result.js";
+export * from "./crm-reply-events.js";
 export * from "./column-types.js";
 export * from "./copilot-journeys.js";
 export * from "./credit-guidance.js";
@@ -23,11 +27,16 @@ export * from "./knowledge-seed-content.js";
 export * from "./langfuse.js";
 export * from "./linkedin-mentions.js";
 export * from "./linkedin-post-url.js";
+export * from "./linkedin-quota-denial.js";
 export * from "./linkedin-url.js";
 export * from "./linkedin-sequences.js";
+export * from "./microsoft-consent-url.js";
 export * from "./networks.js";
 export * from "./recipes.js";
 export * from "./sequence-template.js";
+export * from "./sequence-crm-events.js";
+export * from "./call-outcomes.js";
+export * from "./dial-guardrail-overrides.js";
 export * from "./sequences.js";
 export * from "./suppression-entries.js";
 export * from "./log.js";

package/node_modules/@oxygen/shared/dist/linkedin-quota-denial.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How a LinkedIn quota denial is read by the background jobs that hit it.
+ *
+ * The denial itself is raised by the chokepoint in
+ * packages/integrations/src/linkedin-quota.ts; this module is the consumer half,
+ * and it lives here because the consumers are spread across the worker, the web
+ * app, and the integrations package — three copies of "is this a denial, and
+ * until when" is exactly how the inbox sync and the publishing metrics sync ended
+ * up with different behavior for the same condition.
+ *
+ * The pattern (established in v1.423.0 for `linkedin.inbox_sync_failed`, which
+ * emitted 158,882 warn lines in 31h for one account): a denial is logged at
+ * `info`, not `warn` — a rate budget doing its job is normal operation, and at
+ * background cadence it buries the real warnings — and the account is parked
+ * until its budget resets rather than re-denied on every tenant tick.
+ */
+import { OxygenError } from "./cli-result.js";
+/** Was this thrown error the quota chokepoint refusing the call? */
+export declare function isLinkedInQuotaDenial(error: unknown): error is OxygenError;
+/**
+ * When a quota-denied caller may try again — the denial's own `resets_at` when it
+ * carries a usable one, else a flat hour. Null for anything that is NOT a quota
+ * denial: an ordinary failure (provider timeout, malformed payload) has no reset
+ * instant and must keep retrying on its caller's normal cadence.
+ */
+export declare function linkedInQuotaBackoffUntil(error: unknown, now: Date): Date | null;
+/**
+ * Epoch-ms a sender's park — written under `key` in the freeform
+ * `sender_accounts.metadata` jsonb — expires; 0 when it is not parked.
+ */
+export declare function linkedInQuotaParkedUntil(metadata: unknown, key: string): number;

package/node_modules/@oxygen/shared/dist/linkedin-quota-denial.js

@@ -0,0 +1,56 @@
+/**
+ * How a LinkedIn quota denial is read by the background jobs that hit it.
+ *
+ * The denial itself is raised by the chokepoint in
+ * packages/integrations/src/linkedin-quota.ts; this module is the consumer half,
+ * and it lives here because the consumers are spread across the worker, the web
+ * app, and the integrations package — three copies of "is this a denial, and
+ * until when" is exactly how the inbox sync and the publishing metrics sync ended
+ * up with different behavior for the same condition.
+ *
+ * The pattern (established in v1.423.0 for `linkedin.inbox_sync_failed`, which
+ * emitted 158,882 warn lines in 31h for one account): a denial is logged at
+ * `info`, not `warn` — a rate budget doing its job is normal operation, and at
+ * background cadence it buries the real warnings — and the account is parked
+ * until its budget resets rather than re-denied on every tenant tick.
+ */
+import { OxygenError } from "./cli-result.js";
+import { isRecord } from "./type-guards.js";
+// The two codes a denial is raised with. Either is a "come back later" signal,
+// not a broken caller: a daily cap / closed active window that reopens on its own
+// clock, or an account the status webhook will reactivate.
+const QUOTA_DENIED_CODES = new Set(["linkedin_rate_limited", "linkedin_account_unavailable"]);
+/** Park length when a denial carries no usable `resets_at` hint. */
+const QUOTA_FALLBACK_BACKOFF_MS = 60 * 60 * 1000;
+/** Was this thrown error the quota chokepoint refusing the call? */
+export function isLinkedInQuotaDenial(error) {
+    return error instanceof OxygenError && QUOTA_DENIED_CODES.has(error.code);
+}
+/**
+ * When a quota-denied caller may try again — the denial's own `resets_at` when it
+ * carries a usable one, else a flat hour. Null for anything that is NOT a quota
+ * denial: an ordinary failure (provider timeout, malformed payload) has no reset
+ * instant and must keep retrying on its caller's normal cadence.
+ */
+export function linkedInQuotaBackoffUntil(error, now) {
+    if (!isLinkedInQuotaDenial(error))
+        return null;
+    const raw = isRecord(error.details) ? error.details.resets_at : undefined;
+    if (typeof raw === "string") {
+        const ms = Date.parse(raw);
+        if (!Number.isNaN(ms) && ms > now.getTime())
+            return new Date(ms);
+    }
+    return new Date(now.getTime() + QUOTA_FALLBACK_BACKOFF_MS);
+}
+/**
+ * Epoch-ms a sender's park — written under `key` in the freeform
+ * `sender_accounts.metadata` jsonb — expires; 0 when it is not parked.
+ */
+export function linkedInQuotaParkedUntil(metadata, key) {
+    const raw = isRecord(metadata) ? metadata[key] : undefined;
+    if (typeof raw !== "string")
+        return 0;
+    const ms = Date.parse(raw);
+    return Number.isNaN(ms) ? 0 : ms;
+}

package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts

@@ -144,10 +144,11 @@ export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
 /**
  * Render a sequence-copy template against a row's values. Delegates to the shared
  * deterministic engine, so beyond `{{column}}` substitution it also handles
- * `{{column|fallback}}`, `{{RANDOM|…}}` spintax, and `{% if … %}` conditionals.
- * Unknown `{{column}}` placeholders render empty. Used by the dispatch engine to
- * produce the final message text. Pass `{ seed }` to make spintax choices
- * replayable (crash-safe); with no seed a stable template+values seed is derived.
+ * `{{column|fallback}}`, `{{RANDOM|…}}` and bare `{a|b|c}` spintax (nestable), and
+ * `{% if … %}` conditionals. Unknown `{{column}}` placeholders render empty. Used
+ * by the dispatch engine to produce the final message text. Pass `{ seed }` to make
+ * spintax choices replayable (crash-safe); with no seed a stable template+values
+ * seed is derived.
  */
 export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>, options?: RenderTemplateOptions): string;
 export {};

package/node_modules/@oxygen/shared/dist/linkedin-sequences.js

@@ -64,10 +64,11 @@ export function waitStepDelayMs(step) {
 /**
  * Render a sequence-copy template against a row's values. Delegates to the shared
  * deterministic engine, so beyond `{{column}}` substitution it also handles
- * `{{column|fallback}}`, `{{RANDOM|…}}` spintax, and `{% if … %}` conditionals.
- * Unknown `{{column}}` placeholders render empty. Used by the dispatch engine to
- * produce the final message text. Pass `{ seed }` to make spintax choices
- * replayable (crash-safe); with no seed a stable template+values seed is derived.
+ * `{{column|fallback}}`, `{{RANDOM|…}}` and bare `{a|b|c}` spintax (nestable), and
+ * `{% if … %}` conditionals. Unknown `{{column}}` placeholders render empty. Used
+ * by the dispatch engine to produce the final message text. Pass `{ seed }` to make
+ * spintax choices replayable (crash-safe); with no seed a stable template+values
+ * seed is derived.
  */
 export function renderLinkedInTemplate(template, values, options) {
     return renderTemplate(template, values, options);

package/node_modules/@oxygen/shared/dist/linkedin-url.d.ts

@@ -1,6 +1,28 @@
 export type LinkedinUrlNormalization = {
+    /**
+     * Lowercase canonical URL — the stable MATCH key (CRM `linkedin_url_v1`
+     * identities, suppression entries). Lowercasing is what makes two spellings of
+     * the same profile compare equal, so this must stay case-folded forever: a
+     * suppression key that changed case would stop matching every row already
+     * stored under the old spelling, and someone who opted out would be contacted.
+     */
     normalized: string;
+    /** Lowercase handle — the stable match key. Same contract as `normalized`. */
     handle: string;
+    /**
+     * The handle with its ORIGINAL case, for anything that hands the identifier
+     * back to a provider or stores it on a record.
+     *
+     * A public slug is lowercase by construction, so this equals `handle` for it.
+     * An `ACoAA…` provider id is base64url of a member URN — its case is
+     * significant, and folding it is irreversible data loss: the id then resolves
+     * at neither Unipile nor HarvestAPI (which answers HTTP 400 "You need to
+     * provide at least one valid argument"). Reach for this whenever the value
+     * leaves Oxygen; reach for `handle`/`normalized` whenever it is compared.
+     */
+    dispatchHandle: string;
+    /** Canonical URL built from `dispatchHandle` — what we store on a record. */
+    dispatchUrl: string;
 } | null;
 export declare function normalizeLinkedinProfileUrl(raw: string | null | undefined): LinkedinUrlNormalization;
 /**

package/node_modules/@oxygen/shared/dist/linkedin-url.js

@@ -48,18 +48,21 @@ export function normalizeLinkedinProfileUrl(raw) {
     const rawHandle = parts[markerIndex + 1];
     if (!rawHandle)
         return null;
-    let handle;
+    let decoded;
     try {
-        handle = decodeURIComponent(rawHandle).trim().toLowerCase();
+        decoded = decodeURIComponent(rawHandle).trim();
     }
     catch {
-        handle = rawHandle.trim().toLowerCase();
+        decoded = rawHandle.trim();
     }
-    if (!handle)
+    if (!decoded)
         return null;
+    const handle = decoded.toLowerCase();
     return {
         normalized: `https://www.linkedin.com/in/${handle}`,
         handle,
+        dispatchHandle: decoded,
+        dispatchUrl: `https://www.linkedin.com/in/${decoded}`,
     };
 }
 // A LinkedIn post URL carries the numeric activity id we address the post by:

package/node_modules/@oxygen/shared/dist/log.js

@@ -73,6 +73,35 @@ export function setLogSink(sink) {
 function getLogSink() {
     return globalThis[LOG_SINK_SLOT] ?? null;
 }
+const LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
+/**
+ * Minimum level that reaches the Axiom SINK. stdout is deliberately untouched —
+ * `flyctl logs`, `vercel logs`, and local runs keep every line, so nothing becomes
+ * un-debuggable; this only decides what we pay to store and query.
+ *
+ * Default `info`, i.e. debug never ships. Until 2026-07-31 `log()` had no level gate
+ * at all, so debug lines were shipped exactly like info — which contradicted the code
+ * that chose debug specifically to stay quiet (see the `work_queue.wake.failed` call
+ * in packages/work-queue/src/wake-client.ts: "Log at debug level so this doesn't
+ * generate noise during deploys" — it generated 10k rows/week regardless). Measured
+ * the day this landed: debug was 97,704 rows/day of `oxygen-logs`, 24% of all
+ * in-process rows, and 98% of that was a single `crm_person_photo_cycle_skipped`
+ * line reporting that nothing happened.
+ *
+ * Set `OXYGEN_LOG_SHIP_MIN_LEVEL=debug` to restore the old behaviour (e.g. while
+ * debugging a specific incident), or raise it to `warn` to ship only actionable lines.
+ */
+function shipMinRank() {
+    const configured = process.env.OXYGEN_LOG_SHIP_MIN_LEVEL?.trim().toLowerCase();
+    if (configured
+        && Object.prototype.hasOwnProperty.call(LEVEL_RANK, configured)) {
+        return LEVEL_RANK[configured];
+    }
+    return LEVEL_RANK.info;
+}
+function shouldShip(level) {
+    return LEVEL_RANK[level] >= shipMinRank();
+}
 export function log(level, msg, fields) {
     const context = getLogContext();
     const record = {
@@ -101,6 +130,8 @@ export function log(level, msg, fields) {
     else {
         console.log(line);
     }
+    if (!shouldShip(level))
+        return;
     const logSink = getLogSink();
     if (!logSink)
         return;
@@ -131,8 +162,16 @@ function hashErrorKey(input) {
 export function errorId(err) {
     if (!(err instanceof Error))
         return "non_error";
-    const firstFrame = (err.stack ?? "").split("\n").slice(1, 2).join("");
-    return hashErrorKey(`${err.name}:${err.message}:${firstFrame}`);
+    // A drizzle DrizzleQueryError carries the bound parameter values inside its
+    // own message (`Failed query: <sql>\nparams: <values>`), which also makes
+    // stack line 1 the `params:` continuation instead of a frame. Hashing either
+    // raw gave every repetition of one DB failure its own id — 101 identical
+    // oxygen_lead_db_cache.write_failed events grouped as 101 buckets of one, and
+    // the hash input was derived from customer row values (OXY-46). Redact the
+    // params tail and hash the first real frame so DB errors group again.
+    const message = redactSqlParameters(err.message);
+    const firstFrame = (err.stack ?? "").split("\n").find((line) => /^\s+at\s/.test(line)) ?? "";
+    return hashErrorKey(`${err.name}:${message}:${firstFrame}`);
 }
 export function errorFields(err) {
     if (err instanceof Error) {

package/node_modules/@oxygen/shared/dist/microsoft-consent-url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Normalize a Microsoft Entra admin-consent URL for an operator handoff.
+ *
+ * Provider responses are external input. Only Microsoft's documented HTTPS
+ * login host and either provider-supported admin-consent path may become clickable.
+ */
+export declare function normalizeMicrosoftAdminConsentUrl(value: unknown): string | null;

package/node_modules/@oxygen/shared/dist/microsoft-consent-url.js

@@ -0,0 +1,29 @@
+const MICROSOFT_LOGIN_HOST = "login.microsoftonline.com";
+const ADMIN_CONSENT_PATH = /^\/(?:[^/]+\/)?adminconsent\/?$/i;
+/**
+ * Normalize a Microsoft Entra admin-consent URL for an operator handoff.
+ *
+ * Provider responses are external input. Only Microsoft's documented HTTPS
+ * login host and either provider-supported admin-consent path may become clickable.
+ */
+export function normalizeMicrosoftAdminConsentUrl(value) {
+    if (typeof value !== "string" || value.trim() === "")
+        return null;
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== "https:" ||
+        url.hostname.toLowerCase() !== MICROSOFT_LOGIN_HOST ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.port !== "" ||
+        url.hash !== "" ||
+        !ADMIN_CONSENT_PATH.test(url.pathname)) {
+        return null;
+    }
+    return url.toString();
+}

package/node_modules/@oxygen/shared/dist/object-storage.d.ts

@@ -7,7 +7,12 @@ export declare function buildPublishingMediaObjectKey(input: {
     organizationId: string;
     fileName?: string | null;
 }): string;
+export declare function buildCopilotAttachmentObjectKey(input: {
+    organizationId: string;
+    fileName?: string | null;
+}): string;
 export declare function isImportObjectKeyForOrganization(key: string, organizationId: string): boolean;
+export declare function isCopilotAttachmentObjectKeyForOrganization(key: string, organizationId: string): boolean;
 export declare function isPublishingMediaObjectKeyForOrganization(key: string, organizationId: string): boolean;
 export type PresignedImportUpload = {
     uploadUrl: string;
@@ -30,6 +35,32 @@ export declare function presignPublishingMediaUpload(input: {
     contentType?: string | null;
     contentLength: number;
 }): Promise<PresignedPublishingMediaUpload>;
+export declare function presignCopilotAttachmentUpload(input: {
+    organizationId: string;
+    fileName?: string | null;
+    contentType?: string | null;
+    contentLength: number;
+}): Promise<PresignedImportUpload>;
+/**
+ * Read an uploaded attachment back into memory. Bounded by `maxBytes` because
+ * the callers are a CSV header sniff and a text extraction, neither of which
+ * needs the whole object — and a 400MB upload must not become a 400MB buffer in
+ * a Vercel handler.
+ */
+export declare function readCopilotAttachmentObject(input: {
+    storageKey: string;
+    maxBytes: number;
+}): Promise<{
+    body: Uint8Array;
+    contentType: string | null;
+    truncated: boolean;
+}>;
+export declare function getCopilotAttachmentObjectMetadata(input: {
+    storageKey: string;
+}): Promise<{
+    contentLength: number | null;
+    contentType: string | null;
+}>;
 export declare function getImportObjectMetadata(input: {
     storageKey: string;
 }): Promise<{

package/node_modules/@oxygen/shared/dist/object-storage.js

@@ -65,9 +65,16 @@ export function buildPublishingMediaObjectKey(input) {
     const safeName = sanitizeFileName(input.fileName) || "media";
     return `publishing-media/${input.organizationId}/${randomUUID()}/${safeName}`;
 }
+export function buildCopilotAttachmentObjectKey(input) {
+    const safeName = sanitizeFileName(input.fileName) || "attachment";
+    return `copilot/${input.organizationId}/${randomUUID()}/${safeName}`;
+}
 export function isImportObjectKeyForOrganization(key, organizationId) {
     return key.startsWith(`imports/${organizationId}/`);
 }
+export function isCopilotAttachmentObjectKeyForOrganization(key, organizationId) {
+    return key.startsWith(`copilot/${organizationId}/`);
+}
 export function isPublishingMediaObjectKeyForOrganization(key, organizationId) {
     return key.startsWith(`publishing-media/${organizationId}/`);
 }
@@ -115,6 +122,60 @@ export async function presignPublishingMediaUpload(input) {
         expiresInSeconds: PRESIGN_EXPIRY_SECONDS,
     };
 }
+export async function presignCopilotAttachmentUpload(input) {
+    const { client, config } = resolveClient();
+    const storageKey = buildCopilotAttachmentObjectKey({
+        organizationId: input.organizationId,
+        fileName: input.fileName ?? null,
+    });
+    const command = new PutObjectCommand({
+        Bucket: config.bucket,
+        Key: storageKey,
+        ContentLength: input.contentLength,
+        ...(input.contentType ? { ContentType: input.contentType } : {}),
+    });
+    const uploadUrl = await getSignedUrl(client, command, { expiresIn: PRESIGN_EXPIRY_SECONDS });
+    return {
+        uploadUrl,
+        bucket: config.bucket,
+        storageKey,
+        contentLength: input.contentLength,
+        provider: "s3",
+        expiresInSeconds: PRESIGN_EXPIRY_SECONDS,
+    };
+}
+/**
+ * Read an uploaded attachment back into memory. Bounded by `maxBytes` because
+ * the callers are a CSV header sniff and a text extraction, neither of which
+ * needs the whole object — and a 400MB upload must not become a 400MB buffer in
+ * a Vercel handler.
+ */
+export async function readCopilotAttachmentObject(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new GetObjectCommand({
+        Bucket: config.bucket,
+        Key: input.storageKey,
+        // Ask for one byte past the cap so a full read is distinguishable from a
+        // file that happens to be exactly maxBytes long.
+        Range: `bytes=0-${input.maxBytes}`,
+    }));
+    const raw = await result.Body?.transformToByteArray();
+    const body = raw ?? new Uint8Array();
+    const truncated = body.byteLength > input.maxBytes;
+    return {
+        body: truncated ? body.subarray(0, input.maxBytes) : body,
+        contentType: typeof result.ContentType === "string" ? result.ContentType : null,
+        truncated,
+    };
+}
+export async function getCopilotAttachmentObjectMetadata(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new HeadObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
+    return {
+        contentLength: typeof result.ContentLength === "number" ? result.ContentLength : null,
+        contentType: typeof result.ContentType === "string" ? result.ContentType : null,
+    };
+}
 export async function getImportObjectMetadata(input) {
     const { client, config } = resolveClient();
     const result = await client.send(new HeadObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));