@everfur/cli 0.1.0 → 0.2.0

package/dist/everfur-mcp-container.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/everfur-mcp-container.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { loadHostedMcpConfig, startHostedMcpServer } from './chunk-VHZWTB6J.js';
+import { startRemoteMcpServer, loadRemoteMcpConfig } from './chunk-TBFOL2D3.js';
+import './chunk-WCH6AI6K.js';
+import { CLI_VERSION } from './chunk-CEWWBPPT.js';
+
+// src/mcp/container-entry.ts
+var HOSTED_MARKER = "MCP_PUBLIC_URL";
+var SELF_HOSTED_MARKER = "EVERFUR_MCP_HTTP_ACCESS_TOKEN";
+function isSet(env, name) {
+  return (env[name] ?? "").trim().length > 0;
+}
+function selectContainerEntry(env) {
+  const hosted = isSet(env, HOSTED_MARKER);
+  const selfHosted = isSet(env, SELF_HOSTED_MARKER);
+  if (hosted && !selfHosted) return { kind: "hosted" };
+  if (selfHosted && !hosted) return { kind: "self-hosted" };
+  if (hosted && selfHosted) {
+    return {
+      kind: "refused",
+      message: `both ${HOSTED_MARKER} and ${SELF_HOSTED_MARKER} are set. The image runs one entry: the Everfur-hosted server (${HOSTED_MARKER}) or the partner self-hosted server (${SELF_HOSTED_MARKER}), never both.`
+    };
+  }
+  return {
+    kind: "refused",
+    message: `neither ${HOSTED_MARKER} nor ${SELF_HOSTED_MARKER} is set. Set ${HOSTED_MARKER} (with EVERFUR_API_BASE_URL and EVERFUR_MCP_HTTP_PORT) for the Everfur-hosted server, or ${SELF_HOSTED_MARKER} (with that deployment's Everfur credentials) for the partner self-hosted server.`
+  };
+}
+
+// src/bin/everfur-mcp-container.ts
+async function main() {
+  const choice = selectContainerEntry(process.env);
+  if (choice.kind === "refused") throw new Error(choice.message);
+  let running;
+  if (choice.kind === "hosted") {
+    const config = loadHostedMcpConfig(process.env);
+    running = await startHostedMcpServer({ config });
+    process.stderr.write(`everfur-mcp-hosted listening at ${running.url.toString()} as ${config.publicUrl}
+`);
+  } else {
+    running = await startRemoteMcpServer(loadRemoteMcpConfig(process.env));
+    process.stderr.write(`everfur-mcp-http listening at ${running.url.toString()}
+`);
+  }
+  const stop = () => {
+    running.close().then(() => process.exit(0), () => process.exit(1));
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+}
+if (process.argv.slice(2).includes("--version")) {
+  process.stdout.write(`${CLI_VERSION}
+`);
+} else {
+  main().catch((error) => {
+    process.stderr.write(`everfur-mcp-container: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}

package/dist/everfur-mcp-hosted.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/everfur-mcp-hosted.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { loadHostedMcpConfig, startHostedMcpServer } from './chunk-VHZWTB6J.js';
+import './chunk-TBFOL2D3.js';
+import './chunk-WCH6AI6K.js';
+import { CLI_VERSION } from './chunk-CEWWBPPT.js';
+
+// src/bin/everfur-mcp-hosted.ts
+async function main() {
+  const config = loadHostedMcpConfig(process.env);
+  const running = await startHostedMcpServer({ config });
+  process.stderr.write(`everfur-mcp-hosted listening at ${running.url.toString()} as ${config.publicUrl}
+`);
+  const stop = () => {
+    running.close().then(() => process.exit(0), () => process.exit(1));
+  };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+}
+if (process.argv.slice(2).includes("--version")) {
+  process.stdout.write(`${CLI_VERSION}
+`);
+} else {
+  main().catch((error) => {
+    process.stderr.write(`everfur-mcp-hosted: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}

package/dist/everfur-mcp-http.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/everfur-mcp-http.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { startRemoteMcpServer, loadRemoteMcpConfig } from './chunk-TBFOL2D3.js';
+import './chunk-WCH6AI6K.js';
+import { CLI_VERSION } from './chunk-CEWWBPPT.js';
+
+// src/bin/everfur-mcp-http.ts
+async function main() {
+  const running = await startRemoteMcpServer(loadRemoteMcpConfig(process.env));
+  process.stderr.write(`everfur-mcp-http listening at ${running.url.toString()}
+`);
+}
+if (process.argv.slice(2).includes("--version")) {
+  process.stdout.write(`${CLI_VERSION}
+`);
+} else {
+  main().catch((error) => {
+    process.stderr.write(`everfur-mcp-http: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}

package/dist/everfur-mcp.js

@@ -1,369 +1,15 @@
 #!/usr/bin/env node
-import { CLI_VERSION, loadBundledDecisionSpace, loadDecisionSpace, nodeFileSystem, detectProject, missingFactsFor, planIntegration, runVerification, systemClock, resolveEndpoint, PARTNER_KEY, createApiClient, fetchTransport } from './chunk-KQZ6ZXL7.js';
-import { z } from 'zod';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-
-var CAPABILITY = z.enum(["chat", "records", "photo", "video", "animations"]);
-var IDENTITY_MODE = z.enum(["anonymous", "partner-user-ref", "personalized"]);
-function canonicalIdentityMode(mode) {
-  return mode === "personalized" ? "partner-user-ref" : mode;
-}
-var MINT_LANGUAGE = z.enum(["node", "python", "go", "ruby", "php", "java", "dotnet"]);
-function clientFor(context) {
-  const endpoint = resolveEndpoint(null, context.env);
-  if (!endpoint.ok) return { ok: false, errors: endpoint.errors };
-  return {
-    ok: true,
-    client: createApiClient({ transport: fetchTransport, clock: systemClock, endpoint: endpoint.endpoint })
-  };
-}
-function supplyOverMcp(fact) {
-  switch (fact) {
-    case "decisionTrees":
-      return "pass `contract_path` (a contract-public projection), or set EVERFUR_CONTRACT_PUBLIC in the server environment";
-    case "capabilities":
-      return 'pass `capabilities`, e.g. ["chat"] or ["chat","records"]. Ask the developer which surfaces they want; do not infer it from the project';
-    case "identityMode":
-      return 'pass `identity_mode`: "anonymous" (no backend, scoped to the device) or "partner-user-ref" (your backend mints a session). Ask the developer; this changes the integration shape';
-    case "sessionMintLanguage":
-      return "pass `session_mint_language`, the language of the backend that will mint sessions";
-    case "projectType":
-    case "packageManager":
-      return "point `project_root` at the application root; this fact is read from the project, not asserted";
-    default:
-      return "supply this fact as a tool argument of the same name";
-  }
-}
-function refusal(code, message, extra = {}) {
-  return { isError: true, document: { ok: false, failed_precondition: code, message, ...extra } };
-}
-var PLAN_INPUT_SHAPE = {
-  project_root: z.string().describe("Absolute path to the project being integrated."),
-  capabilities: z.array(CAPABILITY).optional().describe("Which Everfur capabilities this integration uses. Omit if unknown; the tool will refuse and say so."),
-  identity_mode: IDENTITY_MODE.optional().describe('anonymous = no backend, scoped to the device. partner-user-ref = your backend mints a session against your own user id. "personalized" is accepted as an alias for partner-user-ref.'),
-  session_mint_language: MINT_LANGUAGE.optional().describe("Backend language that will mint sessions. Only meaningful when identity_mode is partner-user-ref."),
-  contract_path: z.string().optional().describe("Path to a contract-public projection. Defaults to EVERFUR_CONTRACT_PUBLIC.")
-};
-function planIntegrationTool(args, context) {
-  const contractPath = args.contract_path ?? context.env["EVERFUR_CONTRACT_PUBLIC"] ?? null;
-  const load = contractPath === null ? loadBundledDecisionSpace() : loadDecisionSpace(nodeFileSystem, contractPath);
-  const input = {
-    detection: detectProject(nodeFileSystem, args.project_root),
-    capabilities: args.capabilities ? [...args.capabilities] : null,
-    identityMode: canonicalIdentityMode(args.identity_mode ?? null),
-    sessionMintLanguage: args.session_mint_language ?? null,
-    space: load !== null && load.kind === "loaded" ? load.space : null,
-    cliVersion: CLI_VERSION
-  };
-  const missing = missingFactsFor(input);
-  if (missing.length > 0) {
-    return refusal(
-      "UNDERSPECIFIED_INTEGRATION",
-      "This plan cannot be produced without the facts below. Ask the developer for each one; do not guess.",
-      {
-        missing_facts: missing.map((fact) => ({
-          fact: fact.fact,
-          why: fact.reason,
-          how_to_supply: supplyOverMcp(fact.fact),
-          // The CLI's own phrasing, kept so the two surfaces are visibly the same refusal and a partner
-          // moving between them recognises it.
-          how_to_supply_via_cli: fact.supplyWith
-        })),
-        next_call: {
-          tool: "everfur_plan_integration",
-          with: "the same arguments plus every missing fact above"
-        }
-      }
-    );
-  }
-  return { isError: false, document: { ok: true, plan: planIntegration(input) } };
-}
-var VERIFY_INPUT_SHAPE = {
-  user_ref: z.string().optional().describe("End-user id to mint the test session for. Defaults to a CLI-owned value."),
-  attempts: z.number().int().min(1).max(20).optional().describe("How many times to read the verdict before concluding it is empty.")
-};
-async function verifyIntegrationTool(args, context) {
-  const built = clientFor(context);
-  if (!built.ok) {
-    return refusal("WIRE_NOT_CONFIGURED", "The API connection could not be configured.", { errors: built.errors });
-  }
-  const verification = await runVerification({
-    client: built.client,
-    clock: systemClock,
-    env: context.env,
-    userRef: args.user_ref ?? "everfur-mcp-verify",
-    attempts: args.attempts ?? 3,
-    pollDelayMs: 500
-  });
-  return {
-    // `incomplete` is NOT an error: a SKIP means a credential was absent, which is the agent's cue to supply
-    // one, not a failure of the integration under test. Only a real FAIL is an error.
-    isError: verification.status === "failed",
-    document: {
-      ok: verification.status === "passed",
-      status: verification.status,
-      base_url: built.client.baseUrl,
-      steps: verification.steps,
-      // Attribution: a wrongly generated integration has to be traceable to the corpus revision that
-      // produced it, or a bad recommendation is unfalsifiable after the fact.
-      attribution: { cli_version: CLI_VERSION, verified_at: (/* @__PURE__ */ new Date()).toISOString() }
-    }
-  };
-}
-var DIAGNOSE_INPUT_SHAPE = {};
-async function diagnoseTool(_args, context) {
-  const built = clientFor(context);
-  if (!built.ok) {
-    return refusal("WIRE_NOT_CONFIGURED", "The API connection could not be configured.", { errors: built.errors });
-  }
-  const result = await built.client.request({ method: "GET", path: "/widget/v1/diagnostics" });
-  if (!result.ok && result.kind === "http" && result.status === 404) {
-    return refusal(
-      "DIAGNOSTICS_NOT_DEPLOYED",
-      "This deployment does not serve GET /widget/v1/diagnostics, so the four causes of an empty entitlement verdict cannot be told apart here. This is a gap in the PLATFORM, not in the integration being diagnosed.",
-      {
-        prerequisite: "definitive plan #6 (GET /widget/v1/diagnostics), 2 engineer-days, depends on T1.3",
-        base_url: built.client.baseUrl,
-        meanwhile: "everfur_verify_integration hard-asserts a non-empty verdict and will still catch the most common failure, an unprovisioned tenant, without naming which of the four causes it is."
-      }
-    );
-  }
-  if (!result.ok) {
-    return refusal("DIAGNOSTICS_FAILED", "The diagnostics call did not succeed.", {
-      kind: result.kind,
-      ...result.kind === "http" ? { status: result.status, code: result.code } : {},
-      request_id: result.requestId ?? null
-    });
-  }
-  return { isError: false, document: { ok: true, diagnostics: result.value, base_url: built.client.baseUrl } };
-}
-
-// src/mcp/send-test-message.ts
-var DEADLINE_MS = 3e4;
-function frameOf(block) {
-  const line = block.split("\n").find((l) => l.startsWith("data:"));
-  if (line === void 0) return null;
-  const raw = line.slice(5).trim();
-  if (raw.length === 0) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null) return { kind: "unknown" };
-    const obj = parsed;
-    if (typeof obj["token"] === "string") return { kind: "delta", text: obj["token"] };
-    if (typeof obj["status"] === "string") return { kind: `status:${obj["status"]}` };
-    if (obj["error"] !== void 0 || typeof obj["code"] === "string") return { kind: "error" };
-    if (obj["done"] === true) return { kind: "done" };
-    return { kind: "unknown" };
-  } catch {
-    return { kind: "malformed" };
-  }
-}
-function uuidFromKey(key) {
-  const words = [];
-  for (let lane = 0; lane < 4; lane += 1) {
-    let hash = 2166136261 ^ lane;
-    for (let i = 0; i < key.length; i += 1) {
-      hash ^= key.charCodeAt(i);
-      hash = hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24)) >>> 0;
-    }
-    words.push(hash >>> 0);
-  }
-  const hex = words.map((w) => w.toString(16).padStart(8, "0")).join("");
-  const version = `4${hex.slice(13, 16)}`;
-  const variant = `${(parseInt(hex[16] ?? "0", 16) & 3 | 8).toString(16)}${hex.slice(17, 20)}`;
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${version}-${variant}-${hex.slice(20, 32)}`;
-}
-function refuse(code, message, extra = {}) {
-  return { isError: true, document: { ok: false, failed_precondition: code, message, ...extra } };
-}
-async function sendTestMessage(args, env) {
-  const endpoint = resolveEndpoint(null, env);
-  if (!endpoint.ok) {
-    return refuse("WIRE_NOT_CONFIGURED", "The API connection could not be configured.", {
-      errors: endpoint.errors
-    });
-  }
-  const base = endpoint.endpoint.baseUrl.replace(/\/$/, "");
-  const key = (env[PARTNER_KEY.envVar] ?? "").trim();
-  if (key.length === 0) {
-    return refuse("NO_PARTNER_KEY", `Set ${PARTNER_KEY.envVar} to the publishable key of the sandbox tenant.`);
-  }
-  const sessionId = uuidFromKey(args.idempotency_key);
-  const headers = {
-    "x-everfur-partner-key": key,
-    "x-everfur-session-id": sessionId,
-    "content-type": "application/json"
-  };
-  const verdict = await fetch(`${base}/widget/v1/entitlements`, { headers });
-  if (!verdict.ok) {
-    return refuse("ENTITLEMENTS_UNREADABLE", "Could not read the entitlement verdict, so the sandbox status of this tenant is unknown. Refusing rather than guessing.", { status: verdict.status });
-  }
-  const body = await verdict.json();
-  if (body.livemode !== false) {
-    return refuse(
-      "NOT_A_SANDBOX_TENANT",
-      "This tool sends a REAL message and only runs against a sandbox tenant. This key resolves to a tenant reporting livemode true, or to a deployment that does not report livemode at all. Refusing: a test message landing in a tenant that holds real veterinary records is not recoverable by deleting it afterwards.",
-      {
-        livemode: body.livemode ?? null,
-        how_to_fix: "Use the publishable key of a tenant created with is_sandbox true, on a deployment running PARTNER_SANDBOX_MODE_ENABLED."
-      }
-    );
-  }
-  if (body.capabilities?.["chat.message.create"] === void 0) {
-    return refuse("CHAT_NOT_GRANTED", "This sandbox tenant does not grant chat.message.create, so a message would be refused by the server.", { granted: Object.keys(body.capabilities ?? {}) });
-  }
-  const created = await fetch(`${base}/widget/v1/conversations`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(args.pet_ref ? { pet_ref: args.pet_ref } : {})
-  });
-  if (!created.ok) {
-    return refuse("CONVERSATION_NOT_CREATED", "Could not open a conversation.", { status: created.status });
-  }
-  const conversationId = (await created.json()).conversation_id;
-  if (conversationId === void 0) {
-    return refuse("CONVERSATION_NOT_CREATED", "The create call returned no conversation_id.");
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), DEADLINE_MS);
-  const started = Date.now();
-  try {
-    const streamed = await fetch(`${base}/widget/v1/conversations/${encodeURIComponent(conversationId)}/messages`, {
-      method: "POST",
-      // `message` is the ONLY field this route accepts. `content` returns a 422 naming body.message,
-      // which is an hour of a developer's life if the tool gets it wrong.
-      headers: { ...headers, accept: "text/event-stream", "idempotency-key": args.idempotency_key },
-      body: JSON.stringify({ message: args.message }),
-      signal: controller.signal
-    });
-    if (!streamed.ok || streamed.body === null) {
-      return refuse("SEND_FAILED", "The send did not open a stream.", { status: streamed.status });
-    }
-    const histogram = {};
-    let answer = "";
-    const reader = streamed.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const blocks = buffer.split("\n\n");
-      buffer = blocks.pop() ?? "";
-      for (const block of blocks) {
-        const frame = frameOf(block);
-        if (frame === null) continue;
-        histogram[frame.kind] = (histogram[frame.kind] ?? 0) + 1;
-        if (frame.text !== void 0) answer += frame.text;
-      }
-    }
-    const deltas = histogram["delta"] ?? 0;
-    return {
-      // A stream that produced no deltas is a failure even with a 200, because the partner sees an
-      // empty answer and no error. Reporting it as success is the "green test that proves nothing"
-      // failure this whole surface exists to avoid.
-      isError: deltas === 0,
-      document: {
-        ok: deltas > 0,
-        livemode: false,
-        conversation_id: conversationId,
-        answer,
-        frame_histogram: histogram,
-        elapsed_ms: Date.now() - started,
-        ...deltas === 0 ? { warning: "The stream carried no delta frames, so no answer text arrived. Check the frame histogram." } : {}
-      }
-    };
-  } catch (error) {
-    const aborted = error instanceof Error && error.name === "AbortError";
-    return refuse(
-      aborted ? "DEADLINE_EXCEEDED" : "STREAM_FAILED",
-      aborted ? `The turn did not finish within ${DEADLINE_MS / 1e3}s.` : "The stream failed before it completed.",
-      { detail: error instanceof Error ? error.message : String(error) }
-    );
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// src/mcp/server.ts
-var INSTRUCTIONS = `Everfur partner integration tools.
-
-Everfur is a pet-health API. Partners embed chat and medical-records surfaces in their own apps via
-@everfur/sdk (React Native).
-
-Use everfur_plan_integration FIRST. It refuses underspecified input by naming exactly which facts are
-missing. When it refuses, ask the developer those specific questions and call it again. Do not guess the
-answers and do not proceed without them: an integration built on a guessed identity mode is wrong in a way
-that only shows up in production.
-
-Then everfur_verify_integration to exercise the real wire, and everfur_diagnose when a working integration
-stops returning capabilities.`;
-function toContent(result) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(result.document, null, 2) }],
-    isError: result.isError
-  };
-}
-function buildServer(context) {
-  const server = new McpServer(
-    { name: "everfur", version: CLI_VERSION },
-    { capabilities: { tools: {} }, instructions: INSTRUCTIONS }
-  );
-  server.registerTool(
-    "everfur_plan_integration",
-    {
-      title: "Plan an Everfur integration",
-      description: "Produce an integration plan for a project. REFUSES underspecified input by naming the missing facts rather than guessing them. Read-only; touches no network and no credential.",
-      inputSchema: PLAN_INPUT_SHAPE,
-      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
-    },
-    (args) => toContent(planIntegrationTool(args, context))
-  );
-  server.registerTool(
-    "everfur_verify_integration",
-    {
-      title: "Verify the wire end to end",
-      description: "Mint a session, poll entitlements, and hard-assert the verdict is not empty. Returns PASS/SKIP/FAIL per step with the request id of the call that produced it. Mints a real session, so it is not read-only, but it creates no partner-visible data.",
-      inputSchema: VERIFY_INPUT_SHAPE,
-      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
-    },
-    async (args) => toContent(await verifyIntegrationTool(args, context))
-  );
-  server.registerTool(
-    "everfur_diagnose",
-    {
-      title: "Explain why a capability is unavailable",
-      description: "Separate the four byte-identical causes of an empty entitlement verdict. Read-only. Reports honestly when the deployment does not serve the diagnostics route rather than relaying a bare 404.",
-      inputSchema: DIAGNOSE_INPUT_SHAPE,
-      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
-    },
-    async (args) => toContent(await diagnoseTool(args, context))
-  );
-  server.registerTool(
-    "everfur_send_test_message",
-    {
-      title: "Send a real message against a sandbox tenant",
-      description: "Send a REAL message and stream a real veterinary answer, against a SANDBOX tenant only. Refuses unless the entitlement verdict reports livemode false. Returns the answer plus a frame histogram, so a stream that died mid-answer is distinguishable from a short one.",
-      inputSchema: {
-        message: z.string().min(1).max(4e3).describe("What to ask. A real pet-health question gets a real answer."),
-        idempotency_key: z.string().min(8).describe("Required and explicit. The caller owns it, so a retried tool call cannot silently become a second message in the conversation."),
-        pet_ref: z.string().optional().describe("Optional pet to scope the conversation to. Must already be registered.")
-      },
-      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
-    },
-    async (args) => toContent(await sendTestMessage(args, context.env))
-  );
-  return server;
-}
-async function runStdioServer(env) {
-  const server = buildServer({ env });
-  await server.connect(new StdioServerTransport());
-}
+import { runStdioServer } from './chunk-WCH6AI6K.js';
+import { CLI_VERSION } from './chunk-CEWWBPPT.js';
 
 // src/bin/everfur-mcp.ts
-runStdioServer(process.env).catch((error) => {
-  process.stderr.write(`everfur-mcp: ${error instanceof Error ? error.message : String(error)}
+if (process.argv.slice(2).includes("--version")) {
+  process.stdout.write(`${CLI_VERSION}
 `);
-  process.exit(1);
-});
+} else {
+  runStdioServer(process.env).catch((error) => {
+    process.stderr.write(`everfur-mcp: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  });
+}

package/dist/everfur.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { ExitCode, runCli } from './chunk-67H43MI6.js';
-import { systemClock, fetchTransport, CLI_VERSION, nodeFileSystem } from './chunk-KQZ6ZXL7.js';
+import { runCli } from './chunk-S6UN7D2O.js';
+import { ExitCode, systemClock, fetchTransport, CLI_VERSION, nodeFileSystem, nodeContractCache } from './chunk-CEWWBPPT.js';
 
 // src/bin/everfur.ts
 async function main() {
@@ -12,7 +12,8 @@ async function main() {
       env: process.env,
       version: CLI_VERSION,
       transport: fetchTransport,
-      clock: systemClock
+      clock: systemClock,
+      contractCache: nodeContractCache(process.env)
     }
   });
   if (output.stdout.length > 0) process.stdout.write(output.stdout);