@eddyskywalker/dsh-chatgpt-subscription 0.30.0 → 0.31.0

package/lib/types/host/minimax-code/video-history.d.ts

@@ -0,0 +1,240 @@
+/**
+ * Generation history for the MiniMax Code video tools.
+ *
+ * The two video tools (`minimax_generate_video` / `minimax_understand_video`) are
+ * called by the MODEL, so before this store existed the only trace of a clip was
+ * the file on disk: a user who closed the session could not tell which clips they
+ * had already spent quota on. This store is that ledger, and it is deliberately
+ * narrow.
+ *
+ * WHAT IS STORED, AND WHAT IS NOT. One row per finished generation: when, which
+ * model, which ratio and duration, the WORKSPACE-RELATIVE path, the byte count and
+ * the upstream task id. `videoPath` is workspace-relative because the workspace
+ * moves with the user (a repo can be cloned anywhere) and an absolute path would
+ * go stale the moment it did; the byte count is what lets the card render a row
+ * before the (potentially hundreds of MB) file is read. THE VIDEO ITSELF IS NEVER
+ * STORED HERE - not the bytes, not a copy, not a thumbnail. A history file that
+ * carried media would double every generation on disk, and this store's whole job
+ * is to point at the file the media store already wrote.
+ *
+ * WHY IT IS ENCRYPTED. It holds no token and nothing secret, and the sibling
+ * lines' rule is that a store under `$DSH_HOME` which is easy to protect is
+ * protected: the same platform credential backend the siblings use (Windows
+ * CurrentUser DPAPI, macOS Keychain, Linux Secret Service) reads and writes it, so
+ * the format on disk is that backend's own envelope rather than plain JSON. A
+ * plaintext fallback is kept for a platform with no backend at all, because a
+ * history a user cannot read on an unusual host is worse than a history that is
+ * merely not encrypted - and the file carries no credential either way.
+ *
+ * Path: `$DSH_HOME/storages/minimax-code-video-history.json` (Windows appends
+ * `.dpapi`, exactly like every sibling credential file), matching the path the
+ * sibling stores in this line already use (`minimax-code-files.json`,
+ * `minimax-code-models.json`).
+ *
+ * @module dsh-chatgpt-subscription/minimax-code/video-history
+ */
+import type { CredentialStore } from '../token-store.ts';
+/** How many rows the ledger keeps. Older rows fall off the tail. */
+export declare const MAX_VIDEO_HISTORY_ENTRIES = 100;
+/**
+ * One finished generation.
+ *
+ * Every field except `durationSeconds` is always present: a row without them could
+ * not be rendered as a row at all, so a document missing one is treated as
+ * corrupt and dropped rather than repaired with a guess.
+ */
+export interface MinimaxVideoHistoryEntry {
+    /** Unix milliseconds the clip finished writing. */
+    readonly createdAtMs: number;
+    /** Model id the submit named, exactly as it was sent. */
+    readonly model: string;
+    /** Effective ratio, or absent when the linkage sent no ratio field. */
+    readonly ratio?: string;
+    /** Duration the service reported for the settled task, in seconds. */
+    readonly durationSeconds?: number;
+    /** Workspace-relative, POSIX-separated path of the written file. */
+    readonly videoPath: string;
+    /** Exact byte length of that file. */
+    readonly bytes: number;
+    /** Upstream task id, for diagnosis and follow-up. */
+    readonly taskId: string;
+}
+/** The stored document. The version marker is what lets a later build migrate. */
+export interface MinimaxVideoHistoryDocument {
+    readonly version: 1;
+    readonly entries: readonly MinimaxVideoHistoryEntry[];
+}
+/** What one generation records. The timestamp is added by the store. */
+export interface MinimaxVideoHistoryRecord {
+    readonly model: string;
+    readonly ratio?: string;
+    readonly durationSeconds?: number;
+    readonly videoPath: string;
+    readonly bytes: number;
+    readonly taskId: string;
+}
+/** Path of the history file. Mirrors {@link fileHistoryPath} in the sibling stores. */
+export declare function videoHistoryPath(): string;
+/**
+ * Validate and normalize one stored row.
+ *
+ * A row that cannot be rendered is DROPPED rather than repaired: the history is a
+ * convenience, and inventing a byte count or a path would put a row in front of
+ * the user that describes nothing. Nothing here throws - the whole document goes
+ * through this per row, and one corrupt row must not hide the ninety-nine good
+ * ones beside it.
+ *
+ * @param value - one parsed row.
+ * @returns the normalized entry, or undefined to drop it.
+ */
+export declare function parseHistoryEntry(value: unknown): MinimaxVideoHistoryEntry | undefined;
+/**
+ * Normalize a whole parsed document.
+ *
+ * A document this build cannot recognise yields an EMPTY history rather than an
+ * error: the file is read on every settings-card view and after every generation,
+ * and a hand-edited or forward-versioned file must degrade to "no history yet"
+ * instead of making the card unusable.
+ *
+ * @param value - parsed JSON, or anything else.
+ * @returns the normalized document.
+ */
+export declare function parseHistoryDocument(value: unknown): MinimaxVideoHistoryDocument;
+/**
+ * Prepend one record and trim the tail.
+ *
+ * Newest first, so the card renders the most recent clip without sorting, and a
+ * duplicate task id REPLACES its earlier row: a generation retried after a
+ * timeout settles on the same upstream task, and two rows for one clip would
+ * count one generation twice.
+ *
+ * @param document - the current document.
+ * @param record - the generation to add.
+ * @param now - timestamp to stamp it with.
+ * @returns the next document.
+ */
+export declare function appendHistoryEntry(document: MinimaxVideoHistoryDocument, record: MinimaxVideoHistoryRecord, now: number): MinimaxVideoHistoryDocument;
+/**
+ * The generation ledger for this machine.
+ *
+ * Reads and writes are serialized per file so two generations settling at once
+ * cannot each read the same document and have the second silently discard the
+ * first. The queue is process-wide and keyed by resolved path, exactly like the
+ * credential store's.
+ */
+export declare class MinimaxVideoHistoryStore {
+    private readonly filePath;
+    private readonly backend;
+    private readonly queue;
+    /**
+     * @param filePath - override for tests; defaults to {@link videoHistoryPath}.
+     * @param backend - override for tests; defaults to the platform backend.
+     */
+    constructor(filePath?: string, backend?: CredentialStore<MinimaxVideoHistoryDocument> | undefined);
+    /** Where this store writes. Reported by the card so the path is never a mystery. */
+    path(): string;
+    /** Whether the stored document is encrypted at rest by a platform backend. */
+    encryptedAtRest(): boolean;
+    /**
+     * Read the ledger.
+     *
+     * Never throws: a missing, unreadable or corrupt file yields an empty history, so
+     * one bad write cannot make the video tools or the settings card fail.
+     *
+     * @returns the stored document.
+     */
+    read(): Promise<MinimaxVideoHistoryDocument>;
+    /**
+     * The rows the card renders, newest first.
+     *
+     * @returns the entries alone, which is what the route answers with.
+     */
+    list(): Promise<readonly MinimaxVideoHistoryEntry[]>;
+    /**
+     * Record one finished generation.
+     *
+     * Read-modify-write under the per-file queue. A failure to record is REPORTED to
+     * the caller but is never allowed to fail a generation that already succeeded:
+     * the video is on disk and paid for either way.
+     *
+     * @param record - the generation to add.
+     * @param now - timestamp override for tests.
+     * @returns the document as written.
+     */
+    record(record: MinimaxVideoHistoryRecord, now?: number): Promise<MinimaxVideoHistoryDocument>;
+    /** Write the whole document through the platform backend or the plaintext file. */
+    private write;
+    /**
+     * Run one operation after everything already queued for this file.
+     *
+     * @param operation - the read-modify-write.
+     * @returns its result.
+     */
+    private serialize;
+}
+/**
+ * A store that keeps the ledger in memory and writes nothing.
+ *
+ * Two callers use it. A test that exercises a generation end to end does not want
+ * either side effect of the real store: on Windows every uncached read spawns a
+ * `powershell.exe` DPAPI helper, and either way the row lands in the developer's
+ * personal `$DSH_HOME`. And a host with no platform backend and an unwritable home
+ * still gets a readable history for the length of the process.
+ */
+export declare class InMemoryVideoHistoryStore {
+    private document;
+    /** @returns the in-memory file label, so the card can say where it is (nowhere). */
+    path(): string;
+    /** @returns false: nothing on disk to encrypt. */
+    encryptedAtRest(): boolean;
+    /** @returns the stored document. */
+    read(): Promise<MinimaxVideoHistoryDocument>;
+    /** @returns the entries alone, newest first. */
+    list(): Promise<readonly MinimaxVideoHistoryEntry[]>;
+    /**
+     * Append one row in memory.
+     *
+     * @param record - the generation.
+     * @param now - timestamp to stamp it with.
+     * @returns the document as stored.
+     */
+    record(record: MinimaxVideoHistoryRecord, now?: number): Promise<MinimaxVideoHistoryDocument>;
+}
+/** What the routes need from a store; both implementations satisfy it. */
+export type MinimaxVideoHistoryPort = Pick<MinimaxVideoHistoryStore | InMemoryVideoHistoryStore, 'path' | 'encryptedAtRest' | 'read' | 'list' | 'record'>;
+/**
+ * The process-wide history store.
+ *
+ * A test run gets the in-memory store unless something installed one explicitly.
+ * That default is deliberate rather than convenient: the video tool's own test
+ * suite drives real generations through this hook, and on Windows each row would
+ * otherwise spawn a DPAPI helper and append to the developer's real ledger. A
+ * suite that WANTS the file behaviour installs a store through
+ * {@link setMinimaxVideoHistoryStore} and gets exactly that.
+ *
+ * @returns the process-wide store.
+ */
+export declare function minimaxVideoHistory(): MinimaxVideoHistoryPort;
+/**
+ * Test seam: replace or drop the process-wide store.
+ *
+ * @param store - the store to install, or undefined to rebuild on next use.
+ */
+export declare function setMinimaxVideoHistoryStore(store: MinimaxVideoHistoryPort | undefined): void;
+/**
+ * Record one finished generation, never throwing.
+ *
+ * Called from the video tool right after the clip is on disk. A recording failure
+ * must not turn a SUCCESSFUL generation into an error the user sees: the clip
+ * exists and the quota is spent either way, so the failure is logged and dropped.
+ *
+ * @param record - the generation.
+ * @param logger - the host logger, when the caller has one.
+ * @returns whether the row was written.
+ */
+export declare function recordMinimaxVideoGeneration(record: MinimaxVideoHistoryRecord): Promise<boolean>;
+/** @returns the last recording failure, or undefined when the last write succeeded. */
+export declare function lastMinimaxVideoHistoryFailure(): string | undefined;
+/** Test seam: forget the last recording failure. */
+export declare function resetMinimaxVideoHistoryFailure(): void;
+//# sourceMappingURL=video-history.d.ts.map

package/lib/types/host/minimax-code/video-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-history.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/video-history.ts"],"names":[],"mappings":"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"}

package/lib/types/host/minimax-code/video-submit-rules.d.ts

@@ -0,0 +1,40 @@
+export declare const MAX_REFERENCE_IMAGES = 9;
+export declare const MAX_REFERENCE_VIDEOS = 3;
+export declare const MAX_REFERENCE_AUDIOS = 3;
+export declare const MAX_REFERENCE_MEDIA_TOTAL = 12;
+export declare function minimaxModelSupportsReferenceMedia(model: string): boolean;
+export interface MinimaxGenerationMediaInput {
+    readonly inputImagePath?: string;
+    readonly lastFrameImagePath?: string;
+    readonly referenceType?: string;
+    readonly referenceImagePaths?: readonly string[];
+    readonly referenceVideoPaths?: readonly string[];
+    readonly referenceVideoDurationSeconds?: readonly number[];
+    readonly referenceAudioPaths?: readonly string[];
+}
+export declare function assertGenerationMediaLimits(input: MinimaxGenerationMediaInput, model: string): void;
+export declare function stableJsonKey(value: unknown): string;
+export declare function videoSubmissionKey(sessionId: string | undefined, turn: string | number | undefined, body: unknown): string;
+/**
+ * Whether a submission key is precise enough to REFUSE a repeat on.
+ *
+ * The key is only meaningful WITHIN one session and turn. When the runtime
+ * exposes neither, the key degrades to the request body alone - and then two
+ * genuinely different requests in the same process would carry the same key,
+ * so the guard would refuse a generation the user actually asked for.
+ *
+ * A false refusal is worse than a missed duplicate: a missed duplicate costs
+ * one extra generation, while a false refusal blocks the request outright. The
+ * guard therefore stays INACTIVE without a session identity, and the caller's
+ * own retry discipline carries that case.
+ *
+ * @param sessionId - the session the call belongs to, when known.
+ * @param turn - the turn within it, when known.
+ * @returns true when the key identifies one request in one session turn.
+ */
+export declare function isPreciseSubmissionKey(sessionId: string | undefined, turn: string | number | undefined): boolean;
+export declare function attemptedVideoSubmissionFor(key: string): string | undefined;
+export declare function recordVideoSubmissionAttempt(key: string, taskId?: string): void;
+export declare function attemptedVideoSubmissionCount(): number;
+export declare function resetVideoSubmissionGuard(): void;
+//# sourceMappingURL=video-submit-rules.d.ts.map

package/lib/types/host/minimax-code/video-submit-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-submit-rules.d.ts","sourceRoot":"","sources":["../../../../src/host/minimax-code/video-submit-rules.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAE3C,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IACpC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAChD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAChD,QAAQ,CAAC,6BAA6B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACjD;AAgBD,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,2BAA2B,EAClC,KAAK,EAAE,MAAM,GACZ,IAAI,CAgCN;AAcD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAMpD;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EACjC,IAAI,EAAE,OAAO,GACZ,MAAM,CAER;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAChC,OAAO,CAET;AAED,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG3E;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAE/E;AAED,wBAAgB,6BAA6B,IAAI,MAAM,CAEtD;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}