@jay-framework/jay-stack-cli 0.6.0 → 0.6.1

package/README.md

@@ -4,7 +4,7 @@ A command-line interface for running Jay stack applications in development mode.
 
 ## Overview
 
-The Jay Stack CLI provides a simple way to start a development server for Jay applications. It automatically configures and runs the Jay development server with sensible defaults, making it easy to get started with Jay stack development.
+The Jay Stack CLI provides a simple way to start both development and editor servers for Jay applications. It automatically configures and runs the Jay development server and editor server with sensible defaults, making it easy to get started with Jay stack development.
 
 ## Installation
 
@@ -22,30 +22,44 @@ Simply run the CLI from your project root:
 @jay-framework/@jay-framework/jay-cli
 ```
 
-This will start the development server with default configuration.
+This will start both the development server and editor server with default configuration.
 
-### Environment Variables
+### Configuration
 
-The CLI supports the following environment variables:
+The CLI uses a `.jay` configuration file (YAML format) to customize port ranges for both servers. Create a `.jay` file in your project root:
 
-- `PORT` - The port to run the server on (default: `5173`)
-- `BASE` - The base path for the server (default: `/`)
+```yaml
+devServer:
+  portRange: [3000, 3100]
+  pagesBase: './src/pages' # Directory containing your Jay pages
+  publicFolder: './public' # Directory for static files (CSS, JS, images, etc.)
+editorServer:
+  portRange: [3101, 3200]
+  # editorId will be automatically set when an editor connects
+```
 
-Example:
+If no `.jay` file is found, the CLI will use default values:
 
-```bash
-PORT=3000 BASE=/app @jay-framework/@jay-framework/jay-cli
-```
+- **Dev Server Port Range**: `3000-3100`
+- **Pages Directory**: `./src/pages`
+- **Public Folder**: `./public`
+- **Editor Server Port Range**: `3101-3200`
+
+The CLI automatically finds available ports within these ranges using the `get-port` package.
+
+**Note**: The `editorId` field in the configuration will be automatically updated when an editor connects to the server.
 
 ## Default Configuration
 
 The CLI uses the following default configuration:
 
 - **Pages Directory**: `./src/pages` - All Jay pages should be placed in this directory
+- **Public Folder**: `./public` - Static files (CSS, JS, images) are served from this directory
 - **TypeScript Config**: `./tsconfig.json` - Uses the project's TypeScript configuration
 - **Output Directory**: `build/@jay-framework/runtime` - Compiled Jay runtime files
-- **Server Port**: `5173` (or `PORT` environment variable)
-- **Base Path**: `/` (or `BASE` environment variable)
+- **Dev Server Port Range**: `3000-3100` - Automatically finds available port
+- **Editor Server Port Range**: `3101-3200` - Automatically finds available port
+- **Base Path**: `/`
 
 ## Project Structure
 
@@ -66,6 +80,10 @@ your-project/
 │           └── [slug]/             # parameterized segment
 │               ├── page.jay-html   # a page with url parameters
 │               ├── page.ts         # optional logic for the segment parameterized page
+├── public/                         # Static files (CSS, JS, images, etc.)
+│   ├── styles.css
+│   ├── script.js
+│   └── images/
 ├── tsconfig.json                   # TypeScript configuration
 └── package.json
 ```
@@ -76,6 +94,8 @@ The CLI is built using:
 
 - **Express.js** - HTTP server
 - **Jay Dev Server** - Core development server functionality
+- **Jay Editor Server** - Editor integration server
+- **get-port** - Automatic port discovery
 - **Vite** - Build tool integration
 
 ## Future Enhancements
@@ -91,6 +111,7 @@ The CLI is built using:
 ## Related Packages
 
 - `@jay-framework/dev-server` - Core development server functionality
+- `@jay-framework/editor-server` - Editor integration server
 - `@jay-framework/stack-client-runtime` - Client-side runtime
 - `@jay-framework/stack-server-runtime` - Server-side runtime
 - `@jay-framework/fullstack-component` - Full-stack component system

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import { PublishMessage, PublishResponse, SaveImageMessage, SaveImageResponse, HasImageMessage, HasImageResponse } from '@jay-framework/editor-protocol';
+
+interface JayConfig {
+    devServer?: {
+        portRange?: [number, number];
+        pagesBase?: string;
+        publicFolder?: string;
+    };
+    editorServer?: {
+        portRange?: [number, number];
+        editorId?: string;
+    };
+}
+declare function loadConfig(): JayConfig;
+declare function getConfigWithDefaults(config: JayConfig): Required<JayConfig>;
+declare function updateConfig(updates: Partial<JayConfig>): void;
+
+declare function createEditorHandlers(config: JayConfig): {
+    onPublish: (params: PublishMessage) => Promise<PublishResponse>;
+    onSaveImage: (params: SaveImageMessage) => Promise<SaveImageResponse>;
+    onHasImage: (params: HasImageMessage) => Promise<HasImageResponse>;
+};
+
+export { type JayConfig, createEditorHandlers, getConfigWithDefaults, loadConfig, updateConfig };

package/dist/index.js

@@ -1,28 +1,234 @@
 #!/usr/bin/env node
-"use strict";
-const express = require("express");
-const devServer = require("@jay-framework/dev-server");
-const path = require("path");
-const port = process.env.PORT || 5173;
-const base = process.env.BASE || "/";
+import express from "express";
+import { mkDevServer } from "@jay-framework/dev-server";
+import { createEditorServer } from "@jay-framework/editor-server";
+import getPort from "get-port";
+import path from "path";
+import fs from "fs";
+import YAML from "yaml";
+const DEFAULT_CONFIG = {
+  devServer: {
+    portRange: [3e3, 3100],
+    pagesBase: "./src/pages",
+    publicFolder: "./public"
+  },
+  editorServer: {
+    portRange: [3101, 3200]
+  }
+};
+function loadConfig() {
+  const configPath = path.resolve(".jay");
+  if (!fs.existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const configContent = fs.readFileSync(configPath, "utf-8");
+    const userConfig = YAML.parse(configContent);
+    return {
+      devServer: {
+        ...DEFAULT_CONFIG.devServer,
+        ...userConfig.devServer
+      },
+      editorServer: {
+        ...DEFAULT_CONFIG.editorServer,
+        ...userConfig.editorServer
+      }
+    };
+  } catch (error) {
+    console.warn("Failed to parse .jay YAML config file, using defaults:", error);
+    return DEFAULT_CONFIG;
+  }
+}
+function getConfigWithDefaults(config2) {
+  return {
+    devServer: {
+      portRange: config2.devServer?.portRange || DEFAULT_CONFIG.devServer.portRange,
+      pagesBase: config2.devServer?.pagesBase || DEFAULT_CONFIG.devServer.pagesBase,
+      publicFolder: config2.devServer?.publicFolder || DEFAULT_CONFIG.devServer.publicFolder
+    },
+    editorServer: {
+      portRange: config2.editorServer?.portRange || DEFAULT_CONFIG.editorServer.portRange,
+      editorId: config2.editorServer?.editorId
+    }
+  };
+}
+function updateConfig(updates) {
+  const configPath = path.resolve(".jay");
+  try {
+    const existingConfig = loadConfig();
+    const updatedConfig = {
+      ...existingConfig,
+      ...updates,
+      devServer: {
+        ...existingConfig.devServer,
+        ...updates.devServer
+      },
+      editorServer: {
+        ...existingConfig.editorServer,
+        ...updates.editorServer
+      }
+    };
+    const yamlContent = YAML.stringify(updatedConfig, { indent: 2 });
+    fs.writeFileSync(configPath, yamlContent);
+  } catch (error) {
+    console.warn("Failed to update .jay config file:", error);
+  }
+}
+function createEditorHandlers(config2) {
+  const resolvedConfig2 = getConfigWithDefaults(config2);
+  const onPublish = async (params) => {
+    const status = [];
+    for (const page of params.pages) {
+      try {
+        const pagesBasePath = path.resolve(resolvedConfig2.devServer.pagesBase);
+        const routePath = page.route === "/" ? "" : page.route;
+        const pageDir = path.join(pagesBasePath, routePath);
+        const pageFile = path.join(pageDir, "page.jay-html");
+        await fs.promises.mkdir(pageDir, { recursive: true });
+        await fs.promises.writeFile(pageFile, page.jayHtml, "utf-8");
+        console.log(`📝 Published page: ${pageFile}`);
+        status.push({
+          success: true,
+          filePath: pageFile
+        });
+      } catch (error) {
+        console.error(`Failed to publish page ${page.route}:`, error);
+        status.push({
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return {
+      type: "publish",
+      success: status.every((s) => s.success),
+      status
+    };
+  };
+  const onSaveImage = async (params) => {
+    try {
+      const imagesDir = path.join(
+        path.resolve(resolvedConfig2.devServer.publicFolder),
+        "images"
+      );
+      await fs.promises.mkdir(imagesDir, { recursive: true });
+      const filename = `${params.imageId}.png`;
+      const imagePath = path.join(imagesDir, filename);
+      await fs.promises.writeFile(imagePath, Buffer.from(params.imageData, "base64"));
+      console.log(`🖼️  Saved image: ${imagePath}`);
+      return {
+        type: "saveImage",
+        success: true,
+        imageUrl: `/images/${filename}`
+      };
+    } catch (error) {
+      console.error("Failed to save image:", error);
+      return {
+        type: "saveImage",
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  };
+  const onHasImage = async (params) => {
+    try {
+      const filename = `${params.imageId}.png`;
+      const imagePath = path.join(
+        path.resolve(resolvedConfig2.devServer.publicFolder),
+        "images",
+        filename
+      );
+      const exists = fs.existsSync(imagePath);
+      return {
+        type: "hasImage",
+        success: true,
+        exists,
+        imageUrl: exists ? `/images/${filename}` : void 0
+      };
+    } catch (error) {
+      console.error("Failed to check image:", error);
+      return {
+        type: "hasImage",
+        success: false,
+        exists: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  };
+  return {
+    onPublish,
+    onSaveImage,
+    onHasImage
+  };
+}
+const config = loadConfig();
+const resolvedConfig = getConfigWithDefaults(config);
 const jayOptions = {
   tsConfigFilePath: "./tsconfig.json",
   outputDir: "build/jay-runtime"
 };
 const app = express();
 async function initApp() {
-  const { server, viteServer, routes } = await devServer.mkDevServer({
-    pagesBase: path.resolve("./src/pages"),
-    serverBase: base,
+  const devServerPort = await getPort({ port: resolvedConfig.devServer.portRange });
+  const editorServer = createEditorServer({
+    portRange: resolvedConfig.editorServer.portRange,
+    editorId: resolvedConfig.editorServer.editorId,
+    onEditorId: (editorId2) => {
+      console.log(`Editor connected with ID: ${editorId2}`);
+      updateConfig({
+        editorServer: {
+          editorId: editorId2
+        }
+      });
+    }
+  });
+  const { port: editorPort, editorId } = await editorServer.start();
+  const handlers = createEditorHandlers(config);
+  editorServer.onPublish(handlers.onPublish);
+  editorServer.onSaveImage(handlers.onSaveImage);
+  editorServer.onHasImage(handlers.onHasImage);
+  const { server, viteServer, routes } = await mkDevServer({
+    pagesBase: path.resolve(resolvedConfig.devServer.pagesBase),
+    serverBase: "/",
     dontCacheSlowly: false,
     jayRollupConfig: jayOptions
   });
   app.use(server);
+  const publicPath = path.resolve(resolvedConfig.devServer.publicFolder);
+  if (fs.existsSync(publicPath)) {
+    app.use(express.static(publicPath));
+  } else {
+    console.log(`⚠️  Public folder not found: ${resolvedConfig.devServer.publicFolder}`);
+  }
   routes.forEach((route) => {
     app.get(route.path, route.handler);
   });
-  app.listen(port, () => {
-    console.log(`Server started at http://localhost:${port}`);
+  const expressServer = app.listen(devServerPort, () => {
+    console.log(`🚀 Jay Stack dev server started successfully!`);
+    console.log(`📱 Dev Server: http://localhost:${devServerPort}`);
+    console.log(`🎨 Editor Server: http://localhost:${editorPort} (ID: ${editorId})`);
+    console.log(`📁 Pages directory: ${resolvedConfig.devServer.pagesBase}`);
+    if (fs.existsSync(publicPath)) {
+      console.log(`📁 Public folder: ${resolvedConfig.devServer.publicFolder}`);
+    }
   });
+  const shutdown = async () => {
+    console.log("\n🛑 Shutting down servers...");
+    await editorServer.stop();
+    expressServer.closeAllConnections();
+    await new Promise((resolve) => expressServer.close(resolve));
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
 }
-initApp();
+initApp().catch((error) => {
+  console.error("Failed to start servers:", error);
+  process.exit(1);
+});
+export {
+  createEditorHandlers,
+  getConfigWithDefaults,
+  loadConfig,
+  updateConfig
+};

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jay-framework/jay-stack-cli",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "license": "Apache-2.0",
+  "type": "module",
   "main": "dist/index.js",
   "bin": "dist/index.js",
   "files": [
@@ -22,12 +23,13 @@
     "test:watch": ":"
   },
   "dependencies": {
-    "@jay-framework/dev-server": "^0.6.0",
+    "@jay-framework/dev-server": "^0.6.1",
+    "@jay-framework/editor-server": "^0.6.1",
     "express": "^5.0.1",
     "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.6.0",
+    "@jay-framework/dev-environment": "^0.6.1",
     "@types/express": "^5.0.2",
     "@types/node": "^22.15.21",
     "nodemon": "^3.0.3",

package/dist/index.d.mts

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