@quantiya/codevibe-core 2.0.89 → 2.0.90

package/dist/local-executor/binary-classifier.d.ts

@@ -0,0 +1,117 @@
+/** Random access to one immutable file. The caller owns opening and closing it. */
+export interface FileSource {
+    size: number;
+    read(position: number, length: number): Promise<Buffer>;
+}
+export type OfficeFormat = 'docx' | 'xlsx' | 'pptx';
+export type FileClass = {
+    kind: 'text';
+} | {
+    kind: 'office';
+    format: OfficeFormat;
+} | {
+    kind: 'image';
+    format: 'png' | 'jpeg' | 'gif' | 'webp' | 'heic';
+} | {
+    kind: 'pdf';
+} | {
+    kind: 'other';
+    format: 'audio' | 'video' | 'archive' | 'other_binary';
+};
+/** §10.2: per-part inflate output limit (64 MiB). */
+export declare const MAX_OFFICE_PART_BYTES: number;
+/**
+ * Per-archive cumulative inflated output limit (256 MiB) across all parts of one
+ * Office file version, bounding total memory and inflate work on multi-part archives.
+ */
+export declare const MAX_OFFICE_ARCHIVE_INFLATED_BYTES: number;
+/** Initial header scan length (8 KiB) for magic detection and initial UTF-8/NUL check. */
+export declare const HEADER_SCAN_BYTES: number;
+/** Chunk size (64 KiB) for streaming full-file strict UTF-8 and NUL verification. */
+export declare const UTF8_SCAN_CHUNK_BYTES: number;
+/**
+ * Compute standard IEEE 802.3 CRC32 of `buf` as an unsigned 32-bit integer (`0..0xffffffff`).
+ * Uses a deterministic lookup table so CRC32 verification works across all Node.js >= 22.0.0
+ * runtimes without depending on `zlib.crc32` (added in Node 22.2.0).
+ */
+export declare function computeCrc32(buf: Buffer): number;
+export interface ZipEntryMeta {
+    name: string;
+    method: number;
+    flags: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    localHeaderOffset: number;
+}
+export interface ZipArchiveMeta {
+    cdOffset: number;
+    entries: Map<string, ZipEntryMeta>;
+}
+export type ZipInspectResult = {
+    ok: true;
+    archive: ZipArchiveMeta;
+} | {
+    ok: false;
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+export type ZipEntryReadResult = {
+    ok: true;
+    bytes: Buffer;
+} | {
+    ok: false;
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+/**
+ * Read up to `length` bytes starting at `position`, looping across short reads.
+ * Returns `null` if EOF is reached before `length` bytes or arguments are out of range.
+ * Rejections from `source.read` propagate untouched.
+ */
+export declare function readExact(source: FileSource, position: number, length: number): Promise<Buffer | null>;
+/**
+ * Validate a ZIP central-directory entry name:
+ * - non-empty and bounded length
+ * - no ASCII or C1 control characters (`\p{Cc}`), format/bidi/BOM characters (`\p{Cf}`),
+ *   or Unicode line/paragraph separators (`\p{Zl}`, `\p{Zp}`)
+ * - no backslashes (`\`) or leading `/`
+ * - no empty (`//`), `.`, or `..` path segments
+ */
+export declare function isSafeZipPartName(name: string): boolean;
+/**
+ * Parse a ZIP archive's End of Central Directory and Central Directory via random access.
+ * Refuses ZIP64 archives (`reason: 'zip64'`), oversized central directories (`reason: 'part_too_large'`),
+ * and malformed/unsafe/duplicate part names (`reason: 'malformed'`).
+ */
+export declare function inspectZipArchive(source: FileSource): Promise<ZipInspectResult>;
+/**
+ * Read and inflate one entry from a validated ZIP archive, enforcing the 64 MiB
+ * per-part bound, verifying local file header consistency, and checking CRC32 integrity.
+ */
+export declare function readZipEntryBytes(source: FileSource, archive: ZipArchiveMeta, entry: ZipEntryMeta): Promise<ZipEntryReadResult>;
+/**
+ * Find the index past the closing `>` of an XML declaration (`<!DOCTYPE ...>`,
+ * `<!ENTITY ...>`, etc.) starting at `lt` (`xml.startsWith('<!', lt)`),
+ * respecting quoted strings (`"..."`, `'...'`), nested comments (`<!-- ... -->`),
+ * nested processing instructions (`<? ... ?>`), and internal DTD subset brackets (`[ ... ]`).
+ * Returns `-1` if the declaration is unclosed.
+ */
+export declare function findXmlDeclarationEnd(xml: string, lt: number): number;
+/**
+ * Linear O(N) stripper for XML comments (`<!-- ... -->`), processing instructions (`<? ... ?>`),
+ * CDATA sections (`<![CDATA[ ... ]]>`), and DOCTYPE/declarations (`<! ... >`).
+ * Used when inspecting structural XML tags so commented-out or DTD-declared elements are ignored.
+ */
+export declare function stripXmlCommentsAndDeclarations(xml: string): string;
+/**
+ * Detect whether `[Content_Types].xml` names a WordprocessingML (`docx`),
+ * SpreadsheetML (`xlsx`), or PresentationML (`pptx`) main part.
+ * Strips XML comments and declarations first so commented-out `<Override>` elements are ignored.
+ * Returns `'ambiguous'` if multiple distinct Office main content types are present.
+ */
+export declare function detectOfficeFormatFromContentTypes(contentTypesXml: string): OfficeFormat | 'ambiguous' | null;
+/** Verify that the archive contains the structural parts required for `format`. */
+export declare function hasRequiredOfficeMainParts(entries: Map<string, ZipEntryMeta>, format: OfficeFormat): boolean;
+/**
+ * Classify `source` according to §10.1 (`text`, `office`, `image`, `pdf`, or `other`).
+ */
+export declare function classifyFile(source: FileSource): Promise<FileClass>;

package/dist/local-executor/office-extractor.d.ts

@@ -0,0 +1,61 @@
+import { type FileSource, type OfficeFormat } from './binary-classifier';
+export type { FileSource, OfficeFormat } from './binary-classifier';
+export interface OfficePartChange {
+    part: string;
+    change: 'added' | 'removed' | 'modified';
+    mark: 'text changed' | 'no text change — inspect the part';
+}
+export type OfficeExtraction = {
+    ok: true;
+    format: OfficeFormat;
+    beforeText: string | null;
+    afterText: string;
+    parts: OfficePartChange[];
+} | {
+    ok: false;
+    fallback: 'other_binary';
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+/**
+ * Maximum cumulative extracted text characters and element-overhead units (32 MiB)
+ * per Office archive version, preventing memory exhaustion or V8 RangeError on
+ * high-expansion shared-string or dense-element inputs.
+ */
+export declare const MAX_OFFICE_EXTRACTED_TEXT_BYTES: number;
+/**
+ * Maximum cumulative decoded XML characters (64 MiB) across all extracted XML parts
+ * of one Office archive version before text extraction runs.
+ */
+export declare const MAX_OFFICE_DECODED_XML_CHARS: number;
+/**
+ * Per-element budget charge (64 bytes) applied to structural XML elements (`<si>`, `<c>`,
+ * `<sheet>`, `<definedName>`, `<Relationship>`, `<p:sldId>`, `<w:p>`, `<a:p>`, `<w:comment>`,
+ * and inner elements buffered inside `<w:comment>`) so millions of empty tags
+ * (`<si/>`, `<c/>`, `<sheet/>`, `<a>`) cannot allocate unbounded arrays.
+ */
+export declare const ELEMENT_BUDGET_OVERHEAD = 64;
+/**
+ * Per-chunk budget charge (32 bytes) applied alongside character length whenever a
+ * text fragment is pushed into an intermediate chunk array or string accumulator,
+ * bounding V8 array/string-object overhead on millions of tiny text runs.
+ */
+export declare const CHUNK_BUDGET_OVERHEAD = 32;
+declare class TextBudget {
+    private readonly limit;
+    private used;
+    constructor(limit?: number);
+    add(chars: number): boolean;
+    get exceeded(): boolean;
+}
+/**
+ * Decode standard XML named and numeric character entities in a single linear O(N) pass
+ * without global regex replacement (`Runtime_RegExpExecMultiple`). Caches `nextSemi` so
+ * semicolons are never rescanned across multiple `&` characters, emits slices only when
+ * a valid entity is decoded (charging `CHUNK_BUDGET_OVERHEAD` per decoded entity when a
+ * budget is supplied), and leaves undecoded `&` sequences in the original contiguous
+ * string slice with zero intermediate string allocations. Doubly-escaped sequences
+ * (e.g. `&#38;lt;` or `&#x26;#65;`) are decoded once.
+ */
+export declare function decodeXmlEntities(raw: string, budget?: TextBudget): string;
+/** `before` is null for a created file. A deletion needs no extraction text beyond the `before/` original. */
+export declare function extractOfficeChange(before: FileSource | null, after: FileSource): Promise<OfficeExtraction>;

package/dist/orchestration-shell/cli.js

@@ -24263,7 +24263,13 @@ var AppSyncClient = class _AppSyncClient {
       this.assertSyncAccount(userId);
       let session2 = await this.getSession(state.sessionId);
       if (!current()) return;
-      if (this.assertSyncAccount(userId), !session2 || session2.userId !== userId || !["ACTIVE" /* ACTIVE */, "PAUSED" /* PAUSED */].includes(session2.status))
+      if (this.assertSyncAccount(userId), !session2 || session2.sessionId !== state.sessionId || session2.userId !== userId || state.syncSessionGenerationId !== void 0 && session2.sessionGenerationId !== state.syncSessionGenerationId)
+        throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
+      if (session2.status === "INACTIVE" /* INACTIVE */ && session2.sessionGenerationId) {
+        this.notifyRetiredSession(state.sessionId);
+        return;
+      }
+      if (!["ACTIVE" /* ACTIVE */, "PAUSED" /* PAUSED */].includes(session2.status))
         throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
       let retainedIds = /* @__PURE__ */ new Set();
       state.mobileInputRecoveryHeld = !1, session2.sessionGenerationId && (state.compatibilityInboundIds = retainedIds, state.syncSessionGenerationId = session2.sessionGenerationId), this.createLegacySubscription(state), !(!session2.sessionGenerationId || !current()) && (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.89",
+  "version": "2.0.90",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",