@xnetjs/plugins 0.0.2

package/dist/services/node.js

@@ -0,0 +1,1055 @@
+// src/services/local-api.ts
+import { timingSafeEqual } from "crypto";
+import { createServer } from "http";
+import { URL } from "url";
+function constantTimeCompare(a, b) {
+  if (a.length !== b.length) return false;
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return timingSafeEqual(bufA, bufB);
+}
+var EventBuffer = class {
+  events = [];
+  maxEvents;
+  constructor(maxEvents = 1e3) {
+    this.maxEvents = maxEvents;
+  }
+  push(event) {
+    this.events.push(event);
+    if (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+  }
+  getSince(timestamp, schemaId) {
+    return this.events.filter((e) => {
+      if (e.timestamp <= timestamp) return false;
+      if (schemaId && e.node?.schemaId !== schemaId) return false;
+      return true;
+    });
+  }
+};
+var LocalAPIServer = class {
+  server = null;
+  config;
+  eventBuffer;
+  unsubscribe;
+  constructor(config) {
+    this.config = {
+      port: config.port ?? 31415,
+      host: config.host ?? "127.0.0.1",
+      token: config.token,
+      allowedOrigins: config.allowedOrigins ?? [],
+      store: config.store,
+      schemas: config.schemas
+    };
+    this.eventBuffer = new EventBuffer();
+  }
+  /**
+   * Start the API server
+   */
+  async start() {
+    if (this.server) {
+      throw new Error("Server already running");
+    }
+    this.unsubscribe = this.config.store.subscribe((event) => {
+      const type = this.getEventType(event.change.type);
+      if (type) {
+        this.eventBuffer.push({
+          type,
+          node: event.node,
+          timestamp: Date.now()
+        });
+      }
+    });
+    this.server = createServer((req, res) => {
+      this.handleRequest(req, res).catch((err) => {
+        console.error("[LocalAPI] Request error:", err);
+        this.sendError(res, 500, "Internal server error");
+      });
+    });
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.config.port, this.config.host, () => {
+        console.log(`[LocalAPI] Server listening on http://${this.config.host}:${this.config.port}`);
+        resolve();
+      });
+      this.server.on("error", reject);
+    });
+  }
+  /**
+   * Stop the API server
+   */
+  async stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = void 0;
+    }
+    if (!this.server) return;
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        console.log("[LocalAPI] Server stopped");
+        this.server = null;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Get the server port
+   */
+  get port() {
+    return this.config.port;
+  }
+  /**
+   * Check if server is running
+   */
+  get isRunning() {
+    return this.server !== null;
+  }
+  // ─── Request Handling ────────────────────────────────────────────────────────
+  async handleRequest(req, res) {
+    const origin = req.headers.origin;
+    if (this.config.allowedOrigins.length > 0 && origin) {
+      const isAllowed = this.config.allowedOrigins.includes("*") || this.config.allowedOrigins.includes(origin);
+      if (isAllowed) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+        res.setHeader("Access-Control-Allow-Credentials", "true");
+      }
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (this.config.token) {
+      const auth = req.headers.authorization;
+      const expected = `Bearer ${this.config.token}`;
+      if (!auth || !constantTimeCompare(auth, expected)) {
+        this.sendError(res, 401, "Unauthorized");
+        return;
+      }
+    }
+    const url = new URL(req.url ?? "/", `http://${this.config.host}:${this.config.port}`);
+    const pathname = url.pathname;
+    const method = req.method ?? "GET";
+    try {
+      if (pathname === "/health" && method === "GET") {
+        return this.handleHealth(res);
+      }
+      if (pathname.startsWith("/api/v1/")) {
+        const path = pathname.slice("/api/v1".length);
+        if (path === "/nodes" && method === "GET") {
+          return await this.handleListNodes(url, res);
+        }
+        if (path === "/nodes" && method === "POST") {
+          return await this.handleCreateNode(req, res);
+        }
+        if (path.match(/^\/nodes\/[^/]+$/) && method === "GET") {
+          const id = path.slice("/nodes/".length);
+          return await this.handleGetNode(id, res);
+        }
+        if (path.match(/^\/nodes\/[^/]+$/) && method === "PATCH") {
+          const id = path.slice("/nodes/".length);
+          return await this.handleUpdateNode(id, req, res);
+        }
+        if (path.match(/^\/nodes\/[^/]+$/) && method === "DELETE") {
+          const id = path.slice("/nodes/".length);
+          return await this.handleDeleteNode(id, res);
+        }
+        if (path === "/query" && method === "POST") {
+          return await this.handleQuery(req, res);
+        }
+        if (path === "/events" && method === "GET") {
+          return this.handleGetEvents(url, res);
+        }
+        if (path === "/schemas" && method === "GET") {
+          return await this.handleListSchemas(res);
+        }
+        if (path.match(/^\/schemas\//) && method === "GET") {
+          const iri = decodeURIComponent(path.slice("/schemas/".length));
+          return await this.handleGetSchema(iri, res);
+        }
+      }
+      this.sendError(res, 404, "Not found");
+    } catch (err) {
+      console.error("[LocalAPI] Handler error:", err);
+      this.sendError(res, 500, err instanceof Error ? err.message : "Internal server error");
+    }
+  }
+  // ─── Health ──────────────────────────────────────────────────────────────────
+  handleHealth(res) {
+    this.sendJSON(res, 200, {
+      status: "ok",
+      version: "1.0.0",
+      timestamp: Date.now()
+    });
+  }
+  // ─── Nodes ───────────────────────────────────────────────────────────────────
+  async handleListNodes(url, res) {
+    const schemaId = url.searchParams.get("schema") ?? void 0;
+    const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+    const offset = parseInt(url.searchParams.get("offset") ?? "0", 10);
+    const nodes = await this.config.store.list({ schemaId, limit, offset });
+    this.sendJSON(res, 200, { nodes, count: nodes.length, limit, offset });
+  }
+  async handleGetNode(id, res) {
+    const node = await this.config.store.get(id);
+    if (!node) {
+      this.sendError(res, 404, `Node not found: ${id}`);
+      return;
+    }
+    this.sendJSON(res, 200, node);
+  }
+  async handleCreateNode(req, res) {
+    const body = await this.parseBody(req);
+    if (!body.schema || typeof body.schema !== "string") {
+      this.sendError(res, 400, "Missing required field: schema");
+      return;
+    }
+    if (!body.properties || typeof body.properties !== "object") {
+      this.sendError(res, 400, "Missing required field: properties");
+      return;
+    }
+    const node = await this.config.store.create({
+      schemaId: body.schema,
+      properties: body.properties
+    });
+    this.sendJSON(res, 201, node);
+  }
+  async handleUpdateNode(id, req, res) {
+    const existing = await this.config.store.get(id);
+    if (!existing) {
+      this.sendError(res, 404, `Node not found: ${id}`);
+      return;
+    }
+    const body = await this.parseBody(req);
+    if (!body || typeof body !== "object") {
+      this.sendError(res, 400, "Request body must be an object");
+      return;
+    }
+    const node = await this.config.store.update(id, {
+      properties: body
+    });
+    this.sendJSON(res, 200, node);
+  }
+  async handleDeleteNode(id, res) {
+    const existing = await this.config.store.get(id);
+    if (!existing) {
+      this.sendError(res, 404, `Node not found: ${id}`);
+      return;
+    }
+    await this.config.store.delete(id);
+    this.sendJSON(res, 200, { success: true });
+  }
+  // ─── Query ───────────────────────────────────────────────────────────────────
+  async handleQuery(req, res) {
+    const body = await this.parseBody(req);
+    if (!body.schema || typeof body.schema !== "string") {
+      this.sendError(res, 400, "Missing required field: schema");
+      return;
+    }
+    const limit = typeof body.limit === "number" ? body.limit : 50;
+    const offset = typeof body.offset === "number" ? body.offset : 0;
+    const nodes = await this.config.store.list({
+      schemaId: body.schema,
+      limit,
+      offset
+    });
+    this.sendJSON(res, 200, { nodes, count: nodes.length });
+  }
+  // ─── Events ──────────────────────────────────────────────────────────────────
+  handleGetEvents(url, res) {
+    const since = parseInt(url.searchParams.get("since") ?? "0", 10);
+    const schemaId = url.searchParams.get("schema") ?? void 0;
+    const events = this.eventBuffer.getSince(since, schemaId);
+    this.sendJSON(res, 200, {
+      events,
+      timestamp: Date.now()
+    });
+  }
+  // ─── Schemas ─────────────────────────────────────────────────────────────────
+  async handleListSchemas(res) {
+    const iris = this.config.schemas.getAllIRIs();
+    const schemas = await Promise.all(
+      iris.map(async (iri) => {
+        const schema = await this.config.schemas.get(iri);
+        return schema ? {
+          iri,
+          name: schema.name,
+          properties: schema.properties
+        } : null;
+      })
+    );
+    this.sendJSON(res, 200, {
+      schemas: schemas.filter(Boolean)
+    });
+  }
+  async handleGetSchema(iri, res) {
+    const schema = await this.config.schemas.get(iri);
+    if (!schema) {
+      this.sendError(res, 404, `Schema not found: ${iri}`);
+      return;
+    }
+    this.sendJSON(res, 200, schema);
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────────
+  async parseBody(req) {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", () => {
+        try {
+          const parsed = body ? JSON.parse(body) : {};
+          resolve(parsed);
+        } catch {
+          reject(new Error("Invalid JSON body"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  sendJSON(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  }
+  sendError(res, status, message) {
+    this.sendJSON(res, status, { error: message });
+  }
+  getEventType(changeType) {
+    if (changeType === "node-change") {
+      return "updated";
+    }
+    return null;
+  }
+};
+function createLocalAPI(config) {
+  return new LocalAPIServer(config);
+}
+
+// src/services/mcp-server.ts
+var MCPServer = class {
+  config;
+  tools = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(config) {
+    this.config = {
+      store: config.store,
+      schemas: config.schemas,
+      name: config.name ?? "xnet",
+      version: config.version ?? "1.0.0"
+    };
+    this.registerTools();
+  }
+  /**
+   * Get server info for MCP initialize response
+   */
+  getServerInfo() {
+    return {
+      name: this.config.name,
+      version: this.config.version
+    };
+  }
+  /**
+   * Get server capabilities
+   */
+  getCapabilities() {
+    return {
+      tools: {},
+      resources: {}
+    };
+  }
+  /**
+   * Get all registered tools
+   */
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Get available resources
+   */
+  getResources() {
+    return [
+      {
+        uri: "xnet://nodes",
+        name: "All Nodes",
+        description: "List of all nodes in the local store",
+        mimeType: "application/json"
+      },
+      {
+        uri: "xnet://schemas",
+        name: "All Schemas",
+        description: "List of all available schemas",
+        mimeType: "application/json"
+      }
+    ];
+  }
+  /**
+   * Handle an MCP request
+   */
+  async handleRequest(request) {
+    const { id, method, params } = request;
+    try {
+      let result;
+      switch (method) {
+        case "initialize":
+          result = {
+            protocolVersion: "2024-11-05",
+            serverInfo: this.getServerInfo(),
+            capabilities: this.getCapabilities()
+          };
+          break;
+        case "tools/list":
+          result = { tools: this.getTools() };
+          break;
+        case "tools/call":
+          result = await this.handleToolCall(params);
+          break;
+        case "resources/list":
+          result = { resources: this.getResources() };
+          break;
+        case "resources/read":
+          result = await this.handleResourceRead(params);
+          break;
+        case "notifications/initialized":
+          result = {};
+          break;
+        default:
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Method not found: ${method}` }
+          };
+      }
+      return { jsonrpc: "2.0", id, result };
+    } catch (err) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: -32e3,
+          message: err instanceof Error ? err.message : "Unknown error"
+        }
+      };
+    }
+  }
+  /**
+   * Start the MCP server in stdio mode.
+   * Reads JSON-RPC requests from stdin and writes responses to stdout.
+   */
+  async startStdio() {
+    if (this.running) {
+      throw new Error("Server already running");
+    }
+    this.running = true;
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    for await (const line of rl) {
+      if (!this.running) break;
+      try {
+        const request = JSON.parse(line);
+        const response = await this.handleRequest(request);
+        console.log(JSON.stringify(response));
+      } catch {
+        console.log(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: -32700, message: "Parse error" }
+          })
+        );
+      }
+    }
+  }
+  /**
+   * Stop the stdio server
+   */
+  stop() {
+    this.running = false;
+  }
+  // ─── Tool Registration ─────────────────────────────────────────────────────
+  registerTools() {
+    this.tools.set("xnet_query", {
+      name: "xnet_query",
+      description: "Query nodes by schema and optional filter. Returns matching nodes with their properties.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          schema: {
+            type: "string",
+            description: "Schema IRI to query (e.g., xnet://xnet.dev/Task)"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of results to return (default: 20)"
+          },
+          offset: {
+            type: "number",
+            description: "Number of results to skip for pagination"
+          }
+        },
+        required: ["schema"]
+      }
+    });
+    this.tools.set("xnet_get", {
+      name: "xnet_get",
+      description: "Get a single node by its ID.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          nodeId: {
+            type: "string",
+            description: "The unique ID of the node to retrieve"
+          }
+        },
+        required: ["nodeId"]
+      }
+    });
+    this.tools.set("xnet_create", {
+      name: "xnet_create",
+      description: "Create a new node with the given schema and properties.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          schema: {
+            type: "string",
+            description: "Schema IRI for the new node"
+          },
+          properties: {
+            type: "object",
+            description: "Initial property values for the node"
+          }
+        },
+        required: ["schema", "properties"]
+      }
+    });
+    this.tools.set("xnet_update", {
+      name: "xnet_update",
+      description: "Update properties of an existing node.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          nodeId: {
+            type: "string",
+            description: "ID of the node to update"
+          },
+          properties: {
+            type: "object",
+            description: "Properties to update (only specified properties will change)"
+          }
+        },
+        required: ["nodeId", "properties"]
+      }
+    });
+    this.tools.set("xnet_delete", {
+      name: "xnet_delete",
+      description: "Delete a node by its ID.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          nodeId: {
+            type: "string",
+            description: "ID of the node to delete"
+          }
+        },
+        required: ["nodeId"]
+      }
+    });
+    this.tools.set("xnet_schemas", {
+      name: "xnet_schemas",
+      description: "List all available schemas with their properties. Useful for understanding what types of nodes can be created.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    });
+  }
+  // ─── Tool Execution ────────────────────────────────────────────────────────
+  async handleToolCall(params) {
+    const { name, arguments: args } = params;
+    const toolArgs = args ?? {};
+    let result;
+    switch (name) {
+      case "xnet_query": {
+        const schemaId = toolArgs.schema;
+        const limit = toolArgs.limit ?? 20;
+        const offset = toolArgs.offset ?? 0;
+        const nodes = await this.config.store.list({ schemaId, limit, offset });
+        result = { nodes, count: nodes.length };
+        break;
+      }
+      case "xnet_get": {
+        const nodeId = toolArgs.nodeId;
+        const node = await this.config.store.get(nodeId);
+        if (!node) {
+          throw new Error(`Node not found: ${nodeId}`);
+        }
+        result = node;
+        break;
+      }
+      case "xnet_create": {
+        const schema = toolArgs.schema;
+        const properties = toolArgs.properties;
+        const node = await this.config.store.create({
+          schemaId: schema,
+          properties
+        });
+        result = node;
+        break;
+      }
+      case "xnet_update": {
+        const nodeId = toolArgs.nodeId;
+        const properties = toolArgs.properties;
+        const existing = await this.config.store.get(nodeId);
+        if (!existing) {
+          throw new Error(`Node not found: ${nodeId}`);
+        }
+        const node = await this.config.store.update(nodeId, { properties });
+        result = node;
+        break;
+      }
+      case "xnet_delete": {
+        const nodeId = toolArgs.nodeId;
+        const existing = await this.config.store.get(nodeId);
+        if (!existing) {
+          throw new Error(`Node not found: ${nodeId}`);
+        }
+        await this.config.store.delete(nodeId);
+        result = { success: true, nodeId };
+        break;
+      }
+      case "xnet_schemas": {
+        const iris = this.config.schemas.getAllIRIs();
+        const schemas = await Promise.all(
+          iris.map(async (iri) => {
+            const schema = await this.config.schemas.get(iri);
+            return schema ? {
+              iri,
+              name: schema.name,
+              properties: schema.properties
+            } : null;
+          })
+        );
+        result = { schemas: schemas.filter(Boolean) };
+        break;
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  }
+  // ─── Resource Handling ─────────────────────────────────────────────────────
+  async handleResourceRead(params) {
+    const { uri } = params;
+    let content;
+    if (uri === "xnet://nodes") {
+      const nodes = await this.config.store.list({ limit: 100 });
+      content = { nodes, count: nodes.length };
+    } else if (uri === "xnet://schemas") {
+      const iris = this.config.schemas.getAllIRIs();
+      const schemas = await Promise.all(
+        iris.map(async (iri) => {
+          const schema = await this.config.schemas.get(iri);
+          return schema ? { iri, name: schema.name } : null;
+        })
+      );
+      content = { schemas: schemas.filter(Boolean) };
+    } else {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(content, null, 2)
+        }
+      ]
+    };
+  }
+};
+function createMCPServer(config) {
+  return new MCPServer(config);
+}
+
+// src/services/process-manager.ts
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+}
+var ManagedProcess = class {
+  constructor(definition) {
+    this.definition = definition;
+    this.status = {
+      id: definition.id,
+      state: "stopped",
+      restartCount: 0
+    };
+  }
+  process = null;
+  status;
+  restartTimer = null;
+  healthCheckTimer = null;
+  listeners = { status: [], output: [] };
+  /**
+   * Start the service process
+   */
+  async start() {
+    if (this.status.state === "running" || this.status.state === "starting") {
+      return this.status;
+    }
+    if (!isNodeEnvironment()) {
+      throw new Error("ProcessManager can only run in Node.js environment");
+    }
+    const { spawn } = await import("child_process");
+    this.updateState("starting");
+    const { command, args = [], cwd, env, shell } = this.definition.process;
+    const { protocol } = this.definition.communication;
+    try {
+      this.process = spawn(command, args, {
+        cwd,
+        env: { ...process.env, ...env },
+        shell: shell ?? false,
+        stdio: protocol === "stdio" ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"]
+      });
+      this.status.pid = this.process.pid;
+      this.process.stdout?.on("data", (data) => {
+        this.emitOutput("stdout", data.toString());
+      });
+      this.process.stderr?.on("data", (data) => {
+        this.emitOutput("stderr", data.toString());
+      });
+      this.process.on("exit", (code, signal) => {
+        this.handleExit(code, signal);
+      });
+      this.process.on("error", (err) => {
+        this.status.lastError = err.message;
+        this.updateState("error");
+      });
+      await this.waitForHealthy();
+      this.updateState("running");
+      this.status.startedAt = Date.now();
+      this.startHealthCheck();
+      return this.getStatus();
+    } catch (err) {
+      this.status.lastError = err instanceof Error ? err.message : String(err);
+      this.updateState("error");
+      throw err;
+    }
+  }
+  /**
+   * Stop the service process
+   */
+  async stop() {
+    if (this.status.state === "stopped" || this.status.state === "stopping") {
+      return;
+    }
+    this.updateState("stopping");
+    this.clearTimers();
+    if (!this.process) {
+      this.updateState("stopped");
+      return;
+    }
+    const shutdownTimeout = this.definition.lifecycle.shutdownTimeoutMs ?? 5e3;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.process?.kill("SIGKILL");
+        this.process = null;
+        this.updateState("stopped");
+        resolve();
+      }, shutdownTimeout);
+      this.process.on("exit", () => {
+        clearTimeout(timeout);
+        this.process = null;
+        this.updateState("stopped");
+        resolve();
+      });
+      this.process.kill("SIGTERM");
+    });
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    const status = { ...this.status };
+    if (status.state === "running" && status.startedAt) {
+      status.uptime = Date.now() - status.startedAt;
+    }
+    return status;
+  }
+  /**
+   * Subscribe to status changes
+   */
+  onStatus(callback) {
+    this.listeners.status.push(callback);
+    return () => {
+      const idx = this.listeners.status.indexOf(callback);
+      if (idx >= 0) this.listeners.status.splice(idx, 1);
+    };
+  }
+  /**
+   * Subscribe to output events
+   */
+  onOutput(callback) {
+    this.listeners.output.push(callback);
+    return () => {
+      const idx = this.listeners.output.indexOf(callback);
+      if (idx >= 0) this.listeners.output.splice(idx, 1);
+    };
+  }
+  // ─── Private Methods ─────────────────────────────────────────────────────────
+  updateState(state) {
+    const previousState = this.status.state;
+    this.status.state = state;
+    const event = {
+      serviceId: this.definition.id,
+      status: this.getStatus(),
+      previousState
+    };
+    for (const listener of this.listeners.status) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("[ManagedProcess] Status listener error:", err);
+      }
+    }
+  }
+  emitOutput(stream, data) {
+    const event = {
+      serviceId: this.definition.id,
+      stream,
+      data,
+      timestamp: Date.now()
+    };
+    for (const listener of this.listeners.output) {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error("[ManagedProcess] Output listener error:", err);
+      }
+    }
+  }
+  handleExit(code, signal) {
+    if (this.status.state === "stopping") {
+      return;
+    }
+    const { restart, maxRestarts = 5, restartDelayMs = 1e3 } = this.definition.lifecycle;
+    const shouldRestart = restart === "always" || restart === "on-failure" && code !== 0;
+    if (shouldRestart && this.status.restartCount < maxRestarts) {
+      this.status.restartCount++;
+      this.status.lastError = `Exited with code ${code}, signal ${signal}. Restarting...`;
+      this.updateState("starting");
+      this.restartTimer = setTimeout(() => {
+        this.start().catch((err) => {
+          console.error(`[ManagedProcess] Restart failed for ${this.definition.id}:`, err);
+        });
+      }, restartDelayMs);
+    } else {
+      this.status.lastError = `Exited with code ${code}, signal ${signal}`;
+      this.updateState("error");
+    }
+  }
+  async waitForHealthy() {
+    const { healthCheck, startTimeoutMs = 1e4 } = this.definition.lifecycle;
+    const start = Date.now();
+    while (Date.now() - start < startTimeoutMs) {
+      if (!healthCheck) {
+        await this.delay(500);
+        return;
+      }
+      const healthy = await this.checkHealth();
+      if (healthy) return;
+      await this.delay(500);
+    }
+    throw new Error(`Service '${this.definition.id}' health check timed out`);
+  }
+  async checkHealth() {
+    const { healthCheck } = this.definition.lifecycle;
+    if (!healthCheck) return true;
+    try {
+      switch (healthCheck.type) {
+        case "http": {
+          if (!healthCheck.url) return false;
+          const controller = new AbortController();
+          const timeout = setTimeout(() => controller.abort(), healthCheck.timeoutMs ?? 5e3);
+          try {
+            const res = await fetch(healthCheck.url, { signal: controller.signal });
+            return res.ok;
+          } finally {
+            clearTimeout(timeout);
+          }
+        }
+        case "tcp": {
+          const port = healthCheck.port ?? this.definition.communication.port;
+          if (!port) return false;
+          const { createConnection } = await import("net");
+          return new Promise((resolve) => {
+            const socket = createConnection(
+              { port, host: this.definition.communication.host ?? "127.0.0.1" },
+              () => {
+                socket.destroy();
+                resolve(true);
+              }
+            );
+            socket.on("error", () => resolve(false));
+            socket.setTimeout(healthCheck.timeoutMs ?? 5e3, () => {
+              socket.destroy();
+              resolve(false);
+            });
+          });
+        }
+        case "stdout": {
+          return this.process?.pid !== void 0;
+        }
+        default:
+          return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  startHealthCheck() {
+    const { healthCheck } = this.definition.lifecycle;
+    if (!healthCheck || !healthCheck.intervalMs) return;
+    this.healthCheckTimer = setInterval(async () => {
+      if (this.status.state !== "running") return;
+      const healthy = await this.checkHealth();
+      if (!healthy) {
+        this.status.lastError = "Health check failed";
+      }
+    }, healthCheck.intervalMs);
+  }
+  clearTimers() {
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  listeners = {
+    "service:status": [],
+    "service:output": [],
+    "service:error": []
+  };
+  /**
+   * Start a service
+   */
+  async start(definition) {
+    if (this.processes.has(definition.id)) {
+      throw new Error(`Service '${definition.id}' is already registered`);
+    }
+    const managed = new ManagedProcess(definition);
+    this.processes.set(definition.id, managed);
+    managed.onStatus((event) => {
+      this.emit("service:status", event);
+    });
+    managed.onOutput((event) => {
+      this.emit("service:output", event);
+    });
+    try {
+      return await managed.start();
+    } catch (err) {
+      this.emit("service:error", {
+        serviceId: definition.id,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+      throw err;
+    }
+  }
+  /**
+   * Stop a service
+   */
+  async stop(serviceId) {
+    const managed = this.processes.get(serviceId);
+    if (!managed) return;
+    await managed.stop();
+    this.processes.delete(serviceId);
+  }
+  /**
+   * Restart a service
+   */
+  async restart(serviceId) {
+    const managed = this.processes.get(serviceId);
+    if (!managed) {
+      throw new Error(`Service '${serviceId}' not found`);
+    }
+    await managed.stop();
+    return managed.start();
+  }
+  /**
+   * Get service status
+   */
+  getStatus(serviceId) {
+    return this.processes.get(serviceId)?.getStatus();
+  }
+  /**
+   * Get all service statuses
+   */
+  getAllStatuses() {
+    return [...this.processes.values()].map((p) => p.getStatus());
+  }
+  /**
+   * Stop all services
+   */
+  async stopAll() {
+    await Promise.all([...this.processes.keys()].map((id) => this.stop(id)));
+  }
+  /**
+   * Subscribe to events
+   */
+  on(event, listener) {
+    this.listeners[event].push(listener);
+  }
+  /**
+   * Unsubscribe from events
+   */
+  off(event, listener) {
+    const listeners = this.listeners[event];
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) listeners.splice(idx, 1);
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    for (const listener of listeners) {
+      try {
+        const fn = listener;
+        fn(...args);
+      } catch (err) {
+        console.error(`[ProcessManager] Event listener error for '${event}':`, err);
+      }
+    }
+  }
+};
+
+// src/services/client.ts
+var SERVICE_IPC_CHANNELS = {
+  START: "xnet:service:start",
+  STOP: "xnet:service:stop",
+  RESTART: "xnet:service:restart",
+  STATUS: "xnet:service:status",
+  LIST_ALL: "xnet:service:list-all",
+  CALL: "xnet:service:call",
+  STATUS_UPDATE: "xnet:service:status-update",
+  OUTPUT: "xnet:service:output"
+};
+export {
+  LocalAPIServer,
+  MCPServer,
+  ProcessManager,
+  SERVICE_IPC_CHANNELS,
+  createLocalAPI,
+  createMCPServer
+};