@melaya/runner 1.0.69 → 1.0.71

package/dist/connection.js

@@ -1083,6 +1083,113 @@ export async function connect(opts) {
     // connector. After that, the LinkedIn pipelines (auto-like / auto-reply
     // / auto-connect) just read LINKEDIN_LI_AT / LINKEDIN_JSESSIONID from
     // env at run time and call Voyager directly with aiohttp.
+    socket.on("rag:retrieve", async (payload, ack) => {
+        const sid = payload?.sessionId;
+        if (!sid)
+            return;
+        ack?.({ ok: true });
+        const embedOnly = payload.mode === "cloud_files";
+        try {
+            const prov = (payload.embedderProvider || "").toLowerCase();
+            if (!["ollama", "lmstudio"].includes(prov)) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: "runner retrieval only supports ollama or lmstudio embedders",
+                });
+                return;
+            }
+            const { ensurePythonEnv } = await import("./pythonEnv.js");
+            const env = await ensurePythonEnv(opts.pythonPath, payload.sharedVersion);
+            if (!env.ok) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: `venv bootstrap failed: ${env.reason}`,
+                });
+                return;
+            }
+            await ensureSharedModules(opts.serverUrl, payload.sharedVersion);
+            const sharedDir = getSharedDir();
+            const workDir = join(tmpdir(), `melaya-rag-retrieve-${payload.pipelineName}-${Date.now()}`);
+            mkdirSync(workDir, { recursive: true });
+            const { copyFileSync, existsSync } = await import("fs");
+            const candidates = [
+                join(sharedDir, "..", "localRagRetrieve.py"),
+                join(__dirname, "localRagRetrieve.py"),
+                join(__dirname, "..", "localRagRetrieve.py"),
+            ];
+            let found = "";
+            for (const c of candidates) {
+                if (existsSync(c)) {
+                    found = c;
+                    break;
+                }
+            }
+            if (!found) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: "localRagRetrieve.py not found in runner package - reinstall @melaya/runner",
+                });
+                return;
+            }
+            const stagedScript = join(workDir, "localRagRetrieve.py");
+            copyFileSync(found, stagedScript);
+            const ragCertBundle = (await import("./pythonEnv.js")).getCertBundlePath();
+            const ragSslEnv = ragCertBundle
+                ? { SSL_CERT_FILE: ragCertBundle, REQUESTS_CA_BUNDLE: ragCertBundle }
+                : {};
+            const proc = spawn(env.pythonPath, [
+                "-u", stagedScript,
+                "--pipeline-name", payload.pipelineName,
+                "--embedder-provider", prov,
+                "--embedder-model", payload.embedderModel,
+                "--query", String(payload.query || ""),
+                "--limit", String(Math.max(1, Math.min(20, Number(payload.limit ?? 5)))),
+                // Mode C: embed only, print the vector; the server does the search.
+                ...(embedOnly ? ["--embed-only"] : []),
+            ], {
+                env: {
+                    ...process.env,
+                    PYTHONPATH: sharedDir,
+                    ...ragSslEnv,
+                },
+                cwd: workDir,
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => { stdout += data.toString("utf-8"); });
+            proc.stderr.on("data", (data) => { stderr += data.toString("utf-8"); });
+            proc.on("close", (code) => {
+                const jsonLine = stdout.split(/\r?\n/).map(s => s.trim()).filter(Boolean).reverse()[0] || "";
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(jsonLine);
+                }
+                catch { /* handled below */ }
+                const ok = code === 0 && parsed?.ok === true;
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok,
+                    // Mode C (embed-only): carry the query vector; the server searches
+                    // the prod store. Mode B: carry the local search results directly.
+                    vector: embedOnly && Array.isArray(parsed?.vector) ? parsed.vector : undefined,
+                    results: Array.isArray(parsed?.results) ? parsed.results : [],
+                    store_path: parsed?.store_path,
+                    error: ok ? undefined : (parsed?.error || `runner retrieve exit ${code ?? "?"}`),
+                    stderr_tail: stderr.slice(-2000),
+                });
+            });
+        }
+        catch (e) {
+            socket.emit("rag:retrieve-result", {
+                session_id: sid,
+                ok: false,
+                error: e?.message || String(e),
+            });
+        }
+    });
     socket.on("linkedin:start-login", async (req) => {
         const sid = req?.session_id;
         if (!sid)

package/dist/linkedinLogin.js

@@ -143,26 +143,52 @@ export async function runLinkedInLoginFlow(progress) {
     catch (e) {
         return { ok: false, error: "playwright_unavailable", detail: e?.message };
     }
-    try {
-        await _installChromium(progress);
-    }
-    catch (e) {
-        return { ok: false, error: "chromium_install_failed", detail: e?.message };
-    }
-    // 2. Launch a headed Chromium window. Use a fresh context (no profile
-    //    reuse) so the user always sees a clean LinkedIn login page even
-    //    if they have an old / wrong account session lying around.
+    // 2. Launch a headed browser window. Prefer the user's REAL system Chrome
+    //    (channel:"chrome") — validated 2026-06-22 as the only reliable way to
+    //    render LinkedIn's login page (the bundled Chromium served a blank /
+    //    never-painting page; system Chrome renders the form, accepts password
+    //    + 2FA, and reaches /feed/). System Chrome also needs no 140 MB download.
+    //    Fall back to bundled Chromium only if Chrome isn't installed.
+    //    Fresh context (no profile reuse) so the user always sees a clean login.
+    //
+    //    We KEEP the fixed Chrome/127 UA override below: LinkedIn's anti-bot binds
+    //    cookie issuance to the client fingerprint (UA among others), and every
+    //    Voyager call in shared/tools/social_linkedin.py sends that exact UA
+    //    constant. Minting li_at/JSESSIONID under a DIFFERENT UA than the tools
+    //    later replay triggers a redirect-loop on /voyager/api/me
+    //    (aiohttp.TooManyRedirects) — verified 2026-06-22 when an interim
+    //    native-UA attempt broke list_connections / search / resolve_profile /
+    //    list_conversations while session_status still worked. Keep this string
+    //    in lock-step with social_linkedin.py USER_AGENT.
     let browser = null;
     try {
         progress("Opening LinkedIn login window…");
-        browser = await playwright.chromium.launch({
-            headless: false,
-            args: [
-                "--disable-blink-features=AutomationControlled",
-            ],
-        });
+        try {
+            browser = await playwright.chromium.launch({
+                headless: false,
+                channel: "chrome",
+                args: ["--disable-blink-features=AutomationControlled"],
+            });
+        }
+        catch (chromeErr) {
+            progress(`System Chrome not available (${(chromeErr?.message || chromeErr).toString().split("\n")[0]}); ` +
+                `falling back to the bundled browser.`);
+            try {
+                await _installChromium(progress);
+            }
+            catch (e) {
+                return { ok: false, error: "chromium_install_failed", detail: e?.message };
+            }
+            browser = await playwright.chromium.launch({
+                headless: false,
+                args: ["--disable-blink-features=AutomationControlled"],
+            });
+        }
         _activeLoginBrowser = browser;
         const context = await browser.newContext({
+            // MUST stay byte-for-byte equal to shared/tools/social_linkedin.py
+            // USER_AGENT (Chrome/127). See the fingerprint-binding note above —
+            // a mismatch causes aiohttp.TooManyRedirects on Voyager endpoints.
             userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
                 "(KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
             viewport: { width: 1280, height: 820 },

package/dist/localRagRetrieve.py

@@ -0,0 +1,162 @@
+"""Runner-side RAG retrieval test (local embedder paths).
+
+Two modes, selected by --embed-only:
+  * Mode B (local folder, default): the vector store lives on THIS machine
+    (~/.melaya-runner/rag/<pipeline>/store), so we embed the query AND search
+    locally, returning the matched chunks.
+  * Mode C (cloud files, --embed-only): the chunks were upserted to the
+    PROD-side store during ingest, so they are NOT on this box. We only embed
+    the query with the user's local embedder and return the raw vector; the
+    server searches the prod store by that vector (see builder
+    /docs/retrieval/search_by_vector + runnerNamespace forwarding).
+
+Either way the embedder is local (ollama / lmstudio), which is why this can't
+run server-side: prod has no LM Studio / Ollama to embed the query.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+def _resolve_store_path(pipeline_name: str) -> Path:
+    return Path.home() / ".melaya-runner" / "rag" / pipeline_name / "store"
+
+
+def _build_embedder(provider: str, model: str):
+    if provider == "ollama":
+        from agentscope.embedding import OllamaTextEmbedding
+        dims = {
+            "nomic-embed-text": 768,
+            "nomic-embed-text:v1.5": 768,
+            "mxbai-embed-large": 1024,
+            "all-minilm": 384,
+            "snowflake-arctic-embed": 1024,
+        }
+        dim = dims.get(model.lower())
+        if dim is None:
+            raise ValueError(f"unknown ollama embedding model '{model}'")
+        return OllamaTextEmbedding(model_name=model, dimensions=dim, host=None)
+    if provider == "lmstudio":
+        from agentscope.embedding import OpenAITextEmbedding
+        embedder = OpenAITextEmbedding(
+            api_key="lmstudio",
+            model_name=model,
+            dimensions=768,
+            base_url="http://localhost:1234/v1",
+        )
+        original_create = embedder.client.embeddings.create
+
+        async def _lms_create(**kwargs):
+            kwargs.pop("dimensions", None)
+            return await original_create(**kwargs)
+
+        embedder.client.embeddings.create = _lms_create  # type: ignore[assignment]
+        return embedder
+    raise ValueError(f"unsupported embedder provider '{provider}'")
+
+
+def _extract_text(doc) -> str:
+    content = getattr(doc.metadata, "content", None)
+    if isinstance(content, dict):
+        return str(content.get("text") or "")
+    return str(getattr(content, "text", "") or "")
+
+
+async def _embed_only(args) -> dict:
+    """Mode C: embed the query with the user's LOCAL embedder and return the
+    raw vector. The vectors live in the prod-side store (Mode C ingest upserted
+    them there), so the SERVER does the search — this box only embeds. No store
+    is opened here."""
+    from agentscope.message import TextBlock
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    res = await embedder([TextBlock(type="text", text=str(args.query or "")[:2000])])
+    vector = list(res.embeddings[0])
+    return {"ok": True, "vector": vector}
+
+
+async def _retrieve(args) -> dict:
+    if getattr(args, "embed_only", False):
+        return await _embed_only(args)
+    store_path = _resolve_store_path(args.pipeline_name)
+    if not store_path.exists():
+        return {
+            "ok": False,
+            "error": f"runner RAG store not found: {store_path}",
+            "results": [],
+        }
+
+    import qdrant_client as _qc
+    if not getattr(_qc.AsyncQdrantClient.__init__, "_melaya_patched", False):
+        original_init = _qc.AsyncQdrantClient.__init__
+
+        def _patched_init(self, location=None, **kwargs):
+            if (
+                location
+                and location != ":memory:"
+                and "://" not in str(location)
+                and not kwargs.get("path")
+            ):
+                kwargs["path"] = location
+                location = None
+            original_init(self, location=location, **kwargs)
+
+        _patched_init._melaya_patched = True  # type: ignore[attr-defined]
+        _qc.AsyncQdrantClient.__init__ = _patched_init  # type: ignore[assignment]
+
+    from agentscope.rag import QdrantStore, SimpleKnowledge
+
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    store = QdrantStore(
+        location=str(store_path),
+        collection_name=args.pipeline_name,
+        dimensions=embedder.dimensions,
+        distance="Cosine",
+    )
+    kb = SimpleKnowledge(embedding_store=store, embedding_model=embedder)
+    docs = await kb.retrieve(
+        query=str(args.query or "")[:2000],
+        limit=max(1, min(20, int(args.limit))),
+    )
+    results = []
+    for doc in docs:
+        score = getattr(doc, "score", None)
+        results.append({
+            "source": getattr(doc.metadata, "doc_id", "?"),
+            "chunk_id": getattr(doc.metadata, "chunk_id", "?"),
+            "score": score,
+            "text": _extract_text(doc),
+        })
+    return {
+        "ok": True,
+        "store_path": str(store_path),
+        "results": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pipeline-name", required=True)
+    parser.add_argument("--embedder-provider", required=True, choices=["ollama", "lmstudio"])
+    parser.add_argument("--embedder-model", required=True)
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=5)
+    # Mode C: embed the query and print {ok, vector}; do not open a local store.
+    parser.add_argument("--embed-only", dest="embed_only", action="store_true")
+    args = parser.parse_args()
+    try:
+        print(json.dumps(asyncio.run(_retrieve(args)), ensure_ascii=False))
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({
+            "ok": False,
+            "error": f"{type(exc).__name__}: {exc}",
+            "results": [],
+        }), file=sys.stdout)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/dist/lumaBrowserBridge.js

@@ -128,13 +128,23 @@ export async function startLumaBrowserBridge(opts) {
         if (browserLaunching)
             return browserLaunching;
         browserLaunching = (async () => {
-            const b = await playwright.chromium.launch({
-                headless: true,
-                args: [
-                    "--disable-blink-features=AutomationControlled",
-                    "--disable-dev-shm-usage",
-                ],
-            });
+            // Prefer the user's real system Chrome (channel:"chrome"). Its TLS/JA3
+            // fingerprint matches the headed login that minted cf_clearance, so the
+            // Cloudflare-gated POST /event/register is far more likely to pass — and
+            // it skips the 140 MB bundled-Chromium download. Fall back to bundled
+            // Chromium when Chrome isn't installed.
+            const launchArgs = [
+                "--disable-blink-features=AutomationControlled",
+                "--disable-dev-shm-usage",
+            ];
+            let b;
+            try {
+                b = await playwright.chromium.launch({ headless: true, channel: "chrome", args: launchArgs });
+            }
+            catch {
+                opts.log("Luma browser bridge: system Chrome unavailable, using bundled Chromium.");
+                b = await playwright.chromium.launch({ headless: true, args: launchArgs });
+            }
             browser = b;
             browserLaunching = null;
             return b;
@@ -168,6 +178,10 @@ export async function startLumaBrowserBridge(opts) {
             const storageState = await _readStorageState();
             ctx = await b.newContext({
                 storageState: storageState,
+                // MUST stay in lock-step with lumaLogin.ts and shared/tools/luma.py
+                // USER_AGENT. cf_clearance is UA-bound: it was minted under this exact
+                // string at login, so every replay (here + the direct aiohttp reads)
+                // must present the same UA or Cloudflare rejects it with a 403.
                 userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
                     "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
                 viewport: { width: 1280, height: 820 },

package/dist/lumaLogin.js

@@ -112,21 +112,47 @@ export async function runLumaLoginFlow(progress) {
     catch (e) {
         return { ok: false, error: "playwright_unavailable", detail: e?.message };
     }
-    try {
-        await _installChromium(progress);
-    }
-    catch (e) {
-        return { ok: false, error: "chromium_install_failed", detail: e?.message };
-    }
+    // Prefer the user's REAL system Chrome (channel:"chrome"). Validated for the
+    // LinkedIn login flow 2026-06-22 as the only reliable way to render a headed
+    // provider login (bundled Chromium served a blank page). For Luma it's doubly
+    // important: Luma is behind Cloudflare Turnstile and only issues cf_clearance
+    // (required for POST /event/register) after a challenge passes — a genuine
+    // Chrome clears that far more reliably than bundled Chromium, and it needs no
+    // 140 MB download. Fall back to bundled Chromium only if Chrome isn't present.
+    //
+    // We DO keep the fixed UA override below: cf_clearance is bound to the exact
+    // UA that minted it, and the replay paths (lumaBrowserBridge.ts and the direct
+    // aiohttp reads in shared/tools/luma.py) both send this same fixed string.
+    // Turnstile is solved under this overridden UA, so the binding stays internally
+    // consistent across mint + every replay. Keep all three in lock-step.
     let browser = null;
     try {
         progress("Opening Luma login window…");
-        browser = await playwright.chromium.launch({
-            headless: false,
-            args: ["--disable-blink-features=AutomationControlled"],
-        });
+        try {
+            browser = await playwright.chromium.launch({
+                headless: false,
+                channel: "chrome",
+                args: ["--disable-blink-features=AutomationControlled"],
+            });
+        }
+        catch (chromeErr) {
+            progress(`System Chrome not available (${(chromeErr?.message || chromeErr).toString().split("\n")[0]}); ` +
+                `falling back to the bundled browser.`);
+            try {
+                await _installChromium(progress);
+            }
+            catch (e) {
+                return { ok: false, error: "chromium_install_failed", detail: e?.message };
+            }
+            browser = await playwright.chromium.launch({
+                headless: false,
+                args: ["--disable-blink-features=AutomationControlled"],
+            });
+        }
         _activeLoginBrowser = browser;
         const context = await browser.newContext({
+            // MUST stay in lock-step with shared/tools/luma.py USER_AGENT and
+            // lumaBrowserBridge.ts — cf_clearance is UA-bound (see comment above).
             userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " +
                 "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
             viewport: { width: 1280, height: 820 },

package/localRagRetrieve.py

@@ -0,0 +1,162 @@
+"""Runner-side RAG retrieval test (local embedder paths).
+
+Two modes, selected by --embed-only:
+  * Mode B (local folder, default): the vector store lives on THIS machine
+    (~/.melaya-runner/rag/<pipeline>/store), so we embed the query AND search
+    locally, returning the matched chunks.
+  * Mode C (cloud files, --embed-only): the chunks were upserted to the
+    PROD-side store during ingest, so they are NOT on this box. We only embed
+    the query with the user's local embedder and return the raw vector; the
+    server searches the prod store by that vector (see builder
+    /docs/retrieval/search_by_vector + runnerNamespace forwarding).
+
+Either way the embedder is local (ollama / lmstudio), which is why this can't
+run server-side: prod has no LM Studio / Ollama to embed the query.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+def _resolve_store_path(pipeline_name: str) -> Path:
+    return Path.home() / ".melaya-runner" / "rag" / pipeline_name / "store"
+
+
+def _build_embedder(provider: str, model: str):
+    if provider == "ollama":
+        from agentscope.embedding import OllamaTextEmbedding
+        dims = {
+            "nomic-embed-text": 768,
+            "nomic-embed-text:v1.5": 768,
+            "mxbai-embed-large": 1024,
+            "all-minilm": 384,
+            "snowflake-arctic-embed": 1024,
+        }
+        dim = dims.get(model.lower())
+        if dim is None:
+            raise ValueError(f"unknown ollama embedding model '{model}'")
+        return OllamaTextEmbedding(model_name=model, dimensions=dim, host=None)
+    if provider == "lmstudio":
+        from agentscope.embedding import OpenAITextEmbedding
+        embedder = OpenAITextEmbedding(
+            api_key="lmstudio",
+            model_name=model,
+            dimensions=768,
+            base_url="http://localhost:1234/v1",
+        )
+        original_create = embedder.client.embeddings.create
+
+        async def _lms_create(**kwargs):
+            kwargs.pop("dimensions", None)
+            return await original_create(**kwargs)
+
+        embedder.client.embeddings.create = _lms_create  # type: ignore[assignment]
+        return embedder
+    raise ValueError(f"unsupported embedder provider '{provider}'")
+
+
+def _extract_text(doc) -> str:
+    content = getattr(doc.metadata, "content", None)
+    if isinstance(content, dict):
+        return str(content.get("text") or "")
+    return str(getattr(content, "text", "") or "")
+
+
+async def _embed_only(args) -> dict:
+    """Mode C: embed the query with the user's LOCAL embedder and return the
+    raw vector. The vectors live in the prod-side store (Mode C ingest upserted
+    them there), so the SERVER does the search — this box only embeds. No store
+    is opened here."""
+    from agentscope.message import TextBlock
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    res = await embedder([TextBlock(type="text", text=str(args.query or "")[:2000])])
+    vector = list(res.embeddings[0])
+    return {"ok": True, "vector": vector}
+
+
+async def _retrieve(args) -> dict:
+    if getattr(args, "embed_only", False):
+        return await _embed_only(args)
+    store_path = _resolve_store_path(args.pipeline_name)
+    if not store_path.exists():
+        return {
+            "ok": False,
+            "error": f"runner RAG store not found: {store_path}",
+            "results": [],
+        }
+
+    import qdrant_client as _qc
+    if not getattr(_qc.AsyncQdrantClient.__init__, "_melaya_patched", False):
+        original_init = _qc.AsyncQdrantClient.__init__
+
+        def _patched_init(self, location=None, **kwargs):
+            if (
+                location
+                and location != ":memory:"
+                and "://" not in str(location)
+                and not kwargs.get("path")
+            ):
+                kwargs["path"] = location
+                location = None
+            original_init(self, location=location, **kwargs)
+
+        _patched_init._melaya_patched = True  # type: ignore[attr-defined]
+        _qc.AsyncQdrantClient.__init__ = _patched_init  # type: ignore[assignment]
+
+    from agentscope.rag import QdrantStore, SimpleKnowledge
+
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    store = QdrantStore(
+        location=str(store_path),
+        collection_name=args.pipeline_name,
+        dimensions=embedder.dimensions,
+        distance="Cosine",
+    )
+    kb = SimpleKnowledge(embedding_store=store, embedding_model=embedder)
+    docs = await kb.retrieve(
+        query=str(args.query or "")[:2000],
+        limit=max(1, min(20, int(args.limit))),
+    )
+    results = []
+    for doc in docs:
+        score = getattr(doc, "score", None)
+        results.append({
+            "source": getattr(doc.metadata, "doc_id", "?"),
+            "chunk_id": getattr(doc.metadata, "chunk_id", "?"),
+            "score": score,
+            "text": _extract_text(doc),
+        })
+    return {
+        "ok": True,
+        "store_path": str(store_path),
+        "results": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pipeline-name", required=True)
+    parser.add_argument("--embedder-provider", required=True, choices=["ollama", "lmstudio"])
+    parser.add_argument("--embedder-model", required=True)
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=5)
+    # Mode C: embed the query and print {ok, vector}; do not open a local store.
+    parser.add_argument("--embed-only", dest="embed_only", action="store_true")
+    args = parser.parse_args()
+    try:
+        print(json.dumps(asyncio.run(_retrieve(args)), ensure_ascii=False))
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({
+            "ok": False,
+            "error": f"{type(exc).__name__}: {exc}",
+            "results": [],
+        }), file=sys.stdout)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.69",
+  "version": "1.0.71",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,
@@ -14,23 +14,24 @@
     "dist/**/*.d.ts",
     "dist/**/*.py",
     "localRagIngest.py",
+    "localRagRetrieve.py",
     "nltk_data/**",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && node -e \"require('fs').copyFileSync('localRagIngest.py','dist/localRagIngest.py')\"",
+    "build": "tsc && node -e \"const fs=require('fs'); fs.copyFileSync('localRagIngest.py','dist/localRagIngest.py'); fs.copyFileSync('localRagRetrieve.py','dist/localRagRetrieve.py')\"",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "socket.io-client": "^4.8.0",
-    "commander": "^12.0.0",
     "chalk": "^5.3.0",
+    "commander": "^12.0.0",
     "ora": "^8.0.0",
-    "playwright": "^1.47.0"
+    "playwright": "^1.47.0",
+    "socket.io-client": "^4.8.0"
   },
   "devDependencies": {
-    "typescript": "^5.5.0",
-    "@types/node": "^20.0.0"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
   },
   "engines": {
     "node": ">=18"