@lostgradient/weft 0.2.0

package/dist/cli/conformance.js

@@ -0,0 +1,226 @@
+import { decode } from "../core/codec.js";
+import { Engine } from "../core/engine.js";
+import { serve } from "../server/index.js";
+import { KEYS } from "../storage/interface.js";
+import { MemoryStorage } from "../storage/memory.js";
+import {
+  REMOTE_WORKER_PROTOCOL_VERSION,
+  REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS
+} from "../worker/protocol.js";
+const CONFORMANCE_QUEUE = "conformance", CONFORMANCE_ACTIVITIES = [
+  "weft.conformance.echo",
+  "weft.conformance.sleep",
+  "weft.conformance.cancel"
+], CONFORMANCE_HEARTBEAT_INTERVAL_MS = 25;
+function createCheck(name, ok, message) {
+  return { name, ok, message };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function waitForCondition(predicate, timeoutMs, label) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() <= deadline) {
+    try {
+      if (await predicate())
+        return;
+    } catch (error) {
+      lastError = error;
+    }
+    await Bun.sleep(25);
+  }
+  const message = `Timed out after ${timeoutMs}ms waiting for ${label}`;
+  throw lastError instanceof Error ? Error(`${message}: ${lastError.message}`) : Error(message);
+}
+function startWorker(command, server) {
+  const environment = {
+    ...Bun.env,
+    WEFT_WORKER_URL: `${server.url.replace("http://", "ws://")}/v1/tasks/${CONFORMANCE_QUEUE}/stream`,
+    WEFT_WORKER_QUEUE: CONFORMANCE_QUEUE,
+    WEFT_WORKER_ACTIVITIES: CONFORMANCE_ACTIVITIES.join(","),
+    WEFT_WORKER_PROTOCOL_VERSION: String(REMOTE_WORKER_PROTOCOL_VERSION),
+    WEFT_CONFORMANCE_HEARTBEAT_INTERVAL_MS: String(CONFORMANCE_HEARTBEAT_INTERVAL_MS)
+  };
+  return {
+    process: Bun.spawn(command, {
+      env: environment,
+      stdout: "ignore",
+      stderr: "ignore"
+    })
+  };
+}
+async function stopWorker(worker) {
+  if (worker === void 0)
+    return;
+  if (worker.process.exitCode !== null)
+    return;
+  worker.process.kill("SIGTERM");
+  try {
+    await Promise.race([worker.process.exited, Bun.sleep(1000)]);
+  } catch {}
+  if (worker.process.exitCode === null) {
+    worker.process.kill("SIGKILL");
+    await worker.process.exited.catch(() => {
+      return;
+    });
+  }
+}
+async function waitForRegisteredWorker(server, timeoutMs) {
+  await waitForCondition(() => server.registry.getAll().length > 0, timeoutMs, "worker register");
+  const worker = server.registry.getAll()[0];
+  if (worker === void 0)
+    throw Error("worker registry was empty after registration wait");
+  return worker.id;
+}
+async function waitForReplacementWorker(server, originalWorkerId, timeoutMs) {
+  let replacementWorkerId;
+  await waitForCondition(() => {
+    replacementWorkerId = server.registry.getAll().find((registeredWorker) => registeredWorker.id !== originalWorkerId)?.id;
+    return replacementWorkerId !== void 0;
+  }, timeoutMs, "replacement worker register");
+  if (replacementWorkerId === void 0)
+    throw Error("replacement worker registry was empty after registration wait");
+  return replacementWorkerId;
+}
+async function waitForWorkerHeartbeat(server, workerId, timeoutMs) {
+  const disconnectedMessage = `Worker ${workerId} disconnected before heartbeat was observed`, heartbeatBefore = server.registry.getWorker(workerId)?.lastHeartbeat;
+  if (heartbeatBefore === void 0)
+    throw Error(disconnectedMessage);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const worker = server.registry.getWorker(workerId);
+    if (worker === void 0)
+      throw Error(disconnectedMessage);
+    if (worker.lastHeartbeat > heartbeatBefore)
+      return;
+    await Bun.sleep(25);
+  }
+  throw Error(`Timed out after ${timeoutMs}ms waiting for worker ${workerId} heartbeat`);
+}
+async function waitForWorkerIdle(server, workerId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const worker = server.registry.getWorker(workerId);
+    if (worker === void 0)
+      throw Error(`Worker ${workerId} disconnected while waiting to become idle`);
+    if (worker.inFlight === 0)
+      return;
+    await Bun.sleep(25);
+  }
+  throw Error(`Timed out after ${timeoutMs}ms waiting for worker ${workerId} to become idle`);
+}
+function isResolvedRecord(value) {
+  if (!isRecord(value))
+    return !1;
+  return typeof value.operationId === "string" && (value.status === "completed" || value.status === "failed") && typeof value.resolvedAt === "number";
+}
+async function readResolvedStatus(storage, operationId) {
+  const stored = await storage.get(KEYS.operationResolved(operationId));
+  if (stored === null)
+    return;
+  const decoded = decode(stored);
+  if (!isResolvedRecord(decoded))
+    return;
+  return decoded.status;
+}
+async function waitForResolvedStatus(storage, operationId, status, timeoutMs) {
+  await waitForCondition(async () => await readResolvedStatus(storage, operationId) === status, timeoutMs, `${operationId} to resolve as ${status}`);
+}
+async function dispatchAndWait(server, storage, operationId, activityName, input, expectedStatus, timeoutMs) {
+  if (!await server.dispatchTask({
+    operationId,
+    activityName,
+    input,
+    queue: CONFORMANCE_QUEUE,
+    visibilityTimeout: Math.max(500, timeoutMs)
+  }))
+    throw Error(`Could not dispatch ${operationId}`);
+  await waitForResolvedStatus(storage, operationId, expectedStatus, timeoutMs);
+}
+async function runConformanceChecks(command, timeoutMs) {
+  const storage = new MemoryStorage, engine = new Engine({ storage }), server = serve({ engine, port: 0, hostname: "127.0.0.1" }), checks = [];
+  let worker;
+  try {
+    worker = startWorker(command, server);
+    const workerId = await waitForRegisteredWorker(server, timeoutMs), registered = server.registry.getWorker(workerId);
+    checks.push(createCheck("register", registered?.queue === CONFORMANCE_QUEUE && CONFORMANCE_ACTIVITIES.every((activity) => registered.activities.includes(activity)), `registered worker ${workerId}`));
+    await dispatchAndWait(server, storage, "conformance-echo", "weft.conformance.echo", { ok: !0 }, "completed", timeoutMs);
+    checks.push(createCheck("task completion", !0, "echo task resolved"));
+    await waitForWorkerHeartbeat(server, workerId, timeoutMs);
+    await dispatchAndWait(server, storage, "conformance-heartbeat", "weft.conformance.sleep", { milliseconds: CONFORMANCE_HEARTBEAT_INTERVAL_MS * 3 }, "completed", timeoutMs);
+    checks.push(createCheck("heartbeat", !0, "heartbeat observed while worker was connected"));
+    const cancelOperationId = "conformance-cancel";
+    if (!await server.dispatchTask({
+      operationId: cancelOperationId,
+      activityName: "weft.conformance.cancel",
+      input: { milliseconds: timeoutMs },
+      queue: CONFORMANCE_QUEUE,
+      visibilityTimeout: Math.max(500, timeoutMs)
+    }))
+      throw Error("Could not dispatch cancellation task");
+    await waitForCondition(() => (server.registry.getWorker(workerId)?.inFlight ?? 0) > 0, timeoutMs, "cancellable task assignment");
+    if (!server.cancelTask(cancelOperationId))
+      throw Error("Server could not send cancel message");
+    await waitForResolvedStatus(storage, cancelOperationId, "failed", timeoutMs);
+    checks.push(createCheck("cancellation", !0, "cancelled task resolved as failed"));
+    const reconnectOperationId = "conformance-reconnect", reconnectDelayMs = Math.min(1500, Math.max(250, Math.floor(timeoutMs * 0.75)));
+    if (!await server.dispatchTask({
+      operationId: reconnectOperationId,
+      activityName: "weft.conformance.sleep",
+      input: { milliseconds: reconnectDelayMs },
+      queue: CONFORMANCE_QUEUE,
+      visibilityTimeout: Math.max(500, timeoutMs)
+    }))
+      throw Error("Could not dispatch reconnect task");
+    await waitForCondition(() => (server.registry.getWorker(workerId)?.inFlight ?? 0) > 0, timeoutMs, "in-flight reconnect task assignment");
+    const replacementWorker = startWorker(command, server), replacementWorkerId = await waitForReplacementWorker(server, workerId, timeoutMs);
+    await waitForWorkerHeartbeat(server, replacementWorkerId, timeoutMs);
+    await stopWorker(worker);
+    worker = replacementWorker;
+    await waitForCondition(() => server.registry.getWorker(workerId) === void 0, timeoutMs, "original worker disconnect");
+    await waitForWorkerIdle(server, replacementWorkerId, timeoutMs);
+    await waitForResolvedStatus(storage, reconnectOperationId, "completed", timeoutMs);
+    checks.push(createCheck("reconnect", !0, "in-flight task completed after reconnect"));
+    const shutdownWorkerId = server.registry.getWorker(replacementWorkerId)?.id;
+    if (shutdownWorkerId === void 0)
+      throw Error("No worker available for graceful shutdown check");
+    await server.shutdownWorker(shutdownWorkerId, { timeoutMs });
+    await waitForCondition(() => server.registry.getWorker(shutdownWorkerId) === void 0, timeoutMs, "worker graceful shutdown");
+    checks.push(createCheck("graceful shutdown", !0, "worker disconnected after shutdown"));
+  } finally {
+    await stopWorker(worker);
+    await server.stop();
+    engine[Symbol.dispose]();
+  }
+  return checks;
+}
+function formatChecks(checks, json) {
+  if (json)
+    return JSON.stringify({
+      ok: checks.every((check) => check.ok),
+      protocolVersion: REMOTE_WORKER_PROTOCOL_VERSION,
+      supportedProtocolVersions: REMOTE_WORKER_SUPPORTED_PROTOCOL_VERSIONS,
+      checks
+    }, null, 2);
+  return checks.map((check) => `${check.ok ? "PASS" : "FAIL"} ${check.name}: ${check.message}`).join(`
+`);
+}
+export async function executeConformance(options) {
+  if (options.workerCommand.length === 0)
+    return {
+      stdout: "",
+      stderr: "Error: worker command is required after --",
+      exitCode: 2
+    };
+  try {
+    const checks = await runConformanceChecks(options.workerCommand, options.timeoutMs), ok = checks.every((check) => check.ok);
+    return { stdout: formatChecks(checks, options.json), exitCode: ok ? 0 : 1 };
+  } catch (error) {
+    const failedCheck = createCheck("conformance", !1, error instanceof Error ? error.message : String(error));
+    return {
+      stdout: formatChecks([failedCheck], options.json),
+      exitCode: 1
+    };
+  }
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1,6 @@
+import type { CommandOutput } from './types.ts';
+/** Runs diagnostics against a SQLite database and formats the report. */
+export declare function executeDoctor(options: {
+    database: string;
+    json: boolean;
+}): Promise<CommandOutput>;

package/dist/cli/doctor.js

@@ -0,0 +1,9 @@
+export async function executeDoctor(options) {
+  const { collectDiagnostics } = await import("../diagnostics/doctor.js"), { formatDiagnosticReport } = await import("../diagnostics/format.js"), { BunSQLiteStorage } = await import("../storage/bun-sql.js"), storage = new BunSQLiteStorage(options.database);
+  try {
+    const report = await collectDiagnostics(storage, options.database);
+    return { stdout: options.json ? JSON.stringify(report, null, 2) : formatDiagnosticReport(report), exitCode: 0 };
+  } finally {
+    storage[Symbol.dispose]();
+  }
+}