cvm-server 0.2.7 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvm-server",
-  "version": "0.2.7",
+  "version": "0.3.1",
   "description": "Cognitive Virtual Machine (CVM) - A deterministic bytecode VM with AI cognitive operations",
   "keywords": [
     "mcp",
@@ -39,10 +39,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.2",
-    "dotenv": "^16.0.0",
+    "zod": "^3.25.64",
     "mongodb": "^6.17.0",
-    "typescript": "^5.7.3",
-    "zod": "^3.25.64"
+    "dotenv": "^16.0.0",
+    "typescript": "^5.7.3"
   },
   "type": "commonjs",
   "nx": {
@@ -111,4 +111,4 @@
       }
     }
   }
-}
+}

package/main.js

@@ -1,725 +0,0 @@
-"use strict";
-const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
-const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
-const zod = require("zod");
-const t = require("typescript");
-const fs = require("fs");
-const s = require("path");
-const mongodb = require("mongodb");
-const h = require("os");
-const dotenv = require("dotenv");
-function _interopNamespaceDefault(e) {
-  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k in e) {
-      if (k !== "default") {
-        const d2 = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d2.get ? d2 : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const t__namespace = /* @__PURE__ */ _interopNamespaceDefault(t);
-const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s);
-const h__namespace = /* @__PURE__ */ _interopNamespaceDefault(h);
-const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var a = /* @__PURE__ */ ((i2) => (i2.PUSH = "PUSH", i2.POP = "POP", i2.LOAD = "LOAD", i2.STORE = "STORE", i2.CONCAT = "CONCAT", i2.JUMP = "JUMP", i2.JUMP_IF = "JUMP_IF", i2.CALL = "CALL", i2.RETURN = "RETURN", i2.CC = "CC", i2.PRINT = "PRINT", i2.HALT = "HALT", i2))(a || {});
-function l$1(i2) {
-  const p3 = [], r2 = [];
-  let u2 = false, c2 = false;
-  const o = t__namespace.createSourceFile(
-    "program.ts",
-    i2,
-    t__namespace.ScriptTarget.Latest,
-    true
-  );
-  function s2(e) {
-    if (t__namespace.isFunctionDeclaration(e) && e.name && e.name.text === "main" && (u2 = true, e.parameters.length > 0 && p3.push("main() must not have parameters")), t__namespace.isExpressionStatement(e) && e.parent === o) {
-      const n = e.expression;
-      t__namespace.isCallExpression(n) && t__namespace.isIdentifier(n.expression) && n.expression.text === "main" && (c2 = true);
-    }
-    if (t__namespace.isCallExpression(e) && t__namespace.isIdentifier(e.expression)) {
-      const n = e.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(n) && p3.push(`Unsupported function: ${n}`);
-    }
-    t__namespace.forEachChild(e, s2);
-  }
-  return s2(o), u2 || p3.push("Program must have a main() function"), u2 && !c2 && p3.push("main() must be called at the top level"), p3.length === 0 && r2.push({ op: a.HALT }), {
-    bytecode: r2,
-    errors: p3,
-    hasMain: u2
-  };
-}
-function m$1(i2) {
-  const p3 = l$1(i2);
-  if (p3.errors.length > 0)
-    return {
-      success: false,
-      bytecode: [],
-      errors: p3.errors
-    };
-  const r2 = [], u2 = t__namespace.createSourceFile("program.ts", i2, t__namespace.ScriptTarget.Latest, true);
-  function c2(s2) {
-    if (t__namespace.isExpressionStatement(s2)) {
-      const e = s2.expression;
-      t__namespace.isCallExpression(e) && t__namespace.isPropertyAccessExpression(e.expression) && e.expression.expression.getText() === "console" && e.expression.name.getText() === "log" ? (e.arguments.forEach((n) => {
-        o(n);
-      }), r2.push({ op: a.PRINT })) : t__namespace.isCallExpression(e) && t__namespace.isIdentifier(e.expression) && e.expression.text === "CC" && (e.arguments.length > 0 && o(e.arguments[0]), r2.push({ op: a.CC }), r2.push({ op: a.POP }));
-    } else if (t__namespace.isVariableStatement(s2)) {
-      const e = s2.declarationList.declarations[0];
-      e.initializer && (o(e.initializer), r2.push({ op: a.STORE, arg: e.name.getText() }));
-    }
-  }
-  function o(s2) {
-    t__namespace.isStringLiteral(s2) ? r2.push({ op: a.PUSH, arg: s2.text }) : t__namespace.isIdentifier(s2) ? r2.push({ op: a.LOAD, arg: s2.text }) : t__namespace.isCallExpression(s2) && t__namespace.isIdentifier(s2.expression) && s2.expression.text === "CC" ? (s2.arguments.length > 0 && o(s2.arguments[0]), r2.push({ op: a.CC })) : t__namespace.isBinaryExpression(s2) && s2.operatorToken.kind === t__namespace.SyntaxKind.PlusToken && (o(s2.left), o(s2.right), r2.push({ op: a.CONCAT }));
-  }
-  return u2.forEachChild((s2) => {
-    var e;
-    t__namespace.isFunctionDeclaration(s2) && ((e = s2.name) == null ? void 0 : e.text) === "main" && s2.body && s2.body.statements.forEach((n) => {
-      c2(n);
-    });
-  }), r2.push({ op: a.HALT }), {
-    success: true,
-    bytecode: r2,
-    errors: []
-  };
-}
-var l = Object.defineProperty;
-var d = (i2, t2, e) => t2 in i2 ? l(i2, t2, { enumerable: true, configurable: true, writable: true, value: e }) : i2[t2] = e;
-var r = (i2, t2, e) => d(i2, typeof t2 != "symbol" ? t2 + "" : t2, e);
-let p$1 = class p {
-  constructor(t2) {
-    r(this, "connected", false);
-    r(this, "programsDir");
-    r(this, "executionsDir");
-    this.dataDir = t2, this.programsDir = s__namespace.join(t2, "programs"), this.executionsDir = s__namespace.join(t2, "executions");
-  }
-  async connect() {
-    await fs.promises.mkdir(this.dataDir, { recursive: true }), await fs.promises.mkdir(this.programsDir, { recursive: true }), await fs.promises.mkdir(this.executionsDir, { recursive: true }), this.connected = true;
-  }
-  async disconnect() {
-    this.connected = false;
-  }
-  isConnected() {
-    return this.connected;
-  }
-  async saveProgram(t2) {
-    if (!this.connected) throw new Error("Not connected");
-    const e = s__namespace.join(this.programsDir, `${t2.id}.json`), o = JSON.stringify(t2, null, 2);
-    await fs.promises.writeFile(e, o, "utf-8");
-  }
-  async getProgram(t2) {
-    if (!this.connected) throw new Error("Not connected");
-    const e = s__namespace.join(this.programsDir, `${t2}.json`);
-    try {
-      const o = await fs.promises.readFile(e, "utf-8"), n = JSON.parse(o);
-      return n.created = new Date(n.created), n.updated && (n.updated = new Date(n.updated)), n;
-    } catch (o) {
-      if (o.code === "ENOENT")
-        return null;
-      throw o;
-    }
-  }
-  async saveExecution(t2) {
-    if (!this.connected) throw new Error("Not connected");
-    const e = s__namespace.join(this.executionsDir, `${t2.id}.json`), o = JSON.stringify(t2, null, 2);
-    await fs.promises.writeFile(e, o, "utf-8");
-  }
-  async getExecution(t2) {
-    if (!this.connected) throw new Error("Not connected");
-    const e = s__namespace.join(this.executionsDir, `${t2}.json`);
-    try {
-      const o = await fs.promises.readFile(e, "utf-8"), n = JSON.parse(o);
-      return n.created = new Date(n.created), n.updated && (n.updated = new Date(n.updated)), n;
-    } catch (o) {
-      if (o.code === "ENOENT")
-        return null;
-      throw o;
-    }
-  }
-};
-let w$1 = class w {
-  constructor(t2) {
-    r(this, "client");
-    r(this, "db", null);
-    r(this, "connected", false);
-    this.connectionString = t2, this.client = new mongodb.MongoClient(t2);
-  }
-  async connect() {
-    var n;
-    await this.client.connect();
-    const t2 = ((n = this.connectionString.split("/").pop()) == null ? void 0 : n.split("?")[0]) || "cvm";
-    this.db = this.client.db(t2), this.connected = true;
-    const o = (await this.db.listCollections().toArray()).map((a2) => a2.name);
-    o.includes("programs") || await this.db.createCollection("programs"), o.includes("executions") || await this.db.createCollection("executions");
-  }
-  async disconnect() {
-    await this.client.close(), this.connected = false, this.db = null;
-  }
-  isConnected() {
-    return this.connected;
-  }
-  async getCollections() {
-    if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((e) => e.name);
-  }
-  getCollection(t2) {
-    if (!this.db) throw new Error("Not connected to database");
-    return this.db.collection(t2);
-  }
-  async saveProgram(t2) {
-    await this.getCollection("programs").replaceOne(
-      { id: t2.id },
-      t2,
-      { upsert: true }
-    );
-  }
-  async getProgram(t2) {
-    return await this.getCollection("programs").findOne({ id: t2 });
-  }
-  async saveExecution(t2) {
-    await this.getCollection("executions").replaceOne(
-      { id: t2.id },
-      t2,
-      { upsert: true }
-    );
-  }
-  async getExecution(t2) {
-    return await this.getCollection("executions").findOne({ id: t2 });
-  }
-};
-class g {
-  static create(t2) {
-    const e = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (e) {
-      case "file": {
-        const o = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || s__namespace.join(h__namespace.homedir(), ".cvm");
-        return new p$1(o);
-      }
-      case "mongodb": {
-        const o = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
-        return new w$1(o);
-      }
-      default:
-        throw new Error(`Unsupported storage type: ${e}`);
-    }
-  }
-}
-var m = Object.defineProperty;
-var w2 = (p3, r2, t2) => r2 in p3 ? m(p3, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : p3[r2] = t2;
-var u = (p3, r2, t2) => w2(p3, typeof r2 != "symbol" ? r2 + "" : r2, t2);
-class i {
-  execute(r2, t2) {
-    const e = {
-      pc: (t2 == null ? void 0 : t2.pc) ?? 0,
-      stack: (t2 == null ? void 0 : t2.stack) ?? [],
-      variables: (t2 == null ? void 0 : t2.variables) ?? /* @__PURE__ */ new Map(),
-      status: "running",
-      output: (t2 == null ? void 0 : t2.output) ?? [],
-      ...t2
-    };
-    for (; e.status === "running" && e.pc < r2.length; ) {
-      const s2 = r2[e.pc];
-      switch (s2.op) {
-        case a.HALT:
-          e.status = "complete";
-          break;
-        case a.PUSH:
-          e.stack.push(s2.arg), e.pc++;
-          break;
-        case a.POP:
-          e.stack.pop(), e.pc++;
-          break;
-        case a.LOAD:
-          e.stack.push(e.variables.get(s2.arg) ?? ""), e.pc++;
-          break;
-        case a.STORE:
-          const c2 = e.stack.pop();
-          e.variables.set(s2.arg, c2), e.pc++;
-          break;
-        case a.CONCAT:
-          const o = e.stack.pop(), a$1 = e.stack.pop();
-          e.stack.push(a$1 + o), e.pc++;
-          break;
-        case a.PRINT:
-          const g2 = e.stack.pop();
-          e.output.push(g2), e.pc++;
-          break;
-        case a.CC:
-          e.ccPrompt = e.stack.pop(), e.status = "waiting_cc";
-          break;
-        default:
-          e.status = "error", e.error = `Unknown opcode: ${s2.op}`;
-      }
-    }
-    return e;
-  }
-  resume(r2, t2, e) {
-    if (r2.status !== "waiting_cc")
-      throw new Error("Cannot resume: VM not waiting for CC");
-    const s2 = {
-      ...r2,
-      stack: [...r2.stack, t2],
-      status: "running",
-      ccPrompt: void 0,
-      pc: r2.pc + 1
-    };
-    return this.execute(e, s2);
-  }
-}
-class b {
-  constructor(r2) {
-    u(this, "vms", /* @__PURE__ */ new Map());
-    u(this, "storage");
-    r2 ? this.storage = r2 : this.storage = g.create();
-  }
-  /**
-   * Initialize the VMManager (connect to database)
-   */
-  async initialize() {
-    await this.storage.connect();
-  }
-  /**
-   * Cleanup resources
-   */
-  async dispose() {
-    await this.storage.disconnect(), this.vms.clear();
-  }
-  /**
-   * Load and compile a program from source code
-   */
-  async loadProgram(r2, t2) {
-    const e = m$1(t2);
-    if (!e.success)
-      throw new Error(`Compilation failed: ${e.errors.join(", ")}`);
-    const s2 = {
-      id: r2,
-      name: r2,
-      source: t2,
-      bytecode: e.bytecode,
-      // VM decides internal format
-      created: /* @__PURE__ */ new Date()
-    };
-    await this.storage.saveProgram(s2);
-  }
-  /**
-   * Start execution of a loaded program
-   */
-  async startExecution(r2, t2) {
-    if (!await this.storage.getProgram(r2))
-      throw new Error(`Program not found: ${r2}`);
-    const s2 = {
-      id: t2,
-      programId: r2,
-      state: "ready",
-      pc: 0,
-      stack: [],
-      variables: {},
-      output: [],
-      created: /* @__PURE__ */ new Date()
-    };
-    await this.storage.saveExecution(s2);
-    const c2 = new i();
-    this.vms.set(t2, c2);
-  }
-  /**
-   * Get next action from execution (Claude polls this)
-   * This is READ-ONLY - just returns current state
-   */
-  async getNext(r2) {
-    const t2 = await this.storage.getExecution(r2);
-    if (!t2)
-      throw new Error(`Execution not found: ${r2}`);
-    if (t2.state === "ready") {
-      const e = await this.storage.getProgram(t2.programId);
-      if (!e)
-        throw new Error(`Program not found: ${t2.programId}`);
-      let s2 = this.vms.get(r2);
-      s2 || (s2 = new i(), this.vms.set(r2, s2));
-      const c2 = {
-        pc: 0,
-        stack: [],
-        variables: /* @__PURE__ */ new Map(),
-        output: []
-      }, o = s2.execute(e.bytecode, c2);
-      if (t2.pc = o.pc, t2.stack = o.stack, t2.variables = Object.fromEntries(o.variables), t2.output = o.output, o.status === "complete")
-        return t2.state = "completed", await this.storage.saveExecution(t2), this.vms.delete(r2), {
-          type: "completed",
-          message: "Execution completed"
-        };
-      if (o.status === "waiting_cc")
-        return t2.state = "waiting_cc", t2.ccPrompt = o.ccPrompt, await this.storage.saveExecution(t2), {
-          type: "waiting",
-          message: o.ccPrompt || "Waiting for input"
-        };
-      if (o.status === "error")
-        return t2.state = "error", t2.error = o.error, await this.storage.saveExecution(t2), this.vms.delete(r2), {
-          type: "error",
-          error: o.error
-        };
-    }
-    if (t2.state === "completed")
-      return {
-        type: "completed",
-        message: "Execution completed"
-      };
-    if (t2.state === "error")
-      return {
-        type: "error",
-        error: t2.error || "Unknown error"
-      };
-    if (t2.state === "waiting_cc")
-      return {
-        type: "waiting",
-        message: t2.ccPrompt || "Waiting for input"
-      };
-    throw new Error(`Unexpected execution state: ${t2.state}`);
-  }
-  /**
-   * Report result from cognitive operation and continue execution
-   */
-  async reportCCResult(r2, t2) {
-    const e = await this.storage.getExecution(r2);
-    if (!e)
-      throw new Error(`Execution not found: ${r2}`);
-    const s2 = await this.storage.getProgram(e.programId);
-    if (!s2)
-      throw new Error(`Program not found: ${e.programId}`);
-    let c2 = this.vms.get(r2);
-    c2 || (c2 = new i(), this.vms.set(r2, c2));
-    const o = {
-      pc: e.pc,
-      stack: e.stack,
-      variables: new Map(Object.entries(e.variables)),
-      status: "waiting_cc",
-      output: e.output,
-      ccPrompt: void 0
-    }, a2 = c2.resume(o, t2, s2.bytecode);
-    e.pc = a2.pc, e.stack = a2.stack, e.variables = Object.fromEntries(a2.variables), e.output = a2.output, a2.status === "complete" ? (e.state = "completed", this.vms.delete(r2)) : a2.status === "error" ? (e.state = "error", e.error = a2.error, this.vms.delete(r2)) : a2.status === "waiting_cc" ? (e.state = "waiting_cc", e.ccPrompt = a2.ccPrompt) : e.state = "running", await this.storage.saveExecution(e);
-  }
-  /**
-   * Get current execution status
-   */
-  async getExecutionStatus(r2) {
-    const t2 = await this.storage.getExecution(r2);
-    if (!t2)
-      throw new Error(`Execution not found: ${r2}`);
-    return {
-      id: t2.id,
-      state: t2.state,
-      pc: t2.pc,
-      stack: t2.stack,
-      variables: t2.variables,
-      output: t2.output
-    };
-  }
-}
-var x = Object.defineProperty;
-var p2 = (i2, r2, t2) => r2 in i2 ? x(i2, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : i2[r2] = t2;
-var c = (i2, r2, t2) => p2(i2, typeof r2 != "symbol" ? r2 + "" : r2, t2);
-class f {
-  constructor() {
-    c(this, "server");
-    c(this, "transport", null);
-    c(this, "vmManager");
-    this.vmManager = new b(), this.server = new mcp_js.McpServer({
-      name: "cvm-server",
-      version: "1.0.0"
-    }), this.setupTools();
-  }
-  getName() {
-    return "cvm-server";
-  }
-  getVersion() {
-    return "1.0.0";
-  }
-  setupTools() {
-    this.server.tool(
-      "loadProgram",
-      {
-        programId: zod.z.string(),
-        source: zod.z.string()
-      },
-      async ({ programId: r2, source: t2 }) => {
-        try {
-          return await this.vmManager.loadProgram(r2, t2), {
-            content: [{ type: "text", text: `Program loaded successfully: ${r2}` }]
-          };
-        } catch (o) {
-          return {
-            content: [{ type: "text", text: `Error: ${o instanceof Error ? o.message : "Unknown error"}` }],
-            isError: true
-          };
-        }
-      }
-    ), this.server.tool(
-      "startExecution",
-      {
-        programId: zod.z.string(),
-        executionId: zod.z.string()
-      },
-      async ({ programId: r2, executionId: t2 }) => {
-        try {
-          return await this.vmManager.startExecution(r2, t2), {
-            content: [{ type: "text", text: `Execution started: ${t2}` }]
-          };
-        } catch (o) {
-          return {
-            content: [{ type: "text", text: `Error: ${o instanceof Error ? o.message : "Unknown error"}` }],
-            isError: true
-          };
-        }
-      }
-    ), this.server.tool(
-      "getNext",
-      {
-        executionId: zod.z.string()
-      },
-      async ({ executionId: r2 }) => {
-        try {
-          const t2 = await this.vmManager.getNext(r2);
-          return t2.type === "completed" ? {
-            content: [{ type: "text", text: "Execution completed" }]
-          } : t2.type === "waiting" ? {
-            content: [{ type: "text", text: t2.message || "Waiting for input" }]
-          } : t2.type === "error" ? {
-            content: [{ type: "text", text: `Error: ${t2.error}` }],
-            isError: true
-          } : {
-            content: [{ type: "text", text: "Unexpected state" }],
-            isError: true
-          };
-        } catch (t2) {
-          return {
-            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
-            isError: true
-          };
-        }
-      }
-    ), this.server.tool(
-      "reportCCResult",
-      {
-        executionId: zod.z.string(),
-        result: zod.z.string()
-      },
-      async ({ executionId: r2, result: t2 }) => {
-        try {
-          return await this.vmManager.reportCCResult(r2, t2), {
-            content: [{ type: "text", text: "Execution resumed" }]
-          };
-        } catch (o) {
-          return {
-            content: [{ type: "text", text: `Error: ${o instanceof Error ? o.message : "Unknown error"}` }],
-            isError: true
-          };
-        }
-      }
-    ), this.server.tool(
-      "getExecutionState",
-      {
-        executionId: zod.z.string()
-      },
-      async ({ executionId: r2 }) => {
-        try {
-          const t2 = await this.vmManager.getExecutionStatus(r2);
-          return {
-            content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
-          };
-        } catch (t2) {
-          return {
-            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
-            isError: true
-          };
-        }
-      }
-    );
-  }
-  async start() {
-    await this.vmManager.initialize(), this.transport = new stdio_js.StdioServerTransport(), await this.server.connect(this.transport);
-  }
-  async stop() {
-    this.transport && (await this.transport.close(), this.transport = null), await this.vmManager.dispose();
-  }
-  // For testing - direct tool invocation
-  async handleTool(r2, t2) {
-    const u2 = {
-      loadProgram: async ({ programId: n, source: e }) => {
-        try {
-          return await this.vmManager.loadProgram(n, e), { content: [{ type: "text", text: `Program loaded successfully: ${n}` }] };
-        } catch (s2) {
-          return { content: [{ type: "text", text: s2 instanceof Error ? s2.message : "Unknown error" }], isError: true };
-        }
-      },
-      startExecution: async ({ programId: n, executionId: e }) => {
-        try {
-          return await this.vmManager.startExecution(n, e), { content: [{ type: "text", text: `Execution started: ${e}` }] };
-        } catch (s2) {
-          return { content: [{ type: "text", text: s2 instanceof Error ? s2.message : "Unknown error" }], isError: true };
-        }
-      },
-      getNext: async ({ executionId: n }) => {
-        try {
-          const e = await this.vmManager.getNext(n);
-          return e.type === "completed" ? { content: [{ type: "text", text: "Execution completed" }] } : e.type === "waiting" ? { content: [{ type: "text", text: e.message || "Waiting for input" }] } : { content: [{ type: "text", text: `Error: ${e.error}` }], isError: true };
-        } catch (e) {
-          return { content: [{ type: "text", text: e instanceof Error ? e.message : "Unknown error" }], isError: true };
-        }
-      },
-      reportCCResult: async ({ executionId: n, result: e }) => {
-        try {
-          return await this.vmManager.reportCCResult(n, e), { content: [{ type: "text", text: "Execution resumed" }] };
-        } catch (s2) {
-          return { content: [{ type: "text", text: s2 instanceof Error ? s2.message : "Unknown error" }], isError: true };
-        }
-      },
-      getExecutionState: async ({ executionId: n }) => {
-        try {
-          const e = await this.vmManager.getExecutionStatus(n);
-          return { content: [{ type: "text", text: JSON.stringify(e, null, 2) }] };
-        } catch (e) {
-          return { content: [{ type: "text", text: e instanceof Error ? e.message : "Unknown error" }], isError: true };
-        }
-      }
-    }[r2];
-    if (!u2)
-      throw new Error(`Tool not found: ${r2}`);
-    return await u2(t2);
-  }
-}
-dotenv__namespace.config({ path: s.resolve(__dirname, "../../../.env") });
-function loadConfig() {
-  const env = process.env.NODE_ENV || "development";
-  const storageType = process.env.CVM_STORAGE_TYPE || "file";
-  const mongoUri = process.env.MONGODB_URI;
-  const dataDir = process.env.CVM_DATA_DIR;
-  if (storageType === "mongodb" && !mongoUri) {
-    throw new Error("MONGODB_URI environment variable is required when CVM_STORAGE_TYPE is mongodb");
-  }
-  const logLevel = process.env.CVM_LOG_LEVEL || "info";
-  const validLogLevels = ["debug", "info", "warn", "error"];
-  if (!validLogLevels.includes(logLevel)) {
-    throw new Error(`Invalid CVM_LOG_LEVEL: ${logLevel}. Must be one of: ${validLogLevels.join(", ")}`);
-  }
-  const maxExecutionTime = parseInt(process.env.CVM_MAX_EXECUTION_TIME || "300000", 10);
-  const maxStackSize = parseInt(process.env.CVM_MAX_STACK_SIZE || "1000", 10);
-  const maxOutputSize = parseInt(process.env.CVM_MAX_OUTPUT_SIZE || "1048576", 10);
-  return {
-    storage: {
-      type: storageType,
-      mongoUri,
-      dataDir
-    },
-    logging: {
-      level: logLevel
-    },
-    execution: {
-      maxExecutionTime,
-      maxStackSize,
-      maxOutputSize
-    },
-    env
-  };
-}
-const LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-class Logger {
-  levelValue;
-  constructor(level) {
-    this.levelValue = LOG_LEVELS[level];
-  }
-  log(level, message, ...args) {
-    if (LOG_LEVELS[level] >= this.levelValue) {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
-      if (args.length > 0) {
-        console.error(prefix, message, ...args);
-      } else {
-        console.error(prefix, message);
-      }
-    }
-  }
-  debug(message, ...args) {
-    this.log("debug", message, ...args);
-  }
-  info(message, ...args) {
-    this.log("info", message, ...args);
-  }
-  warn(message, ...args) {
-    this.log("warn", message, ...args);
-  }
-  error(message, ...args) {
-    this.log("error", message, ...args);
-  }
-}
-let logger;
-function initLogger(level) {
-  logger = new Logger(level);
-  return logger;
-}
-function getLogger() {
-  if (!logger) {
-    throw new Error("Logger not initialized. Call initLogger() first.");
-  }
-  return logger;
-}
-async function main() {
-  let cvmServer;
-  try {
-    const config = loadConfig();
-    initLogger(config.logging.level);
-    const logger2 = getLogger();
-    logger2.info("Starting CVM Server...", {
-      env: config.env,
-      logLevel: config.logging.level
-    });
-    if (config.storage.type === "file") {
-      const dataDir = config.storage.dataDir || ".cvm";
-      const fullPath = s.resolve(process.cwd(), dataDir);
-      logger2.info(`[CVM] Initializing file storage in: ${fullPath}`);
-      logger2.warn(`[CVM] ⚠️  Remember to add '${dataDir}/' to your .gitignore file!`);
-    } else {
-      logger2.info("[CVM] Using MongoDB storage");
-    }
-    cvmServer = new f();
-    await cvmServer.start();
-    logger2.info("CVM Server is running and ready to accept MCP connections");
-    process.on("SIGINT", async () => {
-      logger2.info("Received SIGINT, shutting down gracefully...");
-      await shutdown();
-    });
-    process.on("SIGTERM", async () => {
-      logger2.info("Received SIGTERM, shutting down gracefully...");
-      await shutdown();
-    });
-  } catch (error) {
-    console.error("Fatal error starting CVM Server:", error);
-    process.exit(1);
-  }
-  async function shutdown() {
-    const logger2 = getLogger();
-    try {
-      logger2.info("Closing connections...");
-      if (cvmServer) {
-        await cvmServer.stop();
-      }
-      logger2.info("Shutdown complete");
-      process.exit(0);
-    } catch (error) {
-      logger2.error("Error during shutdown:", error);
-      process.exit(1);
-    }
-  }
-}
-main().catch((error) => {
-  console.error("Unhandled error:", error);
-  process.exit(1);
-});