@possumtech/rummy 2.0.1 → 2.1.0

package/src/llm/errors.js

@@ -13,9 +13,46 @@ export function isContextExceededMessage(message) {
 	return CONTEXT_EXCEEDED_PATTERN.test(String(message));
 }
 
-const TRANSIENT_PATTERN =
-	/\b(500|502|503|504|429|timeout|TimeoutError|aborted|unavailable|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|ETIMEDOUT|EPIPE|ECONNABORTED|fetch failed)\b/i;
+const ABORT_PATTERN = /\b(aborted|AbortError|TimeoutError)\b/;
+// `terminated` is undici's err.message when the underlying socket closes
+// mid-fetch (TLSSocket.onHttpSocketClose → Fetch.onAborted) — same lane
+// as ECONNRESET, just surfaced through a streaming-fetch path.
+const GATEWAY_PATTERN =
+	/\b(502|504|ECONNREFUSED|ECONNRESET|ENOTFOUND|EHOSTUNREACH|ETIMEDOUT|EPIPE|ECONNABORTED|fetch failed|terminated)\b/i;
+const RATE_LIMIT_PATTERN = /\b429\b/;
+const STATUS_503_PATTERN = /\b503\b/;
+const STATUS_500_PATTERN = /\b500\b/;
+// llamacpp / OpenAI-compatible servers signal model-warmup with this body.
+const MODEL_WARMUP_PATTERN = /\bLoading model\b/i;
 
-export function isTransientMessage(message) {
-	return TRANSIENT_PATTERN.test(String(message));
+// Returns "gateway" | "warmup" | "rate_limit" | "server" | null.
+// null = do not retry, propagate immediately. Operator/internal aborts,
+// auth failures, malformed-request errors, unknown shapes all fall here.
+export function classifyTransient(err) {
+	if (!err || typeof err.message !== "string") return null;
+	const { message } = err;
+
+	if (ABORT_PATTERN.test(message)) return null;
+	if (GATEWAY_PATTERN.test(message)) return "gateway";
+	if (RATE_LIMIT_PATTERN.test(message)) return "rate_limit";
+	if (STATUS_503_PATTERN.test(message)) {
+		// 503 + explicit warmup signal → wait it out.
+		if (MODEL_WARMUP_PATTERN.test(message)) return "warmup";
+		if (typeof err.body === "string" && MODEL_WARMUP_PATTERN.test(err.body)) {
+			return "warmup";
+		}
+		return "server";
+	}
+	if (STATUS_500_PATTERN.test(message)) return "server";
+	return null;
+}
+
+// HTTP Retry-After: integer seconds (most common form). Returns
+// undefined for missing, malformed, or HTTP-date forms — callers
+// fall through to backoff in those cases.
+export function parseRetryAfter(value) {
+	if (!value) return undefined;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds;
+	return undefined;
 }

package/src/llm/openaiStream.js

@@ -0,0 +1,125 @@
+import { parseRetryAfter } from "./errors.js";
+
+/**
+ * Shared streaming client for OpenAI-compatible /chat/completions endpoints.
+ *
+ * Provider plugins (openai, openrouter, ollama) construct the request body
+ * and headers; this module handles the SSE parsing, accumulates deltas into
+ * a non-streaming-shape response, and surfaces errors with the same ergonomics
+ * as the previous fetch-then-json pattern.
+ *
+ * Streaming is preferred over non-streaming for two reasons:
+ *
+ *   1. Long-running completions through CDN proxies (e.g. Cloudflare's 100s
+ *      origin-timeout) can't survive a non-streaming hold; streaming keeps
+ *      the connection alive byte-by-byte.
+ *   2. Future UI surfaces ("thinking" displays) want the deltas live; a
+ *      streaming-first plugin layer gives them a hook.
+ *
+ * The xAI Responses API (`/v1/responses`) uses a different streaming format
+ * and is out of scope for this client.
+ */
+
+/**
+ * @param {Object} args
+ * @param {string} args.url            Full POST URL (e.g. `${baseUrl}/v1/chat/completions`).
+ * @param {Object} args.headers        Plugin-specific headers (Authorization, etc.).
+ * @param {Object} args.body           Request body (without `stream` — added here).
+ * @param {AbortSignal} [args.signal]  Cancellation signal.
+ * @returns {Promise<Object>}          Non-streaming-shape response: `{ choices, usage, model }`.
+ *                                     Throws on non-2xx with `err.status` and `err.body` populated.
+ */
+export async function chatCompletionStream({ url, headers, body, signal }) {
+	const requestBody = {
+		...body,
+		stream: true,
+		// Tells OpenAI / OpenAI-compatible servers to emit a final usage chunk.
+		stream_options: { include_usage: true },
+	};
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json", ...headers },
+		body: JSON.stringify(requestBody),
+		signal,
+	});
+
+	if (!response.ok) {
+		const errorBody = await response.text();
+		const err = new Error(`${response.status} - ${errorBody}`);
+		err.status = response.status;
+		err.body = errorBody;
+		err.retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+		throw err;
+	}
+
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+
+	let buffer = "";
+	let content = "";
+	let reasoningContent = "";
+	let usage = null;
+	let model = null;
+	let finishReason = null;
+
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+
+		// SSE frames are separated by blank lines; within a frame, a `data:`
+		// line carries the JSON payload. Process complete lines and keep any
+		// trailing partial-line in the buffer for the next read.
+		const lines = buffer.split("\n");
+		buffer = lines.pop();
+
+		for (const rawLine of lines) {
+			const line = rawLine.trim();
+			if (!line.startsWith("data:")) continue;
+			const payload = line.slice(5).trimStart();
+			if (payload === "[DONE]" || payload === "") continue;
+
+			let chunk;
+			try {
+				chunk = JSON.parse(payload);
+			} catch {
+				continue;
+			}
+
+			if (chunk.model) model = chunk.model;
+			if (chunk.usage) usage = chunk.usage;
+
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+			if (choice.finish_reason) finishReason = choice.finish_reason;
+
+			const delta = choice.delta;
+			if (!delta) continue;
+			if (typeof delta.content === "string") content += delta.content;
+			// Different providers surface reasoning under different field names.
+			// Concatenate any that show up.
+			if (typeof delta.reasoning_content === "string")
+				reasoningContent += delta.reasoning_content;
+			if (typeof delta.reasoning === "string")
+				reasoningContent += delta.reasoning;
+			if (typeof delta.thinking === "string")
+				reasoningContent += delta.thinking;
+		}
+	}
+
+	return {
+		model,
+		choices: [
+			{
+				message: {
+					role: "assistant",
+					content,
+					reasoning_content: reasoningContent,
+				},
+				finish_reason: finishReason,
+			},
+		],
+		usage,
+	};
+}

package/src/llm/retry.js

@@ -1,18 +1,4 @@
-/**
- * Exponential backoff with full jitter, time-bounded.
- *
- * Calls `fn` until it returns a value, the deadline elapses, or a
- * non-retryable error is thrown. Between attempts, sleeps for a
- * random duration in [0, min(maxDelayMs, baseDelayMs * 2^attempt)).
- * Full jitter (AWS / Google Cloud pattern) prevents thundering-herd
- * synchronization across concurrent clients hitting the same API.
- *
- * Time-bounded, not count-bounded: a connect-level outage that
- * recovers in 4 minutes is invisible to the caller, but a persistent
- * outage fails after deadlineMs with a clear cause chain.
- *
- * Aborts immediately if the supplied AbortSignal fires — even mid-sleep.
- */
+// Time-bounded exponential backoff with full jitter; mid-sleep AbortSignal-aware.
 export async function retryWithBackoff(
 	fn,
 	{
@@ -50,6 +36,66 @@ export async function retryWithBackoff(
 	}
 }
 
+// Per-category retry. Each category gets its own deadline budget; a
+// category transition resets prior category state — the rationale being
+// that seeing a different category proves upstream is alive in some way,
+// so prior gateway/server storms aren't relevant to the new attempt.
+// Honors err.retryAfter (seconds) as a delay floor for rate-limit hints.
+export async function retryClassified(
+	fn,
+	{ signal, classify, policies, onRetry } = {},
+) {
+	const state = new Map(); // category → { start: ms, attempts: number }
+	let lastCategory = null;
+
+	while (true) {
+		signal?.throwIfAborted();
+		try {
+			return await fn();
+		} catch (err) {
+			const category = classify(err);
+			if (!category) throw err;
+			const policy = policies[category];
+			if (!policy) {
+				throw new Error(
+					`retryClassified: no policy for category "${category}"`,
+					{ cause: err },
+				);
+			}
+
+			if (lastCategory !== category) state.clear();
+			if (!state.has(category)) {
+				state.set(category, { start: Date.now(), attempts: 0 });
+			}
+			lastCategory = category;
+
+			const s = state.get(category);
+			const elapsedMs = Date.now() - s.start;
+			const remainingMs = policy.deadlineMs - elapsedMs;
+			if (remainingMs <= 0) {
+				throw new Error(
+					`${category} retry exhausted after ${Math.round(elapsedMs / 1000)}s; last error: ${err.message}`,
+					{ cause: err },
+				);
+			}
+
+			const expCap = Math.min(
+				policy.maxDelayMs,
+				policy.baseDelayMs * 2 ** s.attempts,
+			);
+			const jittered = Math.floor(Math.random() * expCap);
+			const delayMs =
+				err.retryAfter !== undefined
+					? Math.min(remainingMs, Math.max(err.retryAfter * 1000, jittered))
+					: Math.min(remainingMs, jittered);
+
+			onRetry?.(err, category, s.attempts + 1, delayMs, remainingMs);
+			await sleep(delayMs, signal);
+			s.attempts++;
+		}
+	}
+}
+
 function sleep(ms, signal) {
 	return new Promise((resolve, reject) => {
 		const t = setTimeout(resolve, ms);

package/src/plugins/budget/budget.js

@@ -2,15 +2,7 @@ import { ceiling, computeBudget, measureMessages } from "../../agent/budget.js";
 import materializeContext from "../../agent/materializeContext.js";
 import { countTokens } from "../../agent/tokens.js";
 
-/**
- * Delta-from-actual baseline. The pre-call <prompt tokenUsage> reports
- * the prior turn's actual API prompt_tokens; post-dispatch predicts
- * next turn's packet = this turn's actual tokens + tokens of new rows
- * written this turn. Keeps the 413 body on the same scale as the
- * model's <prompt> arithmetic — a 60% divergence between pre-call
- * (actual) and post-check (conservative estimator) makes the model
- * dismiss the system as janky and stop following rules.
- */
+// Delta-from-actual; same scale as <prompt tokenUsage>. SPEC #budget_enforcement.
 function predictNextPacket(rows, currentTurn, baseline) {
 	let delta = 0;
 	for (const r of rows) {
@@ -19,13 +11,7 @@ function predictNextPacket(rows, currentTurn, baseline) {
 	return baseline + delta;
 }
 
-/**
- * Format the 413 error body. Names each demoted path with its turn
- * and token count so the model can avoid re-promoting them next turn.
- * Exported (not private) so unit tests can assert the exact wire
- * format — the model reads this string, so its shape is part of the
- * contract.
- */
+// 413 error body; wire format is part of the model contract.
 export function overflowBody(overflow, contextSize, demoted) {
 	const cap = ceiling(contextSize);
 	const size = cap + overflow;
@@ -50,35 +36,22 @@ export default class Budget {
 			enforce: this.enforce.bind(this),
 			postDispatch: this.postDispatch.bind(this),
 		};
-		core.filter("assembly.user", this.assembleBudget.bind(this), 275);
+		core.filter("assembly.user", this.assembleBudget.bind(this), 175);
 	}
 
-	/**
-	 * Render the <budget> table between <instructions> and <prompt>.
-	 * See SPEC @token_accounting for the contract: per-row tokens are
-	 * aTokens (the promotion premium = vTokens − sTokens), summarized
-	 * entries collapse into a single aggregate line, system overhead
-	 * (system prompt + tool defs) gets its own line.
-	 */
+	// Renders <budget> at priority 275; see SPEC #token_accounting.
 	assembleBudget(content, ctx) {
 		const { rows, contextSize, systemPrompt } = ctx;
 		if (!contextSize) return content;
 
 		const cap = ceiling(contextSize);
 
-		// Per-scheme aggregation: counts and costs at each visibility tier
-		// plus the savings (premium) the model would unlock by demoting
-		// visible → summarized. All math derives from per-row vTokens
-		// (cost as visible) / sTokens (cost as summarized) / aTokens
-		// (= vTokens − sTokens, the promotion premium).
 		const byScheme = new Map();
 		let visibleCount = 0;
 		let premiumTokens = 0;
 		let summarizedCount = 0;
 		let _summarizedTokens = 0;
 		let floorTokens = 0;
-		let knownVTokens = 0;
-		let sourceVTokens = 0;
 
 		const schemeEntry = (s) => {
 			let e = byScheme.get(s);
@@ -102,36 +75,26 @@ export default class Budget {
 			const entry = schemeEntry(s);
 			if (r.visibility === "visible") {
 				entry.vis += 1;
-				entry.visTokens += r.vTokens || 0;
-				entry.visIfSumTokens += r.sTokens || 0;
-				entry.premium += r.aTokens || 0;
+				entry.visTokens += r.vTokens;
+				entry.visIfSumTokens += r.sTokens;
+				entry.premium += r.aTokens;
 				visibleCount += 1;
 				premiumTokens += r.aTokens;
 				floorTokens += r.sTokens;
-				const v = r.vTokens || 0;
-				if (s === "known") knownVTokens += v;
-				else if (s === "prompt") sourceVTokens += v;
-				else if (r.category === "data") sourceVTokens += v;
 			} else if (r.visibility === "summarized") {
 				entry.sum += 1;
-				entry.sumTokens += r.sTokens || 0;
+				entry.sumTokens += r.sTokens;
 				summarizedCount += 1;
 				_summarizedTokens += r.sTokens;
 				floorTokens += r.sTokens;
 			}
 		}
 
-		const fcrmDenom = knownVTokens + sourceVTokens;
-		const fcrmScore =
-			fcrmDenom > 0 ? (knownVTokens / fcrmDenom).toFixed(2) : "1.00";
-
-		const systemTokens = countTokens(systemPrompt || "");
+		const systemTokens = countTokens(systemPrompt);
 		const tokenUsage = floorTokens + premiumTokens + systemTokens;
 		const tokensFree = Math.max(0, cap - tokenUsage);
 
-		// Sort schemes by current cost descending — biggest-impact rows
-		// land at the top, so "what should I demote first?" reads
-		// straight off the table.
+		// Sort by current cost desc so biggest-impact rows are top.
 		const schemeRows = [...byScheme.entries()]
 			.toSorted(
 				([, a], [, b]) =>
@@ -161,7 +124,7 @@ export default class Budget {
 			"- premium: savings from demoting visible → summarized (cost − if-all-sum)",
 		].join("\n");
 
-		return `${content}<budget tokenUsage="${tokenUsage}" tokensFree="${tokensFree}" fcrmScore="${fcrmScore}">\n${table}\n\n${legend}\n${systemLine}\n${totalLine}\n</budget>\n`;
+		return `${content}<budget tokenUsage="${tokenUsage}" tokensFree="${tokensFree}">\n${table}\n\n${legend}\n${systemLine}\n${totalLine}\n</budget>\n`;
 	}
 
 	#check({ contextSize, messages, rows, lastPromptTokens = 0 }) {
@@ -197,16 +160,7 @@ export default class Budget {
 		});
 	}
 
-	/**
-	 * Pre-LLM budget enforcement. On first-turn overflow, demotes the
-	 * incoming prompt and re-materializes; re-checks and returns the
-	 * post-demotion result. If overflow persists after demotion (or on
-	 * later iterations), emits a 413 error (strike) and returns !ok so
-	 * TurnExecutor can skip the LLM call this turn.
-	 *
-	 * ctx = { runId, loopId, turn, systemPrompt, mode, toolSet, demoted,
-	 *         loopIteration }
-	 */
+	// Pre-LLM enforce: SPEC #budget_enforcement.
 	async enforce({
 		contextSize,
 		messages,
@@ -259,7 +213,6 @@ export default class Budget {
 			mode: ctx.mode,
 			toolSet: ctx.toolSet,
 			contextSize,
-			demoted: ctx.demoted,
 		});
 		const rechecked = this.#check({
 			contextSize,
@@ -280,14 +233,7 @@ export default class Budget {
 		return rechecked;
 	}
 
-	/**
-	 * Post-dispatch Turn Demotion. Re-materializes end-of-turn context and
-	 * checks against the ceiling. On overflow, demotes this turn's promoted
-	 * entries and emits a 413 error (strike) with the descriptive body so
-	 * the model sees it next turn via the unified error channel.
-	 *
-	 * ctx = { runId, loopId, turn, systemPrompt, mode, toolSet, demoted }
-	 */
+	// Post-dispatch Turn Demotion: SPEC #budget_enforcement.
 	async postDispatch({ contextSize, ctx, rummy }) {
 		if (!contextSize) return { failed: false };
 		const postMat = await materializeContext({
@@ -300,13 +246,7 @@ export default class Budget {
 			mode: ctx.mode,
 			toolSet: ctx.toolSet,
 			contextSize,
-			demoted: ctx.demoted,
 		});
-		// Baseline from this turn's actual API tokens (telemetry wrote it
-		// before post-dispatch runs). Delta from rows added this turn.
-		// Predicted next-turn packet stays on the tokenUsage scale the
-		// model can verify against its own arithmetic. materializeContext
-		// guarantees a number (0 when no prior API call exists).
 		const baseline = postMat.lastContextTokens;
 		const predicted = predictNextPacket(postMat.rows, ctx.turn, baseline);
 		const cap = ceiling(contextSize);
@@ -315,14 +255,7 @@ export default class Budget {
 
 		const store = rummy.entries;
 		let demotedEntries = await store.demoteTurnEntries(ctx.runId, ctx.turn);
-		// Fallback: if this turn had nothing to demote but the packet still
-		// overflows, the pressure is coming from prior-turn promotions the
-		// model never demoted itself. Widen to all currently-visible
-		// entries in the run. Without this fallback, overflow-with-nothing
-		// strikes out runs where the base context has drifted over ceiling
-		// through no fault of the current turn (observed: runs where 3
-		// stale promotions from turns 12–14 saturate every subsequent
-		// turn's budget).
+		// Prior-turn-pressure fallback; SPEC #budget_enforcement.
 		if (demotedEntries.length === 0) {
 			demotedEntries = await store.demoteRunVisibleEntries(ctx.runId);
 		}

package/src/plugins/cli/README.md

@@ -0,0 +1,87 @@
+# cli
+
+One-shot CLI client. Boots the service, runs a single `ask`/`act`,
+prints the final summary to stdout, exits with code `0` on terminal
+status `200` (non-zero otherwise). Server mode is unaffected — the
+plugin is inert when `RUMMY_PROMPT` is unset.
+
+## Invocation
+
+```bash
+rummy-cli --RUMMY_PROMPT="list files in /tmp" --RUMMY_MODEL=xfast
+```
+
+All args are env-var-shape: `--KEY=value`, `--KEY value`, or `--KEY`
+(boolean shorthand → `"1"`). Anything else is rejected with exit
+code `2`. CLI flags trump every `.env*` file (Node's `loadEnvFile`
+preserves existing vars).
+
+## Required env
+
+| Var | Effect |
+|---|---|
+| `RUMMY_PROMPT` | Activates the plugin and supplies the instruction. |
+| `RUMMY_MODEL` | Model alias (must match a registered `RUMMY_MODEL_<alias>`). |
+
+## Optional env
+
+| Var | Default | Effect |
+|---|---|---|
+| `RUMMY_MODE` | `act` | `ask` or `act`. |
+
+`RUMMY_RUN_TIMEOUT` is required at boot via `src/agent/config.js`;
+default lives in `.env.example`. Watchdog exits with code `124` on
+overflow.
+
+Per-run defaults (`RUMMY_YOLO`, `RUMMY_NO_REPO`, `RUMMY_NO_WEB`,
+`RUMMY_NO_INTERACTION`, `RUMMY_NO_PROPOSALS`) cascade through
+`AgentLoop`'s boundary normalization — see `.env.example`.
+
+## Profile pattern
+
+Layer profile-specific defaults via Node's `--env-file-if-exists`:
+
+```bash
+node --env-file-if-exists=.env.example \
+     --env-file-if-exists=.env \
+     --env-file-if-exists=.env.tbench \
+     src/plugins/cli/bin.js \
+     --RUMMY_PROMPT="..." --RUMMY_MODEL=xfast
+```
+
+A `.env.tbench` profile typically pins `RUMMY_YOLO=1`,
+`RUMMY_NO_INTERACTION=1`, `RUMMY_NO_WEB=1`, plus model alias and
+provider key. Bench harnesses call `rummy-cli` with just
+`--RUMMY_PROMPT="..."` and let the profile carry the rest.
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | Terminal status `200`. Model claimed success. |
+| `1` | Terminal status in `{204, 413, 422, 499, 500}` or run crashed. |
+| `2` | Arg parse error (invalid flag shape, missing required env). |
+| `124` | Wall-clock timeout (`RUMMY_RUN_TIMEOUT` exceeded). |
+
+External verifiers (terminal-bench, SWE-bench, etc.) decide actual
+task success — the exit code only reports rummy's internal terminal
+status.
+
+## Files
+
+- **`cli.js`** — plugin class. Subscribes to `boot.completed`; on fire,
+  if `RUMMY_PROMPT` is set, constructs a `ProjectAgent`, kicks off
+  the run, awaits its terminal status, prints the latest update body,
+  exits.
+- **`bin.js`** — executable. Parses env-shape args, mirrors
+  `bin/rummy.js`'s env-loading prelude, imports `service.js`.
+
+## Architectural notes
+
+- The plugin uses the same `ProjectAgent` constructor as
+  `ClientConnection`. In CLI mode, `SocketServer` still starts (it's
+  cheap) — `process.exit()` from the plugin terminates everything.
+- `core.on("boot.completed", ...)` is the plugin's only hook.
+  Subscribing earlier (e.g. constructor-time) would race plugin
+  registration order; `boot.completed` fires after all plugins are
+  inited and the DB is open.

package/src/plugins/cli/bin.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import resolveRummyHome from "../../agent/rummyHome.js";
+
+// Env-var-shape args: --KEY=value, --KEY value, or --KEY (→ "1").
+const ENV_FLAG = /^--([A-Z][A-Z0-9_]*)(?:=([\s\S]*))?$/;
+
+function parseEnvArgs(argv) {
+	const args = argv.slice(2);
+	let i = 0;
+	while (i < args.length) {
+		const m = args[i].match(ENV_FLAG);
+		if (!m) {
+			console.error(
+				`rummy-cli: unknown arg ${JSON.stringify(args[i])}. ` +
+					"All args must be --KEY=value, --KEY value, or --KEY (env-var-shape).",
+			);
+			process.exit(2);
+		}
+		const [, name, inline] = m;
+		if (inline !== undefined) {
+			process.env[name] = inline;
+			i += 1;
+			continue;
+		}
+		const next = args[i + 1];
+		if (next === undefined || next.startsWith("--")) {
+			process.env[name] = "1";
+			i += 1;
+			continue;
+		}
+		process.env[name] = next;
+		i += 2;
+	}
+}
+
+parseEnvArgs(process.argv);
+
+// Same env cascade as bin/rummy.js; CLI flags trump because loadEnvFile preserves existing vars.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "../../..");
+const rummyHome = resolveRummyHome();
+
+const cwd = process.cwd();
+const baseDir = existsSync(join(cwd, ".env.example")) ? cwd : rummyHome;
+if (existsSync(join(baseDir, ".env.example"))) {
+	process.loadEnvFile(join(baseDir, ".env.example"));
+}
+const userEnv = join(baseDir, ".env");
+if (existsSync(userEnv)) process.loadEnvFile(userEnv);
+
+process.env.RUMMY_HOME = rummyHome;
+const dbPath = process.env.RUMMY_DB_PATH;
+if (dbPath && !isAbsolute(dbPath)) {
+	process.env.RUMMY_DB_PATH = join(rummyHome, dbPath);
+}
+
+await import(join(packageRoot, "service.js"));