@oxygen-agent/cli 1.146.1 → 1.160.18

package/dist/transcript.d.ts

@@ -0,0 +1,21 @@
+export type TranscriptSource = "claude_code" | "codex" | "cursor" | "file";
+export type CapturedTranscript = {
+    source: TranscriptSource;
+    session_id: string | null;
+    tool: string;
+    event_count: number;
+    byte_size: number;
+    format: "jsonl.gz.b64";
+    content_b64: string;
+    truncated: boolean;
+    path: string;
+};
+export declare function redactTranscriptSecrets(text: string): string;
+export type CaptureOptions = {
+    sessionId?: string | null;
+    file?: string | null;
+};
+export declare class TranscriptCaptureError extends Error {
+}
+export declare function captureCurrentTranscript(options?: CaptureOptions): CapturedTranscript | null;
+export declare function collectFeedbackEnvironment(): Record<string, string>;

package/dist/transcript.js

@@ -0,0 +1,208 @@
+import { gzipSync } from "node:zlib";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { OXYGEN_VERSION } from "@oxygen/shared";
+// Keep at most the most-recent ~2MB of JSONL. gzip of conversational JSON lands
+// ~5–10x smaller, so the base64 payload stays well under Vercel's ~4.5MB body
+// limit without needing chunked upload. Past the cap we drop the oldest events.
+const MAX_RAW_BYTES = 2_000_000;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function transcriptRoots() {
+    const home = homedir();
+    return [
+        { dir: join(process.env.CLAUDE_HOME ?? join(home, ".claude"), "projects"), source: "claude_code", tool: "claude-code" },
+        { dir: join(process.env.CODEX_HOME ?? join(home, ".codex"), "sessions"), source: "codex", tool: "codex" },
+        { dir: join(process.env.CURSOR_HOME ?? join(home, ".cursor"), "projects"), source: "cursor", tool: "cursor" },
+    ];
+}
+// Bounded recursive walk for *.jsonl files. Depth-limited so a pathological tree
+// can't hang the CLI; symlink/permission errors are swallowed per-entry.
+function collectJsonl(dir, depth, out) {
+    if (depth < 0)
+        return;
+    let names = [];
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const full = join(dir, name);
+        let isDir = false;
+        let isFile = false;
+        try {
+            const stat = statSync(full);
+            isDir = stat.isDirectory();
+            isFile = stat.isFile();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            collectJsonl(full, depth - 1, out);
+        }
+        else if (isFile && name.endsWith(".jsonl")) {
+            out.push(full);
+        }
+    }
+}
+function newestTranscriptFile() {
+    let newestPath = null;
+    let newestMtime = -1;
+    let newest = null;
+    for (const root of transcriptRoots()) {
+        if (!existsSync(root.dir))
+            continue;
+        const files = [];
+        collectJsonl(root.dir, 6, files);
+        for (const file of files) {
+            try {
+                const mtime = statSync(file).mtimeMs;
+                if (mtime > newestMtime) {
+                    newestMtime = mtime;
+                    newestPath = file;
+                    newest = root;
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!newestPath || !newest)
+        return null;
+    return { path: newestPath, source: newest.source, tool: newest.tool };
+}
+function findBySessionId(sessionId) {
+    for (const root of transcriptRoots()) {
+        if (!existsSync(root.dir))
+            continue;
+        const files = [];
+        collectJsonl(root.dir, 6, files);
+        // Case-insensitive: UUID session ids can be passed in any casing.
+        const needle = `${sessionId.toLowerCase()}.jsonl`;
+        const match = files.find((file) => file.toLowerCase().endsWith(needle));
+        if (match)
+            return { path: match, source: root.source, tool: root.tool };
+    }
+    return null;
+}
+function sessionIdFromPath(path) {
+    const base = path.split(/[\\/]/).pop() ?? "";
+    const stem = base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+    return UUID_RE.test(stem) ? stem : null;
+}
+// Trim to the last `MAX_RAW_BYTES`, snapping to a newline so the first kept line
+// is whole. Returns the kept buffer and whether anything was dropped.
+function capToRecent(raw) {
+    if (raw.length <= MAX_RAW_BYTES)
+        return { kept: raw, truncated: false };
+    let start = raw.length - MAX_RAW_BYTES;
+    const nl = raw.indexOf(0x0a, start); // '\n'
+    if (nl !== -1 && nl + 1 < raw.length)
+        start = nl + 1;
+    return { kept: raw.subarray(start), truncated: true };
+}
+function countEvents(buf) {
+    const text = buf.toString("utf8");
+    let count = 0;
+    for (const line of text.split("\n")) {
+        if (line.trim().length > 0)
+            count += 1;
+    }
+    return count;
+}
+// Redact obvious credentials from transcript text before it leaves the machine.
+// Agent JSONL can embed API keys, auth headers, and tokens captured from tool
+// calls / shell output; scrub the common shapes so `oxygen feedback` never ships
+// raw secrets to the support API. Best-effort (not a guarantee) and deliberately
+// conservative — it targets credential shapes, not general prose, so the
+// transcript stays useful for debugging.
+const SECRET_PATTERNS = [
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g, "[REDACTED_PRIVATE_KEY]"],
+    [/\bsk-ant-[A-Za-z0-9_-]{12,}/g, "sk-ant-[REDACTED]"],
+    [/\bsk-[A-Za-z0-9_-]{20,}/g, "sk-[REDACTED]"],
+    [/\bAKIA[0-9A-Z]{16}\b/g, "AKIA[REDACTED]"],
+    [/\bAIza[0-9A-Za-z_-]{20,}/g, "AIza[REDACTED]"],
+    [/\bgh[pousr]_[A-Za-z0-9]{20,}/g, "ghx_[REDACTED]"],
+    [/\bxox[baprs]-[A-Za-z0-9-]{10,}/g, "xox-[REDACTED]"],
+    [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}/g, "[REDACTED_JWT]"],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{16,}/gi, "$1 [REDACTED]"],
+    // "secret-ish key": "value"  /  secret_ish_key=value  (JSON + env shapes)
+    [/("?(?:api[_-]?key|apikey|secret|password|passwd|token|access[_-]?token|refresh[_-]?token|client[_-]?secret|authorization|auth[_-]?token|private[_-]?key)"?\s*[:=]\s*"?)([^"\s,}]{6,})/gi, "$1[REDACTED]"],
+];
+export function redactTranscriptSecrets(text) {
+    let out = text;
+    for (const [pattern, replacement] of SECRET_PATTERNS)
+        out = out.replace(pattern, replacement);
+    return out;
+}
+export class TranscriptCaptureError extends Error {
+}
+// Resolve and package the transcript. Returns null only when no transcript could
+// be found for the auto-detect path (so feedback can still send a note-only
+// report); an explicit --session-id / --file that doesn't resolve throws.
+export function captureCurrentTranscript(options = {}) {
+    let resolved = null;
+    if (options.file) {
+        if (!existsSync(options.file)) {
+            throw new TranscriptCaptureError(`Transcript file not found: ${options.file}`);
+        }
+        resolved = { path: options.file, source: "file", tool: "file" };
+    }
+    else if (options.sessionId) {
+        resolved = findBySessionId(options.sessionId);
+        if (!resolved) {
+            throw new TranscriptCaptureError(`No local transcript found for session ${options.sessionId}.`);
+        }
+    }
+    else {
+        resolved = newestTranscriptFile();
+        if (!resolved)
+            return null;
+    }
+    let raw;
+    try {
+        raw = readFileSync(resolved.path);
+    }
+    catch (error) {
+        throw new TranscriptCaptureError(`Could not read transcript ${resolved.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const { kept, truncated } = capToRecent(raw);
+    // Scrub credentials from the raw bytes before gzip+base64 — the encoded blob is
+    // what leaves the machine, so redaction must happen here, not server-side.
+    const redacted = Buffer.from(redactTranscriptSecrets(kept.toString("utf8")), "utf8");
+    const content_b64 = gzipSync(redacted).toString("base64");
+    return {
+        source: resolved.source,
+        session_id: sessionIdFromPath(resolved.path),
+        tool: resolved.tool,
+        event_count: countEvents(redacted),
+        byte_size: redacted.length,
+        format: "jsonl.gz.b64",
+        content_b64,
+        truncated,
+        path: resolved.path,
+    };
+}
+// Lightweight, non-sensitive environment snapshot attached to feedback context so
+// staff can reproduce. Deliberately excludes env vars / secrets.
+export function collectFeedbackEnvironment() {
+    const env = {
+        os: `${process.platform} ${process.arch}`,
+        node: process.version,
+        cli_version: OXYGEN_VERSION,
+        cwd: process.cwd(),
+    };
+    const shell = (process.env.SHELL ?? "").trim();
+    if (shell)
+        env.shell = shell;
+    const term = (process.env.TERM_PROGRAM ?? "").trim();
+    if (term) {
+        const ver = (process.env.TERM_PROGRAM_VERSION ?? "").trim();
+        env.terminal = ver ? `${term} ${ver}` : term;
+    }
+    return env;
+}

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

@@ -4,10 +4,14 @@ export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./linkedin-sequences.js";
+export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
+export * from "./sql-error.js";
 export * from "./telemetry.js";
+export declare const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };

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

@@ -5,10 +5,19 @@ export * from "./billing.js";
 export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
+export * from "./linkedin-sequences.js";
+export * from "./sequences.js";
 export * from "./log.js";
 export * from "./provider-request-outcomes.js";
 export * from "./signup-lead-deliveries.js";
+export * from "./sql-error.js";
 export * from "./telemetry.js";
+// Maximum rows a single row-loop write (insert/upsert/preview) may process. The
+// row-loop engine issues one DB round-trip per row, so a 500-row write already
+// approaches request timeouts (~50s observed in prod); larger batches must use
+// the COPY-based bulk engine. Tenant-db enforces this and the CLI/API row caps
+// reference it so they never advertise a batch the row-loop will reject.
+export const MAX_ROW_LOOP_WRITE_ROWS = 500;
 export class OxygenError extends Error {
     code;
     details;

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

@@ -0,0 +1,106 @@
+/**
+ * LinkedIn-channel step types + helpers for the sequencer. These typed shapes
+ * describe the LinkedIn steps of a sequence and are consumed by the dispatch
+ * engine and the web flow editor/canvas. The canonical multichannel validator
+ * lives in `sequences.ts` (validateSequenceDefinition) — this module is types +
+ * the two pure helpers the dispatcher uses (renderLinkedInTemplate, the
+ * action-kind map, waitStepDelayMs). It carries no validator of its own.
+ *
+ * Step kinds:
+ * - visit_profile        — view the lead's profile (warms up before an invite)
+ * - invite               — send a connection request, optional note_template
+ * - wait_for_connection  — gate: wait until the invite is accepted (new_relation
+ *                          webhook) or timeout_days elapses; on timeout stop or
+ *                          continue per on_timeout
+ * - wait                 — fixed delay (days/hours) before the next step
+ * - message              — send a message; template supports {{column}} interp
+ * - inmail               — send an InMail (works on non-connections)
+ */
+export declare const LINKEDIN_SEQUENCE_STEP_KINDS: readonly ["visit_profile", "invite", "wait_for_connection", "wait", "message", "inmail", "branch", "stop"];
+export type LinkedInSequenceStepKind = typeof LINKEDIN_SEQUENCE_STEP_KINDS[number];
+/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
+export declare const LINKEDIN_BRANCH_CONDITIONS: readonly ["connection_accepted", "already_connected"];
+export type LinkedInBranchCondition = typeof LINKEDIN_BRANCH_CONDITIONS[number];
+/** Every step carries a stable id so branch edges can target it by reference. */
+export type LinkedInStepBase = {
+    id: string;
+};
+export type LinkedInVisitProfileStep = LinkedInStepBase & {
+    kind: "visit_profile";
+};
+export type LinkedInInviteStep = LinkedInStepBase & {
+    kind: "invite";
+    /** Optional connection-request note. Supports {{column}} interpolation. ~300 char max on LinkedIn. */
+    note_template?: string;
+};
+export type LinkedInWaitForConnectionStep = LinkedInStepBase & {
+    kind: "wait_for_connection";
+    /** Days to wait for the invite to be accepted before acting on on_timeout. */
+    timeout_days: number;
+    /** What to do if the invite is never accepted. Defaults to "stop". */
+    on_timeout?: "stop" | "continue";
+};
+export type LinkedInWaitStep = LinkedInStepBase & {
+    kind: "wait";
+    /** Fixed delay before the next step. Provide days and/or hours (>= 1 total). */
+    days?: number;
+    hours?: number;
+};
+export type LinkedInMessageStep = LinkedInStepBase & {
+    kind: "message";
+    /** Message body. Supports {{column}} interpolation from the source-table row. */
+    template: string;
+};
+export type LinkedInInMailStep = LinkedInStepBase & {
+    kind: "inmail";
+    subject_template: string;
+    template: string;
+};
+/**
+ * A routing gate. Unlike a workflow branch (synchronous expression), a sequence
+ * branch routes on a LinkedIn signal that arrives over time:
+ * - `connection_accepted`: enter a wait until the invite is accepted (the
+ *   new_relation webhook sets connectedAt) or `timeout_days` elapses. Accepted →
+ *   `then_id`; timeout → `else_id` (omitted = stop).
+ * - `already_connected`: at entry, resolve whether the lead is already a
+ *   1st-degree connection. Connected → `then_id`; not → `else_id`.
+ * A missing `then_id`/`else_id` ends that path (enrollment completes/stops).
+ */
+export type LinkedInBranchStep = LinkedInStepBase & {
+    kind: "branch";
+    condition: LinkedInBranchCondition;
+    /** connection_accepted only: days to wait for acceptance. Defaults to 14. */
+    timeout_days?: number;
+    /** Step id to route to when the condition is TRUE. Omitted = end this path. */
+    then_id?: string;
+    /** Step id to route to when FALSE / timeout. Omitted = stop this path. */
+    else_id?: string;
+};
+/**
+ * Explicit terminal step. Ends the enrollment here regardless of any steps that
+ * follow in the array — the only way to give a `branch`'s two arms genuinely
+ * distinct endings (e.g. a "warm" message that stops, vs an invite→wait→"cold"
+ * message that stops), instead of forcing both arms to fall through into the
+ * same trailing step.
+ */
+export type LinkedInStopStep = LinkedInStepBase & {
+    kind: "stop";
+};
+export type LinkedInSequenceStep = LinkedInVisitProfileStep | LinkedInInviteStep | LinkedInWaitForConnectionStep | LinkedInWaitStep | LinkedInMessageStep | LinkedInInMailStep | LinkedInBranchStep | LinkedInStopStep;
+export type LinkedInSequenceDefinition = {
+    steps: LinkedInSequenceStep[];
+};
+/**
+ * The dispatch-queue action kind a step produces (matches the
+ * ox_sequencer.sequence_actions.action_kind enum), or null for gate/wait steps
+ * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
+ * — visit_profile maps to the quota kind profile_view downstream.
+ */
+export declare const LINKEDIN_STEP_ACTION_KIND: Record<LinkedInSequenceStepKind, "visit_profile" | "invite" | "message" | "inmail" | null>;
+/** Total delay in milliseconds a `wait` step introduces. */
+export declare function waitStepDelayMs(step: LinkedInWaitStep): number;
+/**
+ * Render a {{column}} template against a row's values. Unknown placeholders
+ * render empty. Used by the dispatch engine to produce the final message text.
+ */
+export declare function renderLinkedInTemplate(template: string, values: Record<string, unknown>): string;

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

@@ -0,0 +1,64 @@
+/**
+ * LinkedIn-channel step types + helpers for the sequencer. These typed shapes
+ * describe the LinkedIn steps of a sequence and are consumed by the dispatch
+ * engine and the web flow editor/canvas. The canonical multichannel validator
+ * lives in `sequences.ts` (validateSequenceDefinition) — this module is types +
+ * the two pure helpers the dispatcher uses (renderLinkedInTemplate, the
+ * action-kind map, waitStepDelayMs). It carries no validator of its own.
+ *
+ * Step kinds:
+ * - visit_profile        — view the lead's profile (warms up before an invite)
+ * - invite               — send a connection request, optional note_template
+ * - wait_for_connection  — gate: wait until the invite is accepted (new_relation
+ *                          webhook) or timeout_days elapses; on timeout stop or
+ *                          continue per on_timeout
+ * - wait                 — fixed delay (days/hours) before the next step
+ * - message              — send a message; template supports {{column}} interp
+ * - inmail               — send an InMail (works on non-connections)
+ */
+export const LINKEDIN_SEQUENCE_STEP_KINDS = [
+    "visit_profile",
+    "invite",
+    "wait_for_connection",
+    "wait",
+    "message",
+    "inmail",
+    "branch",
+    "stop",
+];
+/** Conditions a `branch` step routes on. Both are LinkedIn-signal driven. */
+export const LINKEDIN_BRANCH_CONDITIONS = ["connection_accepted", "already_connected"];
+/**
+ * The dispatch-queue action kind a step produces (matches the
+ * ox_sequencer.sequence_actions.action_kind enum), or null for gate/wait steps
+ * that dispatch nothing. NOTE: this is the *action* kind, not the *quota* kind
+ * — visit_profile maps to the quota kind profile_view downstream.
+ */
+export const LINKEDIN_STEP_ACTION_KIND = {
+    visit_profile: "visit_profile",
+    invite: "invite",
+    wait_for_connection: null,
+    wait: null,
+    message: "message",
+    inmail: "inmail",
+    branch: null,
+    stop: null,
+};
+/** Total delay in milliseconds a `wait` step introduces. */
+export function waitStepDelayMs(step) {
+    const days = step.days ?? 0;
+    const hours = step.hours ?? 0;
+    return (days * 24 + hours) * 60 * 60 * 1000;
+}
+/**
+ * Render a {{column}} template against a row's values. Unknown placeholders
+ * render empty. Used by the dispatch engine to produce the final message text.
+ */
+export function renderLinkedInTemplate(template, values) {
+    return template.replace(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, key) => {
+        const value = values[key];
+        if (value === null || value === undefined)
+            return "";
+        return typeof value === "string" ? value : String(value);
+    });
+}

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

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { sanitizeLogFields } from "./redaction.js";
+import { redactSqlParameters } from "./sql-error.js";
 import { OXYGEN_VERSION } from "./version.js";
 const store = new AsyncLocalStorage();
 export function withLogContext(ctx, fn) {
@@ -16,7 +17,12 @@ export function log(level, msg, fields) {
         msg,
         service_name: process.env.OXYGEN_SERVICE_NAME ?? process.env.OTEL_SERVICE_NAME ?? null,
         oxygen_version: OXYGEN_VERSION,
-        sha: process.env.VERCEL_GIT_COMMIT_SHA ?? null,
+        // Deploying commit. Vercel injects VERCEL_GIT_COMMIT_SHA; the Fly worker has
+        // no such env, so it resolves the image-baked SHA at startup and exports it as
+        // OXYGEN_GIT_SHA (see apps/worker build-info). Without that fallback every
+        // recurring worker line carried sha:null even though /health knew the commit
+        // (OXY-61). This module stays edge-safe by reading only the env var.
+        sha: process.env.VERCEL_GIT_COMMIT_SHA ?? process.env.OXYGEN_GIT_SHA ?? null,
         region: process.env.VERCEL_REGION ?? null,
         env: process.env.VERCEL_ENV ?? process.env.NODE_ENV ?? null,
         ...sanitizeLogFields({
@@ -61,9 +67,11 @@ export function errorFields(err) {
         return {
             error_id: errorId(err),
             error_name: err.name,
-            error_message: err.message,
-            error_stack: err.stack,
+            // Strip drizzle's `\nparams: <values>` tail so SQL parameter values never
+            // reach logs (OXY-46); the SQL text and stack frames are preserved.
+            error_message: redactSqlParameters(err.message),
+            error_stack: err.stack ? redactSqlParameters(err.stack) : err.stack,
         };
     }
-    return { error_id: "non_error", error_message: String(err) };
+    return { error_id: "non_error", error_message: redactSqlParameters(String(err)) };
 }