@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
126 lines (111 loc) • 5.38 kB
text/typescript
/**
* The indexer's side of one rebuild worker (#6990): spawn it, send the build
* request, and take it down again. Every exit settles: a worker that errors or
* exits rejects the pending build. dispose() is bounded; afterExit() runs
* cleanup only once the thread has really exited, so build files the thread
* may still hold are never removed under it.
*/
import { spawnWorker } from "../../lib/worker-embed";
import { storageWorkerOsJoinSettleMs } from "../../storage/worker-lifecycle";
import type { UsageLogRevision } from "../../usage/log";
import { RequestHistoryIndexStaleError } from "./ingest";
import type { RebuildWorkerReply, RebuildWorkerRequest } from "./rebuild-protocol";
const CLOSE_TIMEOUT_MS = 5_000;
type WorkerSuccess = Exclude<RebuildWorkerReply, { type: "error" }>;
function delay(ms: number): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms));
}
/** True when `promise` settles within `ms`; the timer is cleared either way so it never keeps a process alive. */
function settlesWithin(promise: Promise<unknown>, ms: number): Promise<boolean> {
let timer: ReturnType<typeof setTimeout> | undefined;
const expired = new Promise<boolean>(resolve => { timer = setTimeout(() => resolve(false), ms); });
return Promise.race([promise.then(() => true, () => true), expired]).finally(() => clearTimeout(timer));
}
function errorFromReply(reply: Extract<RebuildWorkerReply, { type: "error" }>): Error {
if (reply.name === "RequestHistoryIndexStaleError") return new RequestHistoryIndexStaleError(reply.message);
const error = new Error(reply.message);
error.name = reply.name;
return error;
}
export class RebuildWorkerJob {
private readonly worker: Worker;
private pending: { resolve: (reply: WorkerSuccess) => void; reject: (error: unknown) => void } | null = null;
private exited = false;
private exitedCleanly = false;
private disposal: Promise<void> | null = null;
private readonly closed: Promise<void>;
constructor() {
this.worker = spawnWorker(new URL("./rebuild-worker.ts", import.meta.url).href, "request-history-rebuild-worker");
let markClosed!: () => void;
this.closed = new Promise(resolve => { markClosed = resolve; });
this.worker.addEventListener("message", (event: MessageEvent<RebuildWorkerReply>) => {
const pending = this.pending;
this.pending = null;
if (!pending) return;
const reply = event.data;
if (reply.type === "error") pending.reject(errorFromReply(reply));
else pending.resolve(reply);
});
this.worker.addEventListener("error", (event: Event) => {
this.fail(new Error((event as ErrorEvent).message || "request-history rebuild worker failed"));
});
this.worker.addEventListener("close", () => {
this.exited = true;
this.fail(new Error("request-history rebuild worker exited"));
markClosed();
}, { once: true });
}
private fail(error: unknown): void {
const pending = this.pending;
this.pending = null;
pending?.reject(error);
}
private send(request: RebuildWorkerRequest): Promise<WorkerSuccess> {
if (this.exited || this.disposal) return Promise.reject(new Error("request-history rebuild worker is not running"));
if (this.pending) return Promise.reject(new Error("request-history rebuild worker is busy"));
return new Promise((resolve, reject) => {
this.pending = { resolve, reject };
this.worker.postMessage(request);
});
}
/** Build the complete private file; resolves with the ingested row count. */
async build(indexPath: string, buildPath: string, reason: string, revision: UsageLogRevision): Promise<number> {
const reply = await this.send({ type: "build", indexPath, buildPath, reason, revision });
if (reply.type !== "built") throw new Error("unexpected request-history build reply");
return reply.rows;
}
/** Scan a read-only connection off-loop; operational errors are not corruption. */
async check(indexPath: string): Promise<boolean> {
const reply = await this.send({ type: "check", indexPath });
if (reply.type !== "checked") throw new Error("unexpected request-history integrity reply");
return reply.healthy;
}
/** Stop the thread; waits a bounded time for it to exit. */
dispose(): Promise<void> {
this.disposal ??= this.shutDown();
return this.disposal;
}
/**
* Dispose, then run `cleanup` once the thread has exited. A thread that
* overran the bound (blocked in native I/O) gets its cleanup when it does
* exit; the returned promise does not wait for that.
*/
async afterExit(cleanup: () => void): Promise<void> {
await this.dispose();
if (this.exitedCleanly) {
cleanup();
return;
}
void this.closed.then(() => delay(storageWorkerOsJoinSettleMs())).then(cleanup).catch(() => undefined);
}
private async shutDown(): Promise<void> {
this.fail(new Error("request-history rebuild worker stopped"));
try { this.worker.terminate(); } catch { /* already gone */ }
if (!await settlesWithin(this.closed, CLOSE_TIMEOUT_MS)) return;
// Bun does not expose the OS thread join; Windows needs this gap before
// files a terminated thread held can be removed.
const settleMs = storageWorkerOsJoinSettleMs();
if (settleMs > 0) await delay(settleMs);
this.exitedCleanly = true;
}
}