@oxygen-agent/cli 1.50.37 → 1.98.7

package/node_modules/@oxygen/shared/dist/file-import.js

@@ -3,6 +3,7 @@ import readXlsxFile from "read-excel-file/node";
 import { inferImportColumnDataType, parseDateValueToIso, } from "./column-types.js";
 import { OxygenError } from "./index.js";
 const MAX_IDENTIFIER_LENGTH = 63;
+export const MAX_BUFFERED_IMPORT_PARSE_BYTES = 10 * 1024 * 1024;
 export function inferRowsFileFormat(path) {
     const extension = extname(path).toLowerCase();
     if (extension === ".jsonl" || extension === ".ndjson")
@@ -31,6 +32,20 @@ export async function parseRowsFileBuffer(buffer, format, options = {}) {
         return await parseXlsxRows(buffer, options);
     return parseRowsText(buffer.toString("utf8"), format);
 }
+export async function* iterateRowsFileBufferBatches(buffer, format, options = {}) {
+    const batchSize = normalizeBatchSize(options.batchSize);
+    if (format === "csv") {
+        yield* iterateCsvRowBatches(buffer.toString("utf8"), batchSize);
+        return;
+    }
+    if (format === "jsonl") {
+        yield* iterateJsonlRowBatches(buffer.toString("utf8"), batchSize);
+        return;
+    }
+    assertBufferedParseWithinLimit(buffer, format);
+    const rows = await parseRowsFileBuffer(buffer, format, options.sheet ? { sheet: options.sheet } : {});
+    yield* chunkRows(rows, batchSize);
+}
 export function parseRowsText(text, format) {
     if (format === "json")
         return normalizeRowObjects(parseJsonArray(text));
@@ -145,12 +160,13 @@ function parseJsonArray(text) {
     return parsed;
 }
 function normalizeRowObjects(rows) {
-    return rows.map((row) => {
-        if (!row || typeof row !== "object" || Array.isArray(row)) {
-            throw new OxygenError("invalid_rows", "Rows must be JSON objects.", { exitCode: 1 });
-        }
-        return row;
-    });
+    return rows.map((row) => normalizeRowObject(row));
+}
+function normalizeRowObject(row) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+        throw new OxygenError("invalid_rows", "Rows must be JSON objects.", { exitCode: 1 });
+    }
+    return row;
 }
 function parseCsvRows(text) {
     const records = parseCsvRecords(text);
@@ -166,6 +182,140 @@ function normalizeCsvImportCell(value) {
         return null;
     return value;
 }
+function* iterateCsvRowBatches(text, batchSize) {
+    const state = {
+        header: null,
+        batch: [],
+        record: [],
+        field: "",
+        inQuotes: false,
+    };
+    for (let index = 0; index < text.length; index += 1) {
+        const result = applyCsvCharacter(state, text.charAt(index), text.charAt(index + 1));
+        if (result.skipNext)
+            index += 1;
+        if (!result.recordComplete)
+            continue;
+        const ready = appendCsvRecordToBatch(state, finishCsvRecord(state), batchSize);
+        if (ready)
+            yield ready;
+    }
+    if (state.field || state.record.length > 0) {
+        const ready = appendCsvRecordToBatch(state, finishCsvRecord(state), batchSize);
+        if (ready)
+            yield ready;
+    }
+    if (state.batch.length > 0)
+        yield state.batch;
+}
+function applyCsvCharacter(state, char, next) {
+    return state.inQuotes
+        ? applyQuotedCsvCharacter(state, char, next)
+        : applyUnquotedCsvCharacter(state, char);
+}
+function applyQuotedCsvCharacter(state, char, next) {
+    if (char === "\"" && next === "\"") {
+        state.field += "\"";
+        return { recordComplete: false, skipNext: true };
+    }
+    if (char === "\"") {
+        state.inQuotes = false;
+    }
+    else {
+        state.field += char;
+    }
+    return { recordComplete: false, skipNext: false };
+}
+function applyUnquotedCsvCharacter(state, char) {
+    if (char === "\"") {
+        state.inQuotes = true;
+        return { recordComplete: false, skipNext: false };
+    }
+    if (char === ",") {
+        pushCsvField(state);
+        return { recordComplete: false, skipNext: false };
+    }
+    if (char === "\n") {
+        return { recordComplete: true, skipNext: false };
+    }
+    if (char !== "\r")
+        state.field += char;
+    return { recordComplete: false, skipNext: false };
+}
+function pushCsvField(state) {
+    state.record.push(state.field);
+    state.field = "";
+}
+function finishCsvRecord(state) {
+    pushCsvField(state);
+    const record = state.record;
+    state.record = [];
+    state.field = "";
+    return record;
+}
+function appendCsvRecordToBatch(state, record, batchSize) {
+    const row = csvRecordToRow(record, state.header);
+    if (state.header === null)
+        state.header = record;
+    if (row)
+        state.batch.push(row);
+    if (state.batch.length < batchSize)
+        return null;
+    const ready = state.batch;
+    state.batch = [];
+    return ready;
+}
+function csvRecordToRow(record, header) {
+    if (header === null)
+        return null;
+    if (!record.some((cell) => cell.trim()))
+        return null;
+    return Object.fromEntries(header.map((key, index) => [key, normalizeCsvImportCell(record[index])]));
+}
+function* iterateJsonlRowBatches(text, batchSize) {
+    let batch = [];
+    let lineStart = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charAt(index) !== "\n")
+            continue;
+        const line = text.slice(lineStart, index).replace(/\r$/, "").trim();
+        lineStart = index + 1;
+        if (!line)
+            continue;
+        batch.push(normalizeRowObject(JSON.parse(line)));
+        if (batch.length >= batchSize) {
+            yield batch;
+            batch = [];
+        }
+    }
+    const trailingLine = text.slice(lineStart).replace(/\r$/, "").trim();
+    if (trailingLine)
+        batch.push(normalizeRowObject(JSON.parse(trailingLine)));
+    if (batch.length > 0)
+        yield batch;
+}
+function* chunkRows(rows, batchSize) {
+    for (let index = 0; index < rows.length; index += batchSize) {
+        yield rows.slice(index, index + batchSize);
+    }
+}
+function normalizeBatchSize(value) {
+    if (!Number.isFinite(value) || value === undefined)
+        return 1000;
+    return Math.max(1, Math.trunc(value));
+}
+function assertBufferedParseWithinLimit(buffer, format) {
+    if (buffer.byteLength <= MAX_BUFFERED_IMPORT_PARSE_BYTES)
+        return;
+    throw new OxygenError("buffered_import_too_large", "Large JSON array and XLSX imports require buffered parsing; use CSV or JSONL for large staged imports.", {
+        details: {
+            format,
+            file_bytes: buffer.byteLength,
+            max_buffered_parse_bytes: MAX_BUFFERED_IMPORT_PARSE_BYTES,
+        },
+        exitCode: 1,
+    });
+}
 function parseCsvRecords(text) {
     const records = [];
     let record = [];

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

@@ -4,6 +4,7 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;

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

@@ -5,6 +5,7 @@ export * from "./cell-format.js";
 export * from "./column-types.js";
 export * from "./credit-guidance.js";
 export * from "./log.js";
+export * from "./provider-request-outcomes.js";
 export * from "./telemetry.js";
 export class OxygenError extends Error {
     code;

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

@@ -0,0 +1,26 @@
+export declare function isObjectStorageConfigured(): boolean;
+export declare function buildImportObjectKey(input: {
+    organizationId: string;
+    fileName?: string | null;
+}): string;
+export declare function isImportObjectKeyForOrganization(key: string, organizationId: string): boolean;
+export type PresignedImportUpload = {
+    uploadUrl: string;
+    bucket: string;
+    storageKey: string;
+    contentLength: number;
+    provider: "s3";
+    expiresInSeconds: number;
+};
+export declare function presignImportUpload(input: {
+    organizationId: string;
+    fileName?: string | null;
+    contentType?: string | null;
+    contentLength: number;
+}): Promise<PresignedImportUpload>;
+export declare function downloadImportObject(input: {
+    storageKey: string;
+}): Promise<Buffer>;
+export declare function deleteImportObject(input: {
+    storageKey: string;
+}): Promise<void>;

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

@@ -0,0 +1,115 @@
+import { randomUUID } from "node:crypto";
+import { DeleteObjectCommand, GetObjectCommand, PutObjectCommand, S3Client, } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { OxygenError } from "./index.js";
+// S3-compatible object storage for large CSV/file imports. The CLI uploads the
+// raw file straight to the bucket via a presigned PUT URL (bypassing Vercel's
+// ~4.5MB request-body limit), then the Fly worker downloads it and COPY-loads
+// it. Configured against Hetzner Object Storage (S3-compatible) via the
+// OXYGEN_IMPORT_S3_* env vars; works with any S3-compatible endpoint.
+const PRESIGN_EXPIRY_SECONDS = 900;
+function readImportStorageConfig() {
+    const endpoint = process.env.OXYGEN_IMPORT_S3_ENDPOINT?.trim();
+    const bucket = process.env.OXYGEN_IMPORT_S3_BUCKET?.trim();
+    const accessKeyId = process.env.OXYGEN_IMPORT_S3_ACCESS_KEY_ID?.trim();
+    const secretAccessKey = process.env.OXYGEN_IMPORT_S3_SECRET_ACCESS_KEY?.trim();
+    if (!endpoint || !bucket || !accessKeyId || !secretAccessKey)
+        return null;
+    // Hetzner uses a location code (fsn1/nbg1/hel1) as its region; the S3 SDK
+    // only needs a non-empty string, so default to "auto" when unset.
+    const region = process.env.OXYGEN_IMPORT_S3_REGION?.trim() || "auto";
+    // Path-style addressing avoids bucket-in-hostname DNS/TLS edge cases on
+    // S3-compatible providers; default on, opt out with "false".
+    const forcePathStyle = process.env.OXYGEN_IMPORT_S3_FORCE_PATH_STYLE?.trim() !== "false";
+    return { endpoint, region, bucket, accessKeyId, secretAccessKey, forcePathStyle };
+}
+export function isObjectStorageConfigured() {
+    return readImportStorageConfig() !== null;
+}
+let cachedClient = null;
+function resolveClient() {
+    const config = readImportStorageConfig();
+    if (!config) {
+        throw new OxygenError("object_storage_not_configured", "Import object storage (OXYGEN_IMPORT_S3_*) is not configured.", { exitCode: 1 });
+    }
+    const cacheKey = `${config.endpoint}|${config.region}|${config.accessKeyId}|${config.forcePathStyle}`;
+    if (!cachedClient || cachedClient.key !== cacheKey) {
+        cachedClient = {
+            key: cacheKey,
+            client: new S3Client({
+                endpoint: config.endpoint,
+                region: config.region,
+                forcePathStyle: config.forcePathStyle,
+                credentials: {
+                    accessKeyId: config.accessKeyId,
+                    secretAccessKey: config.secretAccessKey,
+                },
+            }),
+        };
+    }
+    return { client: cachedClient.client, config };
+}
+// Keys are namespaced by org so a tenant can only ever be handed (and the
+// enqueue route only accepts) keys under its own prefix.
+export function buildImportObjectKey(input) {
+    const safeName = sanitizeFileName(input.fileName) || "import";
+    return `imports/${input.organizationId}/${randomUUID()}/${safeName}`;
+}
+export function isImportObjectKeyForOrganization(key, organizationId) {
+    return key.startsWith(`imports/${organizationId}/`);
+}
+export async function presignImportUpload(input) {
+    const { client, config } = resolveClient();
+    const storageKey = buildImportObjectKey({
+        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,
+    };
+}
+export async function downloadImportObject(input) {
+    const { client, config } = resolveClient();
+    const result = await client.send(new GetObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
+    const body = result.Body;
+    if (!body) {
+        throw new OxygenError("import_object_missing", "Import object had no body.", {
+            details: { storage_key: input.storageKey },
+            exitCode: 1,
+        });
+    }
+    const transform = body.transformToByteArray;
+    if (typeof transform === "function") {
+        return Buffer.from(await transform.call(body));
+    }
+    return streamToBuffer(body);
+}
+export async function deleteImportObject(input) {
+    const { client, config } = resolveClient();
+    await client.send(new DeleteObjectCommand({ Bucket: config.bucket, Key: input.storageKey }));
+}
+function sanitizeFileName(fileName) {
+    if (!fileName)
+        return "";
+    const base = fileName.split(/[\\/]/).pop() ?? "";
+    return base.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120);
+}
+async function streamToBuffer(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.d.ts

@@ -0,0 +1,3 @@
+export declare const PROVIDER_REQUEST_OUTCOMES: readonly ["success", "error", "blocked"];
+export type ProviderRequestOutcome = (typeof PROVIDER_REQUEST_OUTCOMES)[number];
+export declare function isProviderRequestOutcome(value: unknown): value is ProviderRequestOutcome;

package/node_modules/@oxygen/shared/dist/provider-request-outcomes.js

@@ -0,0 +1,5 @@
+export const PROVIDER_REQUEST_OUTCOMES = ["success", "error", "blocked"];
+const PROVIDER_REQUEST_OUTCOME_SET = new Set(PROVIDER_REQUEST_OUTCOMES);
+export function isProviderRequestOutcome(value) {
+    return typeof value === "string" && PROVIDER_REQUEST_OUTCOME_SET.has(value);
+}

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

@@ -1 +1 @@
-export declare const OXYGEN_VERSION = "1.50.37";
+export declare const OXYGEN_VERSION = "1.98.7";

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

@@ -1 +1 @@
-export const OXYGEN_VERSION = "1.50.37";
+export const OXYGEN_VERSION = "1.98.7";

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

@@ -1,7 +1,10 @@
 export declare const WORKFLOW_MANIFEST_VERSION = 1;
 export declare const WORKFLOW_COMPILER_VERSION = "oxygen-workflows-v1";
 export declare const DURABLE_RECIPE_COMPILER_VERSION = "oxygen-recipes-v2";
+export declare const BLUEPRINT_VERSION = 1;
+export declare const BLUEPRINT_COMPILER_VERSION = "oxygen-blueprints-v1";
 export declare const MAX_RECIPE_BUNDLE_BYTES = 2000000;
+export declare const MAX_BLUEPRINT_BYTES = 4000000;
 export declare const DEFAULT_WORKFLOW_CRON_TIMEZONE = "UTC";
 export type WorkflowMode = "dry_run" | "live" | "smoke_test";
 export type WorkflowTriggerType = "api" | "webhook" | "cron" | "event";
@@ -100,6 +103,72 @@ export type RecipeManifest = {
     created_at: string;
 };
 export type AnyWorkflowManifest = WorkflowManifest | RecipeManifest;
+export type BlueprintColumnInput = {
+    key?: string;
+    label: string;
+    dataType?: string;
+    kind?: string;
+    semanticType?: string | null;
+    definition?: Record<string, unknown>;
+};
+export type BlueprintTable = {
+    ref: string;
+    name: string;
+    description?: string;
+    columns: BlueprintColumnInput[];
+    metadata?: Record<string, unknown>;
+};
+export type BlueprintColumnGraft = {
+    table_ref: string;
+    column: BlueprintColumnInput;
+};
+export type BlueprintPromptKind = "ai_column_system" | "scoring_rubric" | "other";
+export type BlueprintPromptTemplate = {
+    slug: string;
+    name: string;
+    description?: string | null;
+    kind: BlueprintPromptKind;
+    body: string;
+};
+export type BlueprintIntegrationRequirement = {
+    kind: string;
+    purpose?: string;
+    required?: boolean;
+};
+export type BlueprintByokRequirement = {
+    kind: "openai" | "anthropic" | "google" | "openrouter" | string;
+    required?: boolean;
+};
+export type BlueprintRequires = {
+    integrations?: BlueprintIntegrationRequirement[];
+    context_keys?: string[];
+    byok?: BlueprintByokRequirement[];
+};
+export type BlueprintWorkflow = {
+    manifest: AnyWorkflowManifest;
+    table_refs?: Record<string, string>;
+    prompt_template_slugs?: string[];
+};
+export type Blueprint = {
+    blueprint_version: typeof BLUEPRINT_VERSION;
+    id: string;
+    name: string;
+    summary: string;
+    tags: string[];
+    audience?: string[];
+    requires: BlueprintRequires;
+    input_schema?: JsonSchema;
+    tables: BlueprintTable[];
+    column_grafts?: BlueprintColumnGraft[];
+    prompt_templates: BlueprintPromptTemplate[];
+    workflows: BlueprintWorkflow[];
+    exported_at: string;
+    exported_from?: {
+        oxygen_version?: string;
+    };
+    source_hash: string;
+    compiler_version: typeof BLUEPRINT_COMPILER_VERSION;
+};
 export type WorkflowApplyInput = {
     manifest: WorkflowManifest;
 };
@@ -229,6 +298,28 @@ export declare function lintRecipeManifest(// skipcq: JS-R1005
 value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
 export declare function assertRecipeManifest(value: unknown, options?: WorkflowManifestValidationOptions): asserts value is RecipeManifest;
 export declare function assertWorkflowManifest(value: unknown, options?: WorkflowManifestValidationOptions): asserts value is WorkflowManifest;
+export declare function isBlueprint(value: unknown): value is Blueprint;
+export declare function lintBlueprint(// skipcq: JS-R1005
+value: unknown, options?: WorkflowManifestValidationOptions): WorkflowLintResult;
+export declare function assertBlueprint(value: unknown, options?: WorkflowManifestValidationOptions): asserts value is Blueprint;
+export declare function buildBlueprint(input: {
+    id: string;
+    name: string;
+    summary?: string;
+    tags?: string[];
+    audience?: string[];
+    requires?: BlueprintRequires;
+    inputSchema?: JsonSchema;
+    tables: BlueprintTable[];
+    columnGrafts?: BlueprintColumnGraft[];
+    promptTemplates?: BlueprintPromptTemplate[];
+    workflows: BlueprintWorkflow[];
+    exportedFrom?: {
+        oxygen_version?: string;
+    };
+    exportedAt?: Date;
+    sourceHash?: string;
+}): Blueprint;
 export declare function validateJsonSchemaValue(value: unknown, schema: JsonSchema | undefined, path?: string): JsonSchemaValidationIssue[];
 export declare function assertRecipeBundleSafe(bundle: string): void;
 export declare function lintRecipeBundleSafety(bundle: string, path?: string): WorkflowLintIssue[];