@oxygen-agent/cli 1.64.5 → 1.99.1

package/dist/skills.d.ts

@@ -1,5 +1,6 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 export type ExecFileSyncLike = typeof execFileSync;
+export type SpawnSyncLike = typeof spawnSync;
 export type SkillsInstallOptions = {
     json?: boolean;
     apiUrl?: string;
@@ -29,13 +30,18 @@ export type AutomaticSkillsInstallResult = {
 };
 export declare function listAgentSkills(options: SkillsListOptions): Promise<Record<string, unknown>>;
 export declare function doctorAgentSkills(options: SkillsDoctorOptions): Promise<Record<string, unknown>>;
-export declare function installAgentSkills(options: SkillsInstallOptions, runtime?: {
+export declare function installAgentSkills(// skipcq: JS-R1005
+options: SkillsInstallOptions, runtime?: {
     env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
     execFileSync?: ExecFileSyncLike;
+    spawnSync?: SpawnSyncLike;
 }): Record<string, unknown>;
 export declare function runAutomaticSkillsInstall(options?: {
     apiUrl?: string;
     env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
     execFileSync?: ExecFileSyncLike;
+    spawnSync?: SpawnSyncLike;
 }): AutomaticSkillsInstallResult;
 export declare function skippedAutomaticSkillsInstall(reason: string, apiUrl?: string): AutomaticSkillsInstallResult;

package/dist/skills.js

@@ -1,9 +1,10 @@
-import { execFileSync, spawnSync } from "node:child_process";
+import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { OxygenError, toFailure } from "@oxygen/shared";
 import { defaultApiUrl, normalizeApiUrl } from "./credentials.js";
+import { resolveCmdShimInvocation } from "./windows-shim.js";
 const DEFAULT_SKILL_AGENTS = ["codex", "claude-code", "cursor"];
 const SKILL_INDEX_PATH = "/.well-known/skills/index.json";
 export async function listAgentSkills(options) {
@@ -52,32 +53,39 @@ export async function doctorAgentSkills(options) {
     }
     return data;
 }
-export function installAgentSkills(options, runtime = {}) {
+export function installAgentSkills(// skipcq: JS-R1005
+options, runtime = {}) {
     const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
     const indexUrl = skillIndexUrl(apiUrl);
     const agents = readWords(options.agents ?? DEFAULT_SKILL_AGENTS);
     const skill = readOption(options.skill) ?? "*";
+    const env = runtime.env ?? process.env;
+    const platform = runtime.platform ?? process.platform;
     const args = installerAddArgs(indexUrl, agents, skill);
     if (!options.project)
         args.push("--global");
     if (options.copy)
         args.push("--copy");
-    let output = "";
-    try {
-        const exec = runtime.execFileSync ?? execFileSync;
-        output = String(exec("npx", args, {
-            encoding: "utf8",
-            env: runtime.env ?? process.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        }));
-    }
-    catch (error) {
-        const failure = error;
+    const invocation = resolveCmdShimInvocation("npx", args, platform, env);
+    const spawn = runtime.spawnSync ?? wrapExecFileSync(runtime.execFileSync) ?? spawnSync;
+    const result = spawn(invocation.executable, invocation.args, {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        ...(platform === "win32" ? { windowsVerbatimArguments: true } : {}),
+    });
+    const stdout = typeof result.stdout === "string" ? result.stdout : "";
+    const stderr = typeof result.stderr === "string" ? result.stderr : "";
+    if (result.error || (typeof result.status === "number" && result.status !== 0)) {
+        const message = result.error instanceof Error ? result.error.message : null;
         throw new OxygenError("skills_install_failed", "Unable to install Oxygen agent skills.", {
             details: {
                 index_url: indexUrl,
-                stdout: failure.stdout?.slice(0, 2000) ?? "",
-                stderr: failure.stderr?.slice(0, 2000) ?? failure.message ?? "unknown",
+                executable: invocation.label,
+                exit_code: typeof result.status === "number" ? result.status : null,
+                stdout: stdout.slice(0, 2000),
+                stderr: (stderr || message || "unknown").slice(0, 2000),
             },
             exitCode: 1,
         });
@@ -88,12 +96,45 @@ export function installAgentSkills(options, runtime = {}) {
         agents,
         skill,
         scope: options.project ? "project" : "global",
-        output,
+        output: stdout,
     };
 }
+// Adapt the legacy `execFileSync` runtime hook into a spawnSync-shaped return so
+// existing test fixtures (update.test.ts) keep working without a coordinated
+// rewrite. New tests should inject `spawnSync` directly.
+function wrapExecFileSync(exec) {
+    if (!exec)
+        return undefined;
+    return ((command, args, opts) => {
+        try {
+            const stdout = exec(command, args, opts);
+            return {
+                status: 0,
+                signal: null,
+                output: [],
+                pid: 0,
+                stdout: typeof stdout === "string" ? stdout : Buffer.isBuffer(stdout) ? stdout.toString("utf8") : "",
+                stderr: "",
+            };
+        }
+        catch (error) {
+            const failure = error;
+            return {
+                status: typeof failure.status === "number" ? failure.status : 1,
+                signal: null,
+                output: [],
+                pid: 0,
+                stdout: failure.stdout ?? "",
+                stderr: failure.stderr ?? failure.message ?? "",
+                error: error instanceof Error ? error : new Error(String(error)),
+            };
+        }
+    });
+}
 export function runAutomaticSkillsInstall(options = {}) {
     const apiUrl = normalizeApiUrl(readOption(options.apiUrl) ?? defaultApiUrl());
     const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
     if (env.OXYGEN_SKIP_SKILLS === "1") {
         return skippedAutomaticSkillsInstall("OXYGEN_SKIP_SKILLS=1", apiUrl);
     }
@@ -104,9 +145,14 @@ export function runAutomaticSkillsInstall(options = {}) {
             agents: DEFAULT_SKILL_AGENTS,
             skill: "*",
             json: true,
+            // `npx skills add` symlinks by default; on Windows that requires Developer
+            // Mode or admin elevation, so copy is the only reliable unattended path.
+            copy: platform === "win32",
         }, {
             env,
+            platform,
             ...(options.execFileSync ? { execFileSync: options.execFileSync } : {}),
+            ...(options.spawnSync ? { spawnSync: options.spawnSync } : {}),
         });
         return {
             attempted: true,
@@ -233,10 +279,13 @@ function parseSkillIndex(value) {
     };
 }
 function inspectSkillsInstaller() {
-    const result = spawnSync("npx", ["--version"], {
+    const invocation = resolveCmdShimInvocation("npx", ["--version"], process.platform, process.env);
+    const result = spawnSync(invocation.executable, invocation.args, {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 5000,
+        windowsHide: true,
+        ...(process.platform === "win32" ? { windowsVerbatimArguments: true } : {}),
     });
     const error = result.error instanceof Error ? result.error.message : null;
     const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
@@ -244,6 +293,7 @@ function inspectSkillsInstaller() {
     return {
         command_path: "npx",
         check_args: ["--version"],
+        invocation: { executable: invocation.label, args: invocation.args },
         available: result.status === 0 && !error,
         version: stdout || null,
         ...(error ? { error } : {}),

package/dist/update.js

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { OXYGEN_VERSION, OxygenError } from "@oxygen/shared";
 import { runAutomaticSkillsInstall, skippedAutomaticSkillsInstall, } from "./skills.js";
+import { quoteWindowsCmdArg } from "./windows-shim.js";
 const DEFAULT_CLI_PACKAGE_SPEC = "@oxygen-agent/cli@latest";
 // skipcq: JS-R1005 — handles platform/install-mode/dry-run combinations end-to-end
 export function updateCli(options, runtime = {}) {
@@ -53,6 +54,7 @@ export function updateCli(options, runtime = {}) {
                 updated: true,
                 skills_install: runAutomaticSkillsInstall({
                     env,
+                    platform,
                     ...(runtime.execFileSync ? { execFileSync: runtime.execFileSync } : {}),
                 }),
             };
@@ -111,11 +113,6 @@ function resolveNpmInvocations(args, platform, env) {
             label: shell,
         }];
 }
-function quoteWindowsCmdArg(value) {
-    if (/^[A-Za-z0-9_@+=:,./\\-]+$/.test(value))
-        return value;
-    return `"${value.replace(/(["^&|<>()%])/g, "^$1")}"`;
-}
 function quoteForDisplay(value) {
     if (/^[A-Za-z0-9_@+=:,./-]+$/.test(value))
         return value;

package/dist/windows-shim.d.ts

@@ -0,0 +1,7 @@
+export type CmdShimInvocation = {
+    executable: string;
+    args: string[];
+    label: string;
+};
+export declare function resolveCmdShimInvocation(command: string, args: string[], platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): CmdShimInvocation;
+export declare function quoteWindowsCmdArg(value: string): string;

package/dist/windows-shim.js

@@ -0,0 +1,21 @@
+// Windows-aware command launcher. Node's `execFileSync`/`spawnSync` cannot
+// resolve `.cmd`/`.bat` shims (like `npx.cmd`) from a bare command name, so on
+// Windows we route through `cmd.exe /d /s /c <command> <args>` with
+// `windowsVerbatimArguments: true`. Spawn options must enable that flag at the
+// caller — see `update.ts` and `skills.ts` for the pattern.
+export function resolveCmdShimInvocation(command, args, platform = process.platform, env = process.env) {
+    if (platform !== "win32") {
+        return { executable: command, args, label: command };
+    }
+    const shell = env.ComSpec?.trim() || "cmd.exe";
+    return {
+        executable: shell,
+        args: ["/d", "/s", "/c", [command, ...args].map(quoteWindowsCmdArg).join(" ")],
+        label: shell,
+    };
+}
+export function quoteWindowsCmdArg(value) {
+    if (/^[A-Za-z0-9_@+=:,./\\-]+$/.test(value))
+        return value;
+    return `"${value.replace(/(["^&|<>()%])/g, "^$1")}"`;
+}

package/node_modules/@oxygen/shared/dist/file-import.d.ts

@@ -10,11 +10,16 @@ export type NewTableImportRows = {
     rows: Record<string, unknown>[];
     keyBySource: Record<string, string>;
 };
+export declare const MAX_BUFFERED_IMPORT_PARSE_BYTES: number;
 export declare function inferRowsFileFormat(path: string): RowsFileFormat;
 export declare function normalizeRowsFormat(value: string | undefined, fallback: RowsFileFormat): RowsFileFormat;
 export declare function parseRowsFileBuffer(buffer: Buffer, format: RowsFileFormat, options?: {
     sheet?: string;
 }): Promise<Record<string, unknown>[]>;
+export declare function iterateRowsFileBufferBatches(buffer: Buffer, format: RowsFileFormat, options?: {
+    sheet?: string;
+    batchSize?: number;
+}): AsyncGenerator<Record<string, unknown>[]>;
 export declare function parseRowsText(text: string, format: Exclude<RowsFileFormat, "xlsx">): Record<string, unknown>[];
 export declare function inferImportColumnLabels(rows: Record<string, unknown>[]): string[];
 export declare function normalizeRowsForNewTable(rows: Record<string, unknown>[]): NewTableImportRows;

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/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/version.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_VERSION = "1.64.5";
+export declare const OXYGEN_VERSION = "1.99.1";

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

@@ -1 +1 @@
-export const OXYGEN_VERSION = "1.64.5";
+export const OXYGEN_VERSION = "1.99.1";