@openpond/evals 0.11.20 → 0.11.21

package/dist/native-conversations/collector.js

@@ -1,22 +1,24 @@
-import { agentImportNormalizerRevision } from "../connected-evidence/imports.js";
-import { watch } from "node:fs";
-import { contentHash } from "@openpond/harness";
 import { randomUUID } from "node:crypto";
-import { listSessions, readSession } from "./history.js";
-import { NativeSessionNotReadyError } from "./readiness.js";
+import { setTimeout as delay } from "node:timers/promises";
 import { CollectorStore } from "./collector-store.js";
-import { CollectorErrors, } from "./collector-errors.js";
-import { collectorBranchAnchor } from "./collector-branches.js";
+import { CollectorSourceCache } from "./collector-source-cache.js";
+import { CollectorErrors } from "./collector-errors.js";
 import { CollectorSyncRequests } from "./collector-sync-requests.js";
-import { COLLECTOR_DEFAULTS, } from "./collector-contracts.js";
-/** Supervised single owner: acquisition and admission checkpoints survive monitor/service exits. */
+import { acquireCollectorSource, CollectorInterruptedError, CollectorScopeChangedError } from "./collector-acquisition.js";
+import { scheduledSyncDue, scheduledMinute } from "./collector-schedule.js";
+import { COLLECTOR_DEFAULTS } from "./collector-contracts.js";
+/** A single owned, bounded job. No filesystem watchers or idle network polling. */
 export async function runCollector(input) {
+    const until = input.until ?? new Date().toISOString();
+    if (!Number.isFinite(Date.parse(until)) || Date.parse(until) > Date.now())
+        throw new Error("--until must be a valid timestamp no later than now.");
     const store = await CollectorStore.open(input.directory), nonce = randomUUID();
+    let selected = [];
     store.database.exec("BEGIN IMMEDIATE");
     try {
-        const retained = store.setting("owner");
-        if (retained) {
-            const owner = JSON.parse(retained);
+        const retainedOwner = store.setting("owner");
+        if (retainedOwner) {
+            const owner = JSON.parse(retainedOwner);
             let alive = true;
             try {
                 process.kill(owner.pid, 0);
@@ -24,10 +26,32 @@ export async function runCollector(input) {
             catch (error) {
                 alive = error.code !== "ESRCH";
             }
-            if (alive)
-                throw new Error("The collector already has a live owner.");
+            if (alive) {
+                if (input.trigger === "scheduled") {
+                    store.database.exec("COMMIT");
+                    store.close();
+                    return;
+                }
+                throw new Error("An import is already running. Cancel it or wait for it to finish.");
+            }
+        }
+        const now = new Date();
+        selected = store.connections().filter(connection => connection.state !== "disconnected" &&
+            (!input.connectionIds || input.connectionIds.includes(connection.id)) &&
+            (input.trigger !== "scheduled" || (connection.state === "active" && scheduledSyncDue(store.schedule(connection.id), store.setting(`scheduledMinute:${connection.id}`), now))));
+        if (input.trigger === "scheduled")
+            for (const connection of selected)
+                store.set(`scheduledMinute:${connection.id}`, scheduledMinute(now));
+        if (selected.length && input.trigger)
+            store.set("desiredState", "running");
+        if (!selected.length || store.setting("desiredState") !== "running" || input.signal.aborted) {
+            store.database.exec("COMMIT");
+            store.close();
+            return;
         }
         store.set("owner", JSON.stringify({ pid: process.pid, nonce }));
+        store.set("pid", String(process.pid));
+        store.set("heartbeatAt", now.toISOString());
         store.database.exec("COMMIT");
     }
     catch (error) {
@@ -35,33 +59,23 @@ export async function runCollector(input) {
         store.close();
         throw error;
     }
-    if (store.setting("desiredState") !== "running") {
-        store.set("owner", "");
-        store.close();
-        return;
-    }
-    store.set("pid", String(process.pid));
-    let dirty = true, lastReconcile = 0, lastHeartbeat = 0;
-    const watchers = new Map();
-    const errors = new CollectorErrors(store);
-    const syncRequests = new CollectorSyncRequests(store);
-    const reconciledRevisions = new Map();
-    function retained(connection) {
-        return (store.connections().find((item) => item.id === connection.id) ??
-            connection);
-    }
-    function heartbeatInput(connection) {
-        const pendingOperations = store.queued(connection.id);
-        const error = errors.message(connection.id, "heartbeat");
-        return {
-            pendingOperations,
-            error,
-            // A durable older completion may coexist with newly queued live work.
-            // Keep its receipt, but do not send an ineligible ACK that the server
-            // must reject while the current acquisition/admission state is unhealthy.
-            completedSyncRevision: !pendingOperations && !error ? connection.completedSyncRevision ?? 0 : 0,
-        };
-    }
+    const controller = new AbortController();
+    const deadlineAt = Date.now() + (input.maxDurationMs ?? COLLECTOR_DEFAULTS.runMs);
+    const signal = AbortSignal.any([input.signal, controller.signal]);
+    const deadline = setTimeout(() => controller.abort(new Error("Import exceeded its one-hour time budget. Remaining work is retained for the next run.")), input.maxDurationMs ?? COLLECTOR_DEFAULTS.runMs);
+    // Local cancellation also interrupts an in-flight HTTP request.
+    const pulse = setInterval(() => {
+        if (store.setting("desiredState") !== "running")
+            controller.abort(new CollectorInterruptedError("Import cancelled."));
+        else
+            store.set("heartbeatAt", new Date().toISOString());
+    }, 250);
+    const errors = new CollectorErrors(store), syncRequests = new CollectorSyncRequests(store);
+    const retained = (connection) => store.connections().find(item => item.id === connection.id) ?? connection;
+    const heartbeatInput = (connection) => {
+        const pendingOperations = store.queued(connection.id), error = errors.message(connection.id, "heartbeat");
+        return { pendingOperations, error, completedSyncRevision: !pendingOperations && !error ? connection.completedSyncRevision ?? 0 : 0 };
+    };
     function applyRemote(connection, remote) {
         const current = retained(connection);
         if (current.state === "disconnected" || remote.revision < current.revision)
@@ -74,255 +88,169 @@ export async function runCollector(input) {
         return next;
     }
     function recordFailure(connection, error, phase) {
-        const message = error instanceof Error ? error.message : "Collection failed.";
-        errors.set(connection.id, phase, message);
-        const status = error && typeof error === "object" && "status" in error
-            ? Number(error.status)
-            : 0;
+        errors.set(connection.id, phase, error instanceof Error ? error.message : "Import failed.");
+        const status = error && typeof error === "object" && "status" in error ? Number(error.status) : 0;
         const current = retained(connection);
-        // Authentication loss requires explicit reconnection; a timer or restart
-        // must never turn a revoked connection back into a paused/resumable one.
         if (current.state !== "disconnected" && [400, 401, 403].includes(status))
-            store.put({
-                ...current,
-                state: status === 400 ? "paused" : "disconnected",
-            });
+            store.put({ ...current, state: status === 400 ? "paused" : "disconnected" });
     }
-    async function acquire(connection) {
-        // A request arriving mid-scan must not be acknowledged by the older scan.
-        const controlRevision = connection.revision;
-        const requestedSyncRevision = connection.requestedSyncRevision ?? 0;
-        let cursor;
-        const failures = [];
-        do {
-            if (Date.now() - lastHeartbeat >= COLLECTOR_DEFAULTS.heartbeatMs) {
-                lastHeartbeat = Date.now();
-                store.set("heartbeatAt", new Date().toISOString());
-                for (const current of store.connections()) {
-                    if (current.state === "disconnected")
-                        continue;
-                    try {
-                        const remote = await input.transport.heartbeat(current, heartbeatInput(current));
-                        applyRemote(current, remote);
-                        errors.set(current.id, "heartbeat", null);
-                    }
-                    catch (error) {
-                        recordFailure(current, error, "heartbeat");
-                    }
-                }
-            }
-            connection =
-                store.connections().find((item) => item.id === connection.id) ??
-                    connection;
-            if (connection.state !== "active")
-                return;
-            if (input.signal.aborted || store.setting("desiredState") !== "running")
-                return;
-            const page = await listSessions(connection.source, {
-                since: connection.since ?? undefined,
-                cursor,
-                limit: 50,
-            });
-            for (const native of page.items) {
-                const scanKey = JSON.stringify([native.path, native.nativeSessionId]);
-                const scanRevision = native.storageRevision
-                    ? contentHash([native.storageRevision, agentImportNormalizerRevision(connection.source.source)])
-                    : null;
-                store.progress.select(connection.id, scanKey);
-                if (input.signal.aborted ||
-                    store.setting("desiredState") !== "running" ||
-                    store.connections().find((item) => item.id === connection.id)
-                        ?.state !== "active")
-                    return;
-                try {
-                    if (scanRevision &&
-                        !store.sourceChanged(connection.id, scanKey, scanRevision) &&
-                        !store.progress.tracks(connection.id, scanKey))
-                        continue;
-                    const { files, preview, branchLeafId } = await readSession(connection.source, native, {
-                        branchAnchor: collectorBranchAnchor(store, connection.id, native.nativeSessionId),
-                    });
-                    let eligible = false;
-                    for (const session of preview.sessions) {
-                        const key = JSON.stringify([
-                            connection.source.instanceId,
-                            session.sessionId,
-                            session.branchId,
-                        ]);
-                        store.progress.retained(connection.id, scanKey, key);
-                        const selectedBoundaries = session.boundaries.filter((boundary) => boundary.projection === "turn" &&
-                            boundary.terminal !== "unknown" &&
-                            (!connection.since ||
-                                Date.parse(session.events[boundary.start].occurredAt ??
-                                    native.updatedAt) >= Date.parse(connection.since)));
-                        eligible ||= selectedBoundaries.length > 0;
-                        const changed = selectedBoundaries.filter((boundary) => store.changed(connection.id, key, boundary.id, contentHash([boundary.inputHash, boundary.revisionHash])));
-                        for (let offset = 0; offset < changed.length; offset += COLLECTOR_DEFAULTS.batchCases) {
-                            const selected = changed.slice(offset, offset + COLLECTOR_DEFAULTS.batchCases);
-                            const operationId = `sync-${contentHash([connection.id, key, selected.map((boundary) => [boundary.id, boundary.inputHash, boundary.revisionHash])]).slice(0, 48)}`;
-                            store.enqueue({
-                                operationId,
-                                connectionId: connection.id,
-                                sessionKey: key,
-                                contentHash: session.contentHash,
-                                files,
-                                boundaryIds: selected.map((boundary) => boundary.id),
-                                ...(branchLeafId ? { branchLeafId } : {}),
-                            }, selected.map((boundary) => ({
-                                id: boundary.id,
-                                revision: contentHash([
-                                    boundary.inputHash,
-                                    boundary.revisionHash,
-                                ]),
-                            })), scanKey);
-                        }
-                    }
-                    store.progress.read(connection.id, scanKey, eligible);
-                    if (scanRevision)
-                        store.scanned(connection.id, scanKey, scanRevision);
-                }
-                catch (error) {
-                    if (error instanceof NativeSessionNotReadyError) {
-                        store.progress.read(connection.id, scanKey, false);
-                        if (scanRevision)
-                            store.scanned(connection.id, scanKey, scanRevision);
-                        continue;
-                    }
-                    store.progress.failed(connection.id, scanKey, error instanceof Error ? error.message : "Unable to read session");
-                    failures.push(`${native.nativeSessionId}: ${error instanceof Error ? error.message : "Unable to read session"}`);
-                }
-            }
-            cursor = page.nextCursor ?? undefined;
-        } while (cursor);
-        store.progress.discovered(connection.id);
-        reconciledRevisions.set(connection.id, controlRevision);
-        syncRequests.acquired(connection.id, { controlRevision, requestedSyncRevision, succeeded: failures.length === 0 });
-        errors.set(connection.id, "source", failures.length
-            ? `${failures.length} session(s) need attention. ${failures[0]}`
-            : null);
+    function checkCancelled() {
+        if (Date.now() >= deadlineAt && !controller.signal.aborted)
+            controller.abort(new Error("Import time budget reached. Remaining work is retained for the next run."));
+        if (signal.aborted)
+            throw signal.reason ?? new CollectorInterruptedError("Import cancelled.");
+        if (store.setting("desiredState") !== "running")
+            throw new CollectorInterruptedError("Import cancelled.");
     }
     try {
-        while (!input.signal.aborted &&
-            store.setting("desiredState") === "running") {
-            const connections = store.connections();
-            store.set("heartbeatAt", new Date().toISOString());
-            for (const connection of connections) {
-                if (connection.state === "disconnected")
-                    continue;
-                if (!watchers.has(connection.source.root))
-                    try {
-                        const watcher = watch(connection.source.root, { recursive: connection.source.acquisition !== "sqlite" }, () => {
-                            dirty = true;
-                        });
-                        watcher.on("error", () => {
-                            dirty = true;
-                        });
-                        watchers.set(connection.source.root, watcher);
-                    }
-                    catch {
-                        /* Reconciliation remains authoritative when platform watch is unavailable. */
-                    }
-            }
-            const heartbeat = Date.now() - lastHeartbeat >= COLLECTOR_DEFAULTS.heartbeatMs;
-            if (heartbeat)
+        await store.snapshots.migrate(() => signal.aborted || Date.now() >= deadlineAt || store.setting("desiredState") !== "running");
+        for (let connection of selected) {
+            let phase = "heartbeat", lastHeartbeat = 0;
+            let run = { id: nonce, state: "running", phase: "discovering", startedAt: new Date().toISOString(), finishedAt: null, processed: 0, discovered: 0, uploaded: 0, error: null };
+            const progress = (update) => { run = { ...run, ...update }; store.set(`run:${connection.id}`, JSON.stringify(run)); };
+            progress({});
+            const heartbeat = async () => {
+                checkCancelled();
+                phase = "heartbeat";
+                connection = retained(connection);
+                const remote = await input.transport.heartbeat(connection, heartbeatInput(connection), signal);
+                connection = applyRemote(connection, remote);
+                errors.set(connection.id, "heartbeat", null);
                 lastHeartbeat = Date.now();
-            const reconcile = dirty ||
-                Date.now() - lastReconcile >= COLLECTOR_DEFAULTS.reconcileMs ||
-                store.setting("syncNow") === "yes";
-            if (reconcile) {
-                dirty = false;
-                lastReconcile = Date.now();
-                store.set("syncNow", "no");
-            }
-            for (let connection of connections) {
+            };
+            const check = async () => {
+                checkCancelled();
+                if (Date.now() - lastHeartbeat >= COLLECTOR_DEFAULTS.heartbeatMs)
+                    await heartbeat();
                 connection = retained(connection);
-                if (connection.state === "disconnected")
-                    continue;
-                let phase = "heartbeat";
-                try {
-                    if (heartbeat) {
-                        const remote = await input.transport.heartbeat(connection, heartbeatInput(connection));
-                        connection = applyRemote(connection, remote);
-                        errors.set(connection.id, "heartbeat", null);
-                    }
-                    if (connection.state !== "active") {
-                        reconciledRevisions.delete(connection.id);
-                        continue;
-                    }
-                    phase = "source";
-                    // Resume must scan before retained one-time completion can pause again,
-                    // even when the ordinary reconcile interval has not elapsed.
-                    if (reconcile || reconciledRevisions.get(connection.id) !== connection.revision || syncRequests.needsAcquisition(connection))
-                        await acquire(connection);
-                    connection =
-                        store.connections().find((item) => item.id === connection.id) ??
-                            connection;
-                    if (connection.state !== "active")
-                        continue;
-                    if (input.signal.aborted || store.setting("desiredState") !== "running")
-                        continue;
-                    phase = "admission";
+                if (connection.state !== "active")
+                    throw new CollectorInterruptedError(`Source ${connection.state}.`);
+            };
+            const drain = async () => {
+                while (store.queued(connection.id)) {
+                    await check();
                     const next = store.next(connection.id);
-                    if (next)
+                    if (!next)
+                        break;
+                    progress({ phase: "uploading" });
+                    let admitted = false;
+                    for (let attempt = 0; attempt < COLLECTOR_DEFAULTS.attemptsPerRun; attempt++) {
+                        await check();
+                        if (!store.database.prepare("SELECT 1 FROM pending WHERE id=? AND connection_id=?").get(next.entry.operationId, connection.id)) {
+                            admitted = true;
+                            break;
+                        }
+                        phase = "admission";
                         try {
-                            await input.transport.admit(connection, next.entry);
+                            await input.transport.admit(connection, next.entry, signal);
+                            // Retain a real receipt even if Cancel arrived while the server committed.
                             store.acknowledge(next.entry);
                             errors.set(connection.id, "admission", null);
+                            progress({ uploaded: run.uploaded + next.entry.boundaryIds.length });
+                            admitted = true;
+                            break;
                         }
                         catch (error) {
-                            store.retry(next.entry.operationId, next.attempts);
-                            throw error;
+                            store.retry(next.entry.operationId, next.attempts + attempt);
+                            const status = error && typeof error === "object" && "status" in error ? Number(error.status) : 0;
+                            if (signal.aborted || [400, 401, 403, 409].includes(status) || attempt + 1 >= COLLECTOR_DEFAULTS.attemptsPerRun)
+                                throw error;
+                            await delay(1000 * 2 ** attempt, undefined, { signal });
                         }
+                    }
+                    if (!admitted)
+                        throw new Error("Pending import was not acknowledged.");
+                }
+            };
+            try {
+                await heartbeat();
+                if (connection.state !== "active")
+                    throw new CollectorInterruptedError(`Source ${connection.state}.`);
+                await drain();
+                let completedRevision;
+                // Remote scope revisions arriving mid-job require a fresh acquisition
+                // before acknowledging that request. Bound concurrent reconfiguration.
+                for (let pass = 0; pass < 3; pass++) {
+                    await check();
+                    const revision = connection.revision, requested = connection.requestedSyncRevision ?? 0;
+                    phase = "source";
+                    new CollectorSourceCache(store).seed(connection, until, store.coverage.manifest(connection.id));
+                    store.coverage.begin(connection, `${nonce}-${pass}`, run.startedAt, until);
+                    const checkAcquisition = async () => {
+                        await check();
+                        phase = "source";
+                        if (connection.revision !== revision)
+                            throw new CollectorScopeChangedError("Source settings changed during acquisition.");
+                    };
+                    try {
+                        await acquireCollectorSource({ store, connection, until, check: checkAcquisition,
+                            drain: async () => { await drain(); await checkAcquisition(); }, progress });
+                    }
+                    catch (error) {
+                        if (error instanceof CollectorScopeChangedError && pass < 2)
+                            continue;
+                        throw error;
+                    }
+                    errors.set(connection.id, "source", null);
+                    await drain();
+                    await input.transport.publishCoverage(connection, store.coverage.finish(connection.id, true), signal);
                     connection = retained(connection);
-                    if (input.signal.aborted || store.setting("desiredState") !== "running" || connection.state !== "active")
+                    if (connection.revision !== revision) {
+                        if (pass === 2)
+                            throw new Error("Source settings changed repeatedly during import. Run Sync now again.");
                         continue;
-                    connection = syncRequests.complete(connection, errors.message(connection.id, "heartbeat"));
-                    if (syncRequests.needsAcknowledgement(connection) && heartbeatInput(connection).completedSyncRevision) {
-                        phase = "heartbeat";
-                        const remote = await input.transport.heartbeat(connection, heartbeatInput(connection));
-                        connection = applyRemote(connection, remote);
-                        errors.set(connection.id, "heartbeat", null);
                     }
-                    if (!input.signal.aborted &&
-                        store.setting("desiredState") === "running" &&
-                        connection.state === "active" &&
-                        !connection.keepSyncing &&
-                        reconciledRevisions.get(connection.id) === connection.revision &&
-                        store.queued(connection.id) === 0 &&
-                        store.progress.status(connection.id).stage === "complete" &&
-                        !errors.source(connection.id) &&
-                        syncRequests.confirmed(connection.id) >= (connection.requestedSyncRevision ?? 0)) {
-                        phase = "control";
-                        if (!input.transport.pause)
-                            throw new Error("This transport cannot acknowledge completion of a one-time import.");
-                        const paused = await input.transport.pause(connection);
-                        applyRemote(connection, paused);
-                        errors.set(connection.id, "control", null);
+                    syncRequests.acquired(connection.id, { controlRevision: revision, requestedSyncRevision: requested, succeeded: true });
+                    connection = syncRequests.complete(connection, errors.message(connection.id, "heartbeat"));
+                    await heartbeat();
+                    if (connection.revision !== revision || syncRequests.needsAcquisition(connection)) {
+                        if (pass === 2)
+                            throw new Error("Source settings changed during completion. Run Sync now again.");
+                        continue;
                     }
+                    if (syncRequests.needsAcknowledgement(connection))
+                        throw new Error("The server has not acknowledged sync completion. Retry with Sync now.");
+                    completedRevision = revision;
+                    break;
                 }
-                catch (error) {
-                    recordFailure(connection, error, phase);
+                await check();
+                if (connection.revision !== completedRevision)
+                    throw new CollectorScopeChangedError("Source settings changed before completion. Run Sync now again.");
+                progress({ state: "completed", finishedAt: new Date().toISOString() });
+                store.set(`lastSuccess:${connection.id}`, run.finishedAt);
+            }
+            catch (error) {
+                const cancelled = error instanceof CollectorInterruptedError || input.signal.aborted || signal.reason instanceof CollectorInterruptedError;
+                const reason = signal.aborted ? signal.reason : error;
+                const message = reason instanceof Error ? reason.message : "Import cancelled.";
+                if (!cancelled)
+                    recordFailure(connection, reason, phase);
+                progress({ state: cancelled ? "cancelled" : "failed", error: message, finishedAt: new Date().toISOString() });
+                if (store.coverage.manifest(connection.id)?.jobId.startsWith(`${nonce}-`)) {
+                    const coverage = store.coverage.finish(connection.id, false);
+                    if (!signal.aborted && connection.state === "active") {
+                        try {
+                            await input.transport.publishCoverage(connection, coverage, signal);
+                        }
+                        catch (coverageError) {
+                            recordFailure(connection, coverageError, "source");
+                        }
+                    }
                 }
             }
-            await new Promise((resolve) => {
-                const done = () => {
-                    clearTimeout(timer);
-                    input.signal.removeEventListener("abort", done);
-                    resolve();
-                };
-                const timer = setTimeout(done, 1000);
-                input.signal.addEventListener("abort", done, { once: true });
-            });
+            if (signal.aborted || store.setting("desiredState") !== "running")
+                break;
         }
     }
     finally {
-        for (const watcher of watchers.values())
-            watcher.close();
+        clearInterval(pulse);
+        clearTimeout(deadline);
         const owner = JSON.parse(store.setting("owner") || "{}");
         if (owner.nonce === nonce) {
             store.set("pid", "");
             store.set("heartbeatAt", "");
             store.set("owner", "");
+            store.set("desiredState", "stopped");
         }
         store.close();
     }

package/dist/native-conversations/history.js

@@ -8,6 +8,7 @@ import { contentHash } from "@openpond/harness";
 import { listDatabaseSessions, readDatabaseSession } from "./database.js";
 import { claudeConversationTitle, retainedConversationTitle } from "./titles.js";
 import { NativeSessionNotReadyError } from "./readiness.js";
+import { inspectCodexWindow } from "./codex-window-inventory.js";
 import { NATIVE_READ_LIMIT, } from "./contracts.js";
 async function selectedPath(source, path, boundSize = true) {
     const root = await realpath(source.root), target = await realpath(resolve(root, path));
@@ -38,6 +39,14 @@ async function readSelectedFile(source, path) {
     }
     return text;
 }
+export async function inspectSessionWindow(source, session, input) {
+    if (source.source !== "codex" || source.acquisition !== "files" || session.issue
+        || !(session.path || source.root).endsWith(".jsonl"))
+        return null;
+    if (session.sourceInstanceId !== source.instanceId)
+        throw new Error("Native session belongs to another selected source.");
+    return inspectCodexWindow({ ...input, path: await selectedPath(source, session.path, false), sessionId: session.nativeSessionId });
+}
 async function pathsBelow(source) {
     if ((await lstat(source.root)).isFile())
         return [""];

package/dist/native-conversations/index.js

@@ -9,3 +9,4 @@ export * from "./supervisor.js";
 export * from "./location.js";
 export * from "./collector-branches.js";
 export * from "./collector-destinations.js";
+export * from "./collector-schedule.js";

package/dist/native-conversations/location.js

@@ -2,8 +2,10 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile } from "node:fs/promises";
-export function collectorDirectory(home = process.env.OPENPOND_HOME || join(homedir(), ".openpond")) {
-    return resolve(home, "conversation-importer");
+export function collectorDirectory(home = join(homedir(), ".openpond")) {
+    return process.env.OPENPOND_COLLECTOR_DIR
+        ? resolve(process.env.OPENPOND_COLLECTOR_DIR)
+        : resolve(home, "conversation-importer");
 }
 export async function collectorMachineId(directory = collectorDirectory()) {
     await mkdir(directory, { recursive: true, mode: 0o700 });