cvm-server 0.1.0

package/packages/vm/src/lib/vm-manager.js

@@ -0,0 +1,231 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vm_manager_exports = {};
+__export(vm_manager_exports, {
+  VMManager: () => VMManager
+});
+module.exports = __toCommonJS(vm_manager_exports);
+var import_vm = require("./vm.js");
+var import_parser = require("@cvm/parser");
+var import_storage = require("@cvm/storage");
+class VMManager {
+  vms = /* @__PURE__ */ new Map();
+  storage;
+  constructor(storageAdapter) {
+    if (storageAdapter) {
+      this.storage = storageAdapter;
+    } else {
+      this.storage = import_storage.StorageFactory.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(programId, source) {
+    const compileResult = (0, import_parser.compile)(source);
+    if (!compileResult.success) {
+      throw new Error(`Compilation failed: ${compileResult.errors.join(", ")}`);
+    }
+    const program = {
+      id: programId,
+      name: programId,
+      source,
+      bytecode: compileResult.bytecode,
+      // VM decides internal format
+      created: /* @__PURE__ */ new Date()
+    };
+    await this.storage.saveProgram(program);
+  }
+  /**
+   * Start execution of a loaded program
+   */
+  async startExecution(programId, executionId) {
+    const program = await this.storage.getProgram(programId);
+    if (!program) {
+      throw new Error(`Program not found: ${programId}`);
+    }
+    const execution = {
+      id: executionId,
+      programId,
+      state: "ready",
+      pc: 0,
+      stack: [],
+      variables: {},
+      output: [],
+      created: /* @__PURE__ */ new Date()
+    };
+    await this.storage.saveExecution(execution);
+    const vm = new import_vm.VM();
+    this.vms.set(executionId, vm);
+  }
+  /**
+   * Get next action from execution (Claude polls this)
+   * This is READ-ONLY - just returns current state
+   */
+  async getNext(executionId) {
+    const execution = await this.storage.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution not found: ${executionId}`);
+    }
+    if (execution.state === "ready") {
+      const program = await this.storage.getProgram(execution.programId);
+      if (!program) {
+        throw new Error(`Program not found: ${execution.programId}`);
+      }
+      let vm = this.vms.get(executionId);
+      if (!vm) {
+        vm = new import_vm.VM();
+        this.vms.set(executionId, vm);
+      }
+      const initialState = {
+        pc: 0,
+        stack: [],
+        variables: /* @__PURE__ */ new Map(),
+        output: []
+      };
+      const state = vm.execute(program.bytecode, initialState);
+      execution.pc = state.pc;
+      execution.stack = state.stack;
+      execution.variables = Object.fromEntries(state.variables);
+      execution.output = state.output;
+      if (state.status === "complete") {
+        execution.state = "completed";
+        await this.storage.saveExecution(execution);
+        this.vms.delete(executionId);
+        return {
+          type: "completed",
+          message: "Execution completed"
+        };
+      } else if (state.status === "waiting_cc") {
+        execution.state = "waiting_cc";
+        execution.ccPrompt = state.ccPrompt;
+        await this.storage.saveExecution(execution);
+        return {
+          type: "waiting",
+          message: state.ccPrompt || "Waiting for input"
+        };
+      } else if (state.status === "error") {
+        execution.state = "error";
+        execution.error = state.error;
+        await this.storage.saveExecution(execution);
+        this.vms.delete(executionId);
+        return {
+          type: "error",
+          error: state.error
+        };
+      }
+    }
+    if (execution.state === "completed") {
+      return {
+        type: "completed",
+        message: "Execution completed"
+      };
+    } else if (execution.state === "error") {
+      return {
+        type: "error",
+        error: execution.error || "Unknown error"
+      };
+    } else if (execution.state === "waiting_cc") {
+      return {
+        type: "waiting",
+        message: execution.ccPrompt || "Waiting for input"
+      };
+    }
+    throw new Error(`Unexpected execution state: ${execution.state}`);
+  }
+  /**
+   * Report result from cognitive operation and continue execution
+   */
+  async reportCCResult(executionId, result) {
+    const execution = await this.storage.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution not found: ${executionId}`);
+    }
+    const program = await this.storage.getProgram(execution.programId);
+    if (!program) {
+      throw new Error(`Program not found: ${execution.programId}`);
+    }
+    let vm = this.vms.get(executionId);
+    if (!vm) {
+      vm = new import_vm.VM();
+      this.vms.set(executionId, vm);
+    }
+    const currentState = {
+      pc: execution.pc,
+      stack: execution.stack,
+      variables: new Map(Object.entries(execution.variables)),
+      status: "waiting_cc",
+      output: execution.output,
+      ccPrompt: void 0
+    };
+    const newState = vm.resume(currentState, result, program.bytecode);
+    execution.pc = newState.pc;
+    execution.stack = newState.stack;
+    execution.variables = Object.fromEntries(newState.variables);
+    execution.output = newState.output;
+    if (newState.status === "complete") {
+      execution.state = "completed";
+      this.vms.delete(executionId);
+    } else if (newState.status === "error") {
+      execution.state = "error";
+      execution.error = newState.error;
+      this.vms.delete(executionId);
+    } else if (newState.status === "waiting_cc") {
+      execution.state = "waiting_cc";
+      execution.ccPrompt = newState.ccPrompt;
+    } else {
+      execution.state = "running";
+    }
+    await this.storage.saveExecution(execution);
+  }
+  /**
+   * Get current execution status
+   */
+  async getExecutionStatus(executionId) {
+    const execution = await this.storage.getExecution(executionId);
+    if (!execution) {
+      throw new Error(`Execution not found: ${executionId}`);
+    }
+    return {
+      id: execution.id,
+      state: execution.state,
+      pc: execution.pc,
+      stack: execution.stack,
+      variables: execution.variables,
+      output: execution.output
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VMManager
+});

package/packages/vm/src/lib/vm.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vm_exports = {};
+__export(vm_exports, {
+  VM: () => VM
+});
+module.exports = __toCommonJS(vm_exports);
+var import_parser = require("@cvm/parser");
+class VM {
+  execute(bytecode, initialState) {
+    const state = {
+      pc: initialState?.pc ?? 0,
+      stack: initialState?.stack ?? [],
+      variables: initialState?.variables ?? /* @__PURE__ */ new Map(),
+      status: "running",
+      output: initialState?.output ?? [],
+      ...initialState
+    };
+    while (state.status === "running" && state.pc < bytecode.length) {
+      const instruction = bytecode[state.pc];
+      switch (instruction.op) {
+        case import_parser.OpCode.HALT:
+          state.status = "complete";
+          break;
+        case import_parser.OpCode.PUSH:
+          state.stack.push(instruction.arg);
+          state.pc++;
+          break;
+        case import_parser.OpCode.POP:
+          state.stack.pop();
+          state.pc++;
+          break;
+        case import_parser.OpCode.LOAD:
+          state.stack.push(state.variables.get(instruction.arg) ?? "");
+          state.pc++;
+          break;
+        case import_parser.OpCode.STORE:
+          const value = state.stack.pop();
+          state.variables.set(instruction.arg, value);
+          state.pc++;
+          break;
+        case import_parser.OpCode.CONCAT:
+          const b = state.stack.pop();
+          const a = state.stack.pop();
+          state.stack.push(a + b);
+          state.pc++;
+          break;
+        case import_parser.OpCode.PRINT:
+          const printValue = state.stack.pop();
+          state.output.push(printValue);
+          state.pc++;
+          break;
+        case import_parser.OpCode.CC:
+          state.ccPrompt = state.stack.pop();
+          state.status = "waiting_cc";
+          break;
+        default:
+          state.status = "error";
+          state.error = `Unknown opcode: ${instruction.op}`;
+      }
+    }
+    return state;
+  }
+  resume(state, ccResult, bytecode) {
+    if (state.status !== "waiting_cc") {
+      throw new Error("Cannot resume: VM not waiting for CC");
+    }
+    const newState = {
+      ...state,
+      stack: [...state.stack, ccResult],
+      status: "running",
+      ccPrompt: void 0,
+      pc: state.pc + 1
+    };
+    return this.execute(bytecode, newState);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VM
+});