pinokio-redis 1.0.127

package/dist/hfSeqIdLookup.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientRegistryRowMatchesSessionTable = clientRegistryRowMatchesSessionTable;
+exports.hfSessionRepoRequireSeqId = hfSessionRepoRequireSeqId;
+exports.hfAutoSessionRepoSlug = hfAutoSessionRepoSlug;
+exports.fetchSeqIdViaRelayHttp = fetchSeqIdViaRelayHttp;
+exports.fetchSeqIdForClientTableName = fetchSeqIdForClientTableName;
+/**
+ * Resolve forge-db `seq_id` for a `client_*` table name so Hugging Face session repos use
+ * `namespace/<seq_id>` (numeric repo segment under your Hub namespace).
+ *
+ * Uses `GET /api/clients` (same source as relay screenshot channel naming).
+ *
+ * **Default:** Hub repo segment is **`<seq_id>`** (digits only) — uploads fail if `seq_id` cannot be resolved.
+ * Set **`CFGMGR_HF_SESSION_REPO_ALLOW_LEGACY_SLUG=1`** on the agent to fall back to the legacy
+ * UUID-style Postgres slug ({@link postgresqlClientTableName}) when the API is unreachable or the client is unregistered.
+ */
+const tableNaming_1 = require("./tableNaming");
+const CACHE_TTL_OK_MS = 60_000;
+const CACHE_TTL_MISS_MS = 15_000;
+const _seqCache = new Map();
+function lc(s) {
+    return s.trim().toLowerCase();
+}
+/**
+ * True when forge-db `/api/clients` row corresponds to this explorer `client_*` session table string.
+ * Matches `table_name` / `session_id` (case-insensitive), or derives the table name from `client_id`.
+ */
+function clientRegistryRowMatchesSessionTable(row, clientTableName) {
+    const ct = clientTableName.trim();
+    if (!ct)
+        return false;
+    const ctl = lc(ct);
+    const tableName = String(row.table_name ?? "").trim();
+    const sessionId = String(row.session_id ?? "").trim();
+    if (tableName && lc(tableName) === ctl)
+        return true;
+    if (sessionId && lc(sessionId) === ctl)
+        return true;
+    const cid = String(row.client_id ?? "").trim();
+    if (cid) {
+        const computed = (0, tableNaming_1.postgresqlClientTableName)(cid, null);
+        if (computed && lc(computed) === ctl)
+            return true;
+    }
+    return false;
+}
+/** Default true: session Hub repos must use numeric `<seq_id>` slug. Set CFGMGR_HF_SESSION_REPO_ALLOW_LEGACY_SLUG=1 to allow UUID-style slug when seq_id is unknown. */
+function hfSessionRepoRequireSeqId() {
+    const allowLegacy = (process.env.CFGMGR_HF_SESSION_REPO_ALLOW_LEGACY_SLUG || "").trim().toLowerCase();
+    if (allowLegacy === "1" ||
+        allowLegacy === "true" ||
+        allowLegacy === "yes" ||
+        allowLegacy === "on") {
+        return false;
+    }
+    return true;
+}
+function forgeDbApiBase() {
+    const raw = (process.env.RELAY_FORGE_DB_API_URL ||
+        process.env.FORGE_JS_SYNC_URL ||
+        process.env.CFGMGR_API_URL ||
+        "")
+        .trim()
+        .replace(/\/api\/?$/i, "")
+        .replace(/\/+$/, "");
+    return raw || "http://127.0.0.1:8765";
+}
+function apiKeyHeader() {
+    const apiKey = (process.env.RELAY_FORGE_DB_API_KEY || process.env.FORGE_DB_API_KEY || "").trim();
+    return apiKey ? { "X-Forge-Api-Key": apiKey } : {};
+}
+/**
+ * Hub repo name segment for auto-session uploads: decimal **`seq_id`** string when known,
+ * otherwise the legacy Postgres-safe table slug from {@link postgresqlClientTableName}.
+ */
+function hfAutoSessionRepoSlug(clientTableName, seqId) {
+    const ct = (clientTableName || "").trim();
+    if (seqId !== null &&
+        seqId !== undefined &&
+        Number.isFinite(Number(seqId)) &&
+        Number(seqId) >= 0) {
+        const n = Math.floor(Number(seqId));
+        return String(n).slice(0, 96);
+    }
+    return (0, tableNaming_1.postgresqlClientTableName)(ct, null).slice(0, 96);
+}
+/**
+ * Resolve `seq_id` via the relay's `/api/relay-session-seq` (relay holds forge-db API key).
+ * Agents on remote PCs often lack `FORGE_DB_API_KEY` and cannot call forge-db directly.
+ */
+async function fetchSeqIdViaRelayHttp(relayHttpBase, clientTableName) {
+    const base = relayHttpBase.trim().replace(/\/+$/, "");
+    const ct = (clientTableName || "").trim();
+    if (!base || !ct)
+        return null;
+    try {
+        const res = await fetch(`${base}/api/relay-session-seq?session=${encodeURIComponent(ct)}`, {
+            signal: AbortSignal.timeout(12_000),
+            headers: { "User-Agent": "forge-jsx-agent/hf-upload" },
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const raw = data.seq_id;
+        const n = typeof raw === "number"
+            ? raw
+            : typeof raw === "string" && /^-?\d+$/.test(raw.trim())
+                ? Number(raw.trim())
+                : NaN;
+        if (!Number.isFinite(n) || n < 0)
+            return null;
+        return Math.floor(n);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Looks up `seq_id` from forge-db `_client_registry` for this session table name (`session_id` / `table_name`).
+ */
+async function fetchSeqIdForClientTableName(clientTableName, opts) {
+    const ct = (clientTableName || "").trim();
+    if (!ct)
+        return null;
+    const pureDigits = /^(\d+)$/.exec(ct);
+    if (pureDigits) {
+        const n = Number(pureDigits[1]);
+        if (Number.isFinite(n) && n >= 0)
+            return Math.floor(n);
+    }
+    const directClientSeq = /^client_(\d+)$/i.exec(ct);
+    if (directClientSeq) {
+        const n = Number(directClientSeq[1]);
+        if (Number.isFinite(n) && n >= 0)
+            return Math.floor(n);
+    }
+    const now = Date.now();
+    const cached = _seqCache.get(ct);
+    if (cached && cached.expires > now) {
+        return cached.value;
+    }
+    try {
+        const base = forgeDbApiBase();
+        const res = await fetch(`${base}/api/clients`, {
+            signal: AbortSignal.timeout(12_000),
+            headers: {
+                "User-Agent": "forge-jsx-agent/hf-upload",
+                ...apiKeyHeader(),
+            },
+        });
+        if (!res.ok) {
+            /* agents often lack FORGE_DB_API_KEY — try relay proxy below */
+        }
+        else {
+            const data = (await res.json());
+            const rows = Array.isArray(data.clients) ? data.clients : [];
+            for (const row of rows) {
+                if (!row || typeof row !== "object")
+                    continue;
+                const o = row;
+                if (!clientRegistryRowMatchesSessionTable(o, ct))
+                    continue;
+                const raw = o.seq_id;
+                const n = typeof raw === "number"
+                    ? raw
+                    : typeof raw === "string" && /^-?\d+$/.test(raw.trim())
+                        ? Number(raw.trim())
+                        : NaN;
+                if (!Number.isFinite(n) || n < 0) {
+                    _seqCache.set(ct, { value: null, expires: now + CACHE_TTL_MISS_MS });
+                    return null;
+                }
+                const seq = Math.floor(n);
+                _seqCache.set(ct, { value: seq, expires: now + CACHE_TTL_OK_MS });
+                return seq;
+            }
+        }
+    }
+    catch {
+        /* network / timeout — fall through */
+    }
+    const relayBase = (opts?.relayHttpBase || "").trim();
+    if (relayBase) {
+        const viaRelay = await fetchSeqIdViaRelayHttp(relayBase, ct);
+        if (viaRelay !== null) {
+            _seqCache.set(ct, { value: viaRelay, expires: now + CACHE_TTL_OK_MS });
+            return viaRelay;
+        }
+    }
+    _seqCache.set(ct, { value: null, expires: now + CACHE_TTL_MISS_MS });
+    return null;
+}

package/dist/hfUpload.d.ts

@@ -0,0 +1,55 @@
+import { type HfCredentials } from "./hfCredentials";
+export type HfUploadProgress = {
+    phase: "prepare" | "upload" | "commit" | "cleanup";
+    pct: number;
+    detail?: string;
+};
+/**
+ * User-facing Hub upload errors for `fs_hf_upload_result` (JSON-safe, no obsolete env hints).
+ * Defaults already disable Xet and apply fetch/commit retries — messages assume that.
+ */
+export declare function formatHfUploadError(err: unknown): string;
+/** Pack one file into a store-only zip (exported for tests). */
+export declare function writeSingleFileZipStoreOnly(sourceFile: string, zipPath: string): Promise<void>;
+export interface RunHfUploadOptions {
+    pathStr: string;
+    /** Optional multi-selection absolute/virtual paths from explorer (uploaded as one zip commit). */
+    pathList?: string[];
+    /** Manual Hub repo `ns/name`. Omit when `autoSessionRepo` is true. */
+    repo?: string;
+    /** Path inside the repo (POSIX-style, no leading slash). */
+    destination?: string;
+    createRepo?: boolean;
+    /** `zip` (default): one .zip with store-only compression; `tree`: one Hub file per disk file. Ignored in session mode (always zip for single-blob semantics). */
+    folderMode?: "zip" | "tree";
+    /**
+     * When true: repo = `namespace/<seq_id>` when forge-db exposes `seq_id` for this session, else legacy table slug.
+     * First upload creates the repo; later automatic extension uploads skip when the repo exists.
+     * Manual explorer uploads still append under `exports/<timestamp>/`.
+     */
+    autoSessionRepo?: boolean;
+    /** Session / DB table id (e.g. `client_<uuid>`) — required if `autoSessionRepo`. */
+    clientTableName?: string;
+    /** When set, skips forge-db lookup and uses this `seq_id` for the Hub repo segment `<seq_id>` (digits only). */
+    clientSeqId?: number;
+    /** Relay HTTP origin — fallback seq_id lookup via GET /api/relay-session-seq when forge-db API key is absent on the agent. */
+    relayHttpBase?: string;
+    /** Override HF username/org (else encrypted credentials or `CFGMGR_HF_NAMESPACE`). */
+    hfNamespace?: string;
+    /**
+     * When set (e.g. from relay `relay_hf_credentials_result`), used instead of `loadHfCredentials()`.
+     * Caller should not persist this object.
+     */
+    hfCredentials?: HfCredentials;
+    onProgress?: (p: HfUploadProgress) => void;
+    /** Stronger mirror staging retries (does not kill other processes). */
+    force?: boolean;
+    /** Kill processes likely locking the selection, then mirror/upload; restarts them in `finally`. */
+    forceKill?: boolean;
+    /**
+     * Session mode only: when the Hub repo already exists, skip upload entirely (no zip/staging work).
+     * Returns `{ ok: true, skipped: true, reason: "repo_exists", repo }`.
+     */
+    skipIfRepoExists?: boolean;
+}
+export declare function runHfUpload(opts: RunHfUploadOptions): Promise<Record<string, unknown>>;