@ezetgalaxy/titan 26.9.1 → 26.9.3

package/templates/extension/node_modules/titanpl-sdk/README.md

@@ -0,0 +1,109 @@
+
+<div align="center">
+  <img src="./assets/titanpl-sdk.png" alt="Titan SDK Logo" width="120" />
+  <h1>Titan SDK</h1>
+  <p>
+    <b>The Developer Toolkit for Titan Planet. Type safety, IntelliSense, and Extension Testing.</b>
+  </p>
+</div>
+
+<div align="center">
+
+[![npm version](https://img.shields.io/npm/v/titanpl-sdk.svg?style=flat-square)](https://www.npmjs.com/package/titanpl-sdk)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg?style=flat-square)](https://opensource.org/licenses/ISC)
+
+</div>
+
+---
+
+## 🌌 Overview
+
+**Titan SDK** is NOT the runtime engine itself. It is a **development-only toolkit** designed to bridge the gap between your local coding environment and the native Titan Planet binary. 
+
+It provides the necessary **Type Definitions** to make your IDE understand the global `t` object and a **Lite Test Harness** to verify your extensions before they ever touch a production binary.
+
+> **Note:** The actual implementation of `t.log`, `t.fetch`, and other APIs are embedded directly into the [Titan Planet Binary](https://github.com/ezet-galaxy/titanpl). This SDK simply provides the "blueprints" (types) and a "sandbox" (test runner).
+
+---
+
+## ✨ Features
+
+- **💎 Blueprint Types (IntelliSense)**: Provides the full TypeScript `index.d.ts` for the global `t` object so you get autocomplete in VS Code and other editors.
+- **🛡️ Static Validation**: Catch parameter mismatches and typos in `t.log`, `t.fetch`, `t.db`, etc., during development.
+- **🔌 Extension Test Harness**: A "lite" version of the Titan runtime that simulates the native environment to test extensions in isolation.
+- **🚀 Zero Production Trace**: This is a `devDependencies` package. It never ships with your binary, keeping your production footprint at literal zero.
+
+---
+
+## 🚀 The Test Harness (Lite Runtime)
+
+The SDK includes a specialized **Test Runner** (`titan-sdk`). This is a "lite" version of the Titan ecosystem that acts as a bridge for developers.
+
+### How it works:
+When you run the SDK in an extension folder, it:
+1.  **Scaffolds a Virtual Project**: Creates a temporary, minimal Titan environment in `.titan_test_run`.
+2.  **Native Compilation**: Automatically builds your native Rust code (`native/`) if it exists.
+3.  **Hot-Linking**: Junctions your local extension into the virtual project's `node_modules`.
+4.  **Verification**: Generates a test suite that attempts to call your extension's methods via the real `t` object inside the sandbox.
+
+### Usage:
+
+```bash
+# Inside your extension directory
+npx titan-sdk
+```
+
+---
+
+## ⌨️ Enabling IntelliSense
+
+Since the `t` object is injected globally by the Titan engine at runtime, your IDE won't recognize it by default. The SDK fixes this.
+
+1.  **Install the SDK**:
+    ```bash
+    npm install --save-dev titan-sdk
+    ```
+
+2.  **Configure Types**:
+    Create or update `jsconfig.json` (or `tsconfig.json`) in your project root:
+    ```json
+    {
+      "compilerOptions": {
+        "types": ["titan-sdk"]
+      }
+    }
+    ```
+
+Now your editor will treat `t` as a first-class citizen:
+```js
+export function myAction(req) {
+  t.log.info("Request received", req.path); // Autocomplete works!
+  return { status: "ok" };
+}
+```
+
+---
+
+## 🧱 What's Included? (Types Only)
+
+The SDK provides types for the native APIs provided by the Titan Planet engine:
+
+- **`t.log`**: Standardized logging that appears in the Titan binary console.
+- **`t.fetch`**: Types for the high-performance Rust-native network stack.
+- **`t.db`**: Interface for the native PostgreSQL driver.
+- **`t.read`**: Definitions for optimized filesystem reads.
+- **`t.jwt` / `t.password`**: Security helper types.
+
+---
+
+## 🌍 Community & Documentation
+
+- **Core Framework**: [Titan Planet](https://github.com/ezet-galaxy/titanpl)
+- **Official Docs**: [Titan Planet Docs](https://titan-docs-ez.vercel.app/docs)
+- **Author**: [ezetgalaxy](https://github.com/ezet-galaxy)
+
+---
+
+<p align="center">
+  Built with ❤️ for the <a href="https://titan-docs-ez.vercel.app/">Titan Planet</a> ecosystem.
+</p>

package/templates/extension/node_modules/titanpl-sdk/bin/run.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Helper for colors
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+const red = (t) => `\x1b[31m${t}\x1b[0m`;
+const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+
+function copyDir(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const file of fs.readdirSync(src)) {
+        const srcPath = path.join(src, file);
+        const destPath = path.join(dest, file);
+        if (fs.lstatSync(srcPath).isDirectory()) {
+            copyDir(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+function run() {
+    console.log(cyan("Titan SDK: Test Runner"));
+
+    // 1. Validate we are in an extension directory
+    const cwd = process.cwd();
+    const manifestPath = path.join(cwd, "titan.json");
+    if (!fs.existsSync(manifestPath)) {
+        console.log(red("Error: titan.json not found. Run this command inside your extension folder."));
+        process.exit(1);
+    }
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const name = manifest.name;
+    console.log(green(`Extension: ${name}`));
+
+    // 2. Build Native Logic (if properly set up)
+    const nativeDir = path.join(cwd, "native");
+    if (fs.existsSync(nativeDir) && fs.existsSync(path.join(nativeDir, "Cargo.toml"))) {
+        console.log(cyan("Building native Rust module..."));
+        try {
+            execSync("cargo build --release", { cwd: nativeDir, stdio: "inherit" });
+        } catch (e) {
+            console.log(red("Failed to build native module."));
+            process.exit(1);
+        }
+    }
+
+    // 3. Setup Test Harness (Mini Titan Project)
+    const runDir = path.join(cwd, ".titan_test_run");
+    const isFirstRun = !fs.existsSync(runDir);
+
+    if (isFirstRun) {
+        console.log(cyan("Initializing test environment..."));
+        fs.mkdirSync(runDir, { recursive: true });
+
+        // Create app structure
+        const appDir = path.join(runDir, "app");
+        fs.mkdirSync(appDir);
+
+        // Create actions folder (required by Titan build)
+        const actionsDir = path.join(appDir, "actions");
+        fs.mkdirSync(actionsDir);
+
+        // Copy titan/ and server/ from templates
+        const templatesDir = path.join(__dirname, "..", "templates");
+
+        const titanSrc = path.join(templatesDir, "titan");
+        const titanDest = path.join(runDir, "titan");
+        if (fs.existsSync(titanSrc)) {
+            copyDir(titanSrc, titanDest);
+            // Double check titan.js exists
+            if (!fs.existsSync(path.join(titanDest, "titan.js"))) {
+                console.log(red(`Error: Failed to copy titan.js to ${titanDest}`));
+                process.exit(1);
+            }
+        } else {
+            console.log(red(`Error: Titan templates not found at ${titanSrc}`));
+            process.exit(1);
+        }
+
+        const serverSrc = path.join(templatesDir, "server");
+        const serverDest = path.join(runDir, "server");
+        if (fs.existsSync(serverSrc)) {
+            copyDir(serverSrc, serverDest);
+        } else {
+            console.log(red(`Error: Server templates not found at ${serverSrc}`));
+            process.exit(1);
+        }
+
+        // Create package.json for the test harness
+        const pkgJson = {
+            "type": "module"
+        };
+        fs.writeFileSync(path.join(runDir, "package.json"), JSON.stringify(pkgJson, null, 2));
+
+        // Create 'node_modules'
+        fs.mkdirSync(path.join(runDir, "node_modules"));
+    } else {
+        console.log(cyan("Using existing test environment..."));
+    }
+
+    // Always Ensure Extension Link is Fresh
+    const nmDir = path.join(runDir, "node_modules");
+    if (!fs.existsSync(nmDir)) fs.mkdirSync(nmDir, { recursive: true });
+
+    const extDest = path.join(nmDir, name);
+
+    // Remove old link/folder if exists to ensure freshness
+    if (fs.existsSync(extDest)) {
+        try {
+            fs.rmSync(extDest, { recursive: true, force: true });
+        } catch (e) { }
+    }
+
+    // Link current extension to node_modules/NAME
+    try {
+        // Use junction for Windows compat without admin rights
+        fs.symlinkSync(cwd, extDest, "junction");
+    } catch (e) {
+        // Fallback to copy if link fails
+        // console.log(yellow("Linking failed, copying extension files..."));
+        copyDir(cwd, extDest);
+    }
+
+    // Create default test files ONLY if they don't exist
+    const actionsDir = path.join(runDir, "app", "actions");
+    const testActionPath = path.join(actionsDir, "test.js");
+
+    if (!fs.existsSync(testActionPath)) {
+        const testAction = `export const test = (req) => {
+    const ext = t["${name}"];
+    
+    const results = {
+        extension: "${name}",
+        loaded: !!ext,
+        methods: ext ? Object.keys(ext) : [],
+        timestamp: new Date().toISOString()
+    };
+    
+    if (ext && ext.hello) {
+        try {
+            results.hello_test = ext.hello("World");
+        } catch(e) {
+            results.hello_error = String(e);
+        }
+    }
+    
+    if (ext && ext.calc) {
+        try {
+            results.calc_test = ext.calc(15, 25);
+        } catch(e) {
+            results.calc_error = String(e);
+        }
+    }
+    
+    return results;
+};
+`;
+        fs.writeFileSync(testActionPath, testAction);
+    }
+
+    const appJsPath = path.join(runDir, "app", "app.js");
+    if (!fs.existsSync(appJsPath)) {
+        const testScript = `import t from "../titan/titan.js";
+import "${name}";
+
+// Extension test harness for: ${name}
+const ext = t["${name}"];
+
+console.log("---------------------------------------------------");
+console.log("Testing Extension: ${name}");
+console.log("---------------------------------------------------");
+
+if (!ext) {
+    console.log("ERROR: Extension '${name}' not found in global 't'.");
+} else {
+    console.log("✓ Extension loaded successfully!");
+    console.log("✓ Available methods:", Object.keys(ext).join(", "));
+    
+    // Try 'hello' if it exists
+    if (typeof ext.hello === 'function') {
+        console.log("\\nTesting ext.hello('Titan')...");
+        try {
+           const res = ext.hello("Titan");
+           console.log("✓ Result:", res);
+        } catch(e) {
+           console.log("✗ Error:", e.message);
+        }
+    }
+
+    // Try 'calc' if it exists
+    if (typeof ext.calc === 'function') {
+        console.log("\\nTesting ext.calc(10, 20)...");
+        try {
+            const res = ext.calc(10, 20);
+            console.log("✓ Result:", res);
+        } catch(e) {
+            console.log("✗ Error:", e.message);
+        }
+    }
+}
+
+console.log("---------------------------------------------------");
+console.log("✓ Test complete!");
+console.log("\\n📍 Routes:");
+console.log("  GET  http://localhost:3000/      → Test harness info");
+console.log("  GET  http://localhost:3000/test  → Extension test results (JSON)");
+console.log("---------------------------------------------------\\n");
+
+// Create routes
+t.get("/test").action("test");
+t.get("/").reply("🚀 Extension Test Harness for ${name}\\n\\nVisit /test to see extension test results");
+
+await t.start(3000, "Titan Extension Test Running!");
+`;
+        fs.writeFileSync(appJsPath, testScript);
+    }
+
+    // Build the app (bundle actions)
+    console.log(cyan("Building test app..."));
+    try {
+        execSync("node app/app.js --build", {
+            cwd: runDir,
+            stdio: "inherit",
+            env: { ...process.env, NODE_OPTIONS: "--no-warnings" }
+        });
+    } catch (e) {
+        console.log(red("Failed to build test app. checking for runtime errors..."));
+    }
+
+    // 4. Run Titan Server using cargo run
+    console.log(green("\\x1b[1m\\n>>> STARTING EXTENSION TEST >>>\\n\\x1b[0m"));
+
+    const serverDir = path.join(runDir, "server");
+
+    try {
+        execSync("cargo run", { cwd: serverDir, stdio: "inherit" });
+    } catch (e) {
+        // console.log(red("Runtime exited."));
+    }
+}
+
+run();

package/templates/extension/node_modules/titanpl-sdk/index.d.ts

@@ -0,0 +1,46 @@
+export { };
+
+declare global {
+    /**
+     * Titan Runtime Global Object
+     */
+    const t: Titan.Runtime;
+}
+
+export namespace Titan {
+    interface Runtime {
+        /**
+         * Log messages to the Titan console
+         */
+        log: LogInterface;
+
+        /**
+         * Read file content
+         */
+        read(path: string): string;
+        
+        /**
+         * Fetch API wrapper
+         */
+        fetch(url: string, options?: any): Promise<any>;
+
+        /**
+         * Database operations
+         */
+        db: {
+            query(sql: string, params?: any[]): Promise<any>;
+        };
+
+        /**
+         * Titan Extensions
+         */
+        [key: string]: any;
+    }
+
+    interface LogInterface {
+        (...args: any[]): void;
+        info(...args: any[]): void;
+        warn(...args: any[]): void;
+        error(...args: any[]): void;
+    }
+}

package/templates/extension/node_modules/titanpl-sdk/index.js

@@ -0,0 +1,5 @@
+// Titan SDK
+// This package is primarily for type definitions and development tools.
+// The 't' object is injected globally by the Titan runtime.
+
+export const VERSION = "0.0.1";

package/templates/extension/node_modules/titanpl-sdk/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "titanpl-sdk",
+    "version": "0.1.7",
+    "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
+    "main": "index.js",
+    "type": "module",
+    "types": "index.d.ts",
+    "bin": {
+        "titanpl-sdk": "./bin/run.js"
+    },
+    "files": [
+        "bin/",
+        "templates/",
+        "titan",
+        "assets",
+        "index.js",
+        "index.d.ts",
+        "README.md"
+    ],
+    "keywords": [
+        "titan",
+        "titan-planet",
+        "titanpl-sdk",
+        "ezetgalaxy",
+        "types",
+        "typescript",
+        "intellisense",
+        "sdk",
+        "backend-sdk",
+        "extension-development"
+    ],
+    "license": "ISC"
+}

package/templates/{rust-js → extension/node_modules/titanpl-sdk/templates}/Dockerfile

@@ -18,20 +18,6 @@ COPY . .
 # Install JS dependencies (needed for Titan DSL + bundler)
 RUN npm install
 
-SHELL ["/bin/bash", "-c"]
-
-# Extract Titan extensions into .ext
-RUN mkdir -p /app/.ext && \
-    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
-    while IFS= read -r -d '' file; do \
-    pkg_dir="$(dirname "$file")"; \
-    pkg_name="$(basename "$pkg_dir")"; \
-    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
-    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
-    done && \
-    echo "Extensions in .ext:" && \
-    ls -R /app/.ext
-
 # Build Titan metadata + bundle JS actions
 RUN titan build
 
@@ -48,7 +34,7 @@ FROM debian:stable-slim
 WORKDIR /app
 
 # Copy Rust binary from builder stage
-COPY --from=builder /app/server/target/release/titan-server ./titan-server
+COPY --from=builder /app/server/target/release/server ./titan-server
 
 # Copy Titan routing metadata
 COPY --from=builder /app/server/routes.json ./routes.json
@@ -58,9 +44,10 @@ COPY --from=builder /app/server/action_map.json ./action_map.json
 RUN mkdir -p /app/actions
 COPY --from=builder /app/server/actions /app/actions
 
-# Copy only Titan extensions
-COPY --from=builder /app/.ext ./.ext
+COPY --from=builder /app/db /app/assets
 
+# Expose Titan port
 EXPOSE 3000
 
+# Start Titan
 CMD ["./titan-server"]

package/templates/extension/node_modules/titanpl-sdk/templates/app/actions/hello.js

@@ -0,0 +1,5 @@
+export const hello = (req) => {
+   return {
+        message: `Hello from Titan ${req.body.name}`,
+    };
+}

package/templates/extension/node_modules/titanpl-sdk/templates/app/app.js

@@ -0,0 +1,10 @@
+import t from "../titan/titan.js";
+
+
+
+
+t.post("/hello").action("hello") // pass a json payload { "name": "titan" }
+
+t.get("/").reply("Ready to land on Titan Planet 🚀");
+
+t.start(3000, "Titan Running!");

package/templates/extension/node_modules/titanpl-sdk/templates/jsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "checkJs": false,
+        "noImplicitAny": false,
+        "allowJs": true,
+        "moduleResolution": "node",
+        "baseUrl": ".",
+        "paths": {
+            "*": [
+                "./app/*"
+            ]
+        }
+    },
+    "include": [
+        "app/**/*"
+    ]
+}