@jay-framework/editor-server 0.6.0

package/dist/index.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const socket_io = require("socket.io");
+const http = require("http");
+const getPort = require("get-port");
+const editorProtocol = require("@jay-framework/editor-protocol");
+class EditorServer {
+  constructor(options) {
+    __publicField(this, "io", null);
+    __publicField(this, "httpServer", null);
+    __publicField(this, "port", null);
+    __publicField(this, "editorId", null);
+    __publicField(this, "portRange");
+    __publicField(this, "onEditorId");
+    __publicField(this, "handlers", {});
+    this.portRange = options.portRange || [3101, 3200];
+    this.onEditorId = options.onEditorId;
+    this.editorId = options.editorId || null;
+  }
+  async start() {
+    this.port = await getPort({ port: this.portRange });
+    this.httpServer = http.createServer((req, res) => {
+      if (req.url?.startsWith("/editor-connect")) {
+        this.handlePortDiscovery(req, res);
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    });
+    this.io = new socket_io.Server(this.httpServer, {
+      cors: {
+        origin: "*",
+        methods: ["GET", "POST"]
+      }
+    });
+    this.setupSocketHandlers();
+    return new Promise((resolve, reject) => {
+      this.httpServer.listen(this.port, () => {
+        console.log(`Editor server started on port ${this.port}`);
+        resolve({ port: this.port, editorId: this.editorId || "init" });
+      });
+      this.httpServer.on("error", reject);
+    });
+  }
+  async stop() {
+    if (this.io) {
+      this.io.close();
+    }
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+  }
+  // DevServerProtocol implementation
+  onPublish(callback) {
+    this.handlers.publish = callback;
+  }
+  onSaveImage(callback) {
+    this.handlers.saveImage = callback;
+  }
+  onHasImage(callback) {
+    this.handlers.hasImage = callback;
+  }
+  handlePortDiscovery(req, res) {
+    const url = new URL(req.url, `http://localhost:${this.port}`);
+    const tabId = url.searchParams.get("id");
+    if (!tabId) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing tab ID" }));
+      return;
+    }
+    if (!this.editorId) {
+      this.editorId = tabId;
+      this.onEditorId && this.onEditorId(tabId);
+    }
+    const response = {
+      status: this.editorId === tabId ? "configured" : "init",
+      id: this.editorId,
+      port: this.port
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(response));
+  }
+  setupSocketHandlers() {
+    if (!this.io)
+      return;
+    this.io.on("connection", (socket) => {
+      console.log(`Editor connected: ${socket.id}`);
+      socket.on("protocol-message", async (message) => {
+        try {
+          const response = await this.handleProtocolMessage(message);
+          socket.emit("protocol-response", response);
+        } catch (error) {
+          const errorPayload = {
+            type: message.payload.type,
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+          const errorResponse = editorProtocol.createProtocolResponse(message.id, errorPayload);
+          socket.emit("protocol-response", errorResponse);
+        }
+      });
+      socket.on("disconnect", () => {
+        console.log(`Editor disconnected: ${socket.id}`);
+      });
+    });
+  }
+  async handleProtocolMessage(message) {
+    const { id, payload } = message;
+    switch (payload.type) {
+      case "publish":
+        if (!this.handlers.publish) {
+          throw new Error("Publish handler not registered");
+        }
+        const publishResult = await this.handlers.publish(payload);
+        return editorProtocol.createProtocolResponse(id, publishResult);
+      case "saveImage":
+        if (!this.handlers.saveImage) {
+          throw new Error("Save image handler not registered");
+        }
+        const saveResult = await this.handlers.saveImage(payload);
+        return editorProtocol.createProtocolResponse(id, saveResult);
+      case "hasImage":
+        if (!this.handlers.hasImage) {
+          throw new Error("Has image handler not registered");
+        }
+        const hasResult = await this.handlers.hasImage(payload);
+        return editorProtocol.createProtocolResponse(id, hasResult);
+      default:
+        throw new Error(`Unknown message type: ${payload.type}`);
+    }
+  }
+}
+function createEditorServer(options) {
+  return new EditorServer(options);
+}
+exports.EditorServer = EditorServer;
+exports.createEditorServer = createEditorServer;

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { DevServerProtocol, PublishMessage, PublishResponse, SaveImageMessage, SaveImageResponse, HasImageMessage, HasImageResponse } from '@jay-framework/editor-protocol';
+
+interface EditorServerOptions {
+    editorId?: string;
+    onEditorId?: (editorId: string) => void;
+    portRange?: [number, number];
+}
+declare class EditorServer implements DevServerProtocol {
+    private io;
+    private httpServer;
+    private port;
+    private editorId;
+    private portRange;
+    private onEditorId;
+    private handlers;
+    constructor(options: EditorServerOptions);
+    start(): Promise<{
+        port: number;
+        editorId: string;
+    }>;
+    stop(): Promise<void>;
+    onPublish(callback: (params: PublishMessage) => Promise<PublishResponse>): void;
+    onSaveImage(callback: (params: SaveImageMessage) => Promise<SaveImageResponse>): void;
+    onHasImage(callback: (params: HasImageMessage) => Promise<HasImageResponse>): void;
+    private handlePortDiscovery;
+    private setupSocketHandlers;
+    private handleProtocolMessage;
+}
+declare function createEditorServer(options: EditorServerOptions): EditorServer;
+
+export { EditorServer, type EditorServerOptions, createEditorServer };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@jay-framework/editor-server",
+  "version": "0.6.0",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "dist/index.cjs",
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "scripts": {
+    "build": "npm run build:js && npm run build:types",
+    "build:watch": "npm run build:js -- --watch & npm run build:types -- --watch",
+    "build:js": "vite build",
+    "build:types": "tsup lib/index.ts --dts-only --format esm",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run build:check-types && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@jay-framework/editor-protocol": "^0.6.0",
+    "get-port": "^7.0.0",
+    "socket.io": "^4.7.4",
+    "uuid": "^9.0.1",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "@jay-framework/dev-environment": "^0.6.0",
+    "@jay-framework/editor-client": "^0.6.0",
+    "@jay-framework/jay-cli": "^0.6.0",
+    "@types/express": "^5.0.2",
+    "@types/node": "^22.15.21",
+    "@types/uuid": "^9.0.7",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.1"
+  }
+}

package/readme.md

@@ -0,0 +1,71 @@
+# @jay-framework/editor-server
+
+Socket.io server implementation for Jay dev servers to handle editor integration.
+
+## Overview
+
+This package provides a Socket.io server that can be integrated into Jay dev servers to handle real-time communication with editor applications. It includes:
+
+- Port discovery and automatic port allocation
+- Socket.io server setup with CORS support
+- Protocol message handling for publish, saveImage, and hasImage operations
+- Default protocol handlers for file operations
+- Configuration management via `.jay` files
+- Memory filesystem support for testing
+
+## Usage
+
+```typescript
+import { createEditorServer, createDefaultHandlers } from '@jay-framework/editor-server';
+
+// Create the editor server
+const server = createEditorServer({
+  projectRoot: '/path/to/project',
+  portRange: [3101, 3200],
+});
+
+const handlePublish: EditorProtocol['publish'] = () => {}; // callback implementation
+const handleSaveImage: EditorProtocol['saveImage'] = () => {}; // callback implementation
+const handleHasImage: EditorProtocol['hasImage'] = () => {}; // callback implementation
+
+// Register protocol handlers
+server.onPublish(handlePublish);
+server.onSaveImage(handleSaveImage);
+server.onHasImage(handleHasImage);
+
+// Start the server
+const { port, editorId } = await server.start();
+console.log(`Editor server running on port ${port} with ID ${editorId}`);
+
+// Stop the server when done
+await server.stop();
+```
+
+## Features
+
+### Port Discovery
+
+- Automatically finds available ports in the configured range
+- Provides HTTP endpoint for editor port discovery
+- Supports both "init" mode and "configured" mode
+
+### Protocol Support
+
+- **Publish**: Saves jay-html files to the project
+- **Save Image**: Saves base64 image data to assets directory
+- **Has Image**: Checks if an image already exists
+
+### Protocol Message Structure
+
+All messages use a wrapper structure with `id`, `timestamp`, and `payload` fields for reliable communication.
+
+### Configuration
+
+- optional `editorId` config
+  - if omitted, starts with `init` mode supporting discovery of `editorId` and callback `onEditorId` to save `editorId`
+  - if provided, only accepts connection with the same `editorId`
+- Supports custom port ranges
+
+## Integration with Dev Server
+
+This package is designed to be integrated into the existing `@jay-framework/dev-server` package to provide editor integration capabilities.