instaserve 0.1.24 → 1.0.1

package/README.md

@@ -1,47 +1,145 @@
-# instaserve
-Instant web stack
+<div align="center">
+  <h1 style="color: #3b82f6; margin: 10px 0 5px;">Instaserve</h1>
+  <p style="color: #6b7280; margin: 0;">Instant web stack for Node.js</p>
+</div>
 
-In any folder:
+## Usage
 
-> npx instaserve
-Starts a server in the current directory
-Create a public folder and add files for static file serving
-Use a routes.mjs or one will be created automatically
+<div style="background: white; padding: 15px; border-radius: 6px; box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); margin: 15px 0;">
+  <pre style="margin: 0;"><code>npx instaserve [options]</code></pre>
+</div>
 
-> npm run deno (deno)
-Starts a deno server using routes.mjs and static serving
+## Options
 
-> npm run bun (bun)
-Starts a bun server
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-port &lt;number&gt;</code>
+  <span>Port to listen on (default: 3000)</span>
+</div>
 
-> port=8080 npx instaserve
-Use custom port and routes file
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-ip &lt;address&gt;</code>
+  <span>IP address to bind to (default: 127.0.0.1)</span>
+</div>
 
-###Script usage
-````
-import serve from 'instaserve'
-serve({
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-public &lt;path&gt;</code>
+  <span>Public directory path (default: ./public)</span>
+</div>
 
-    // routes prefixed with "_" run on every request
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-api &lt;file&gt;</code>
+  <span>Path to routes file (default: ./routes.js)</span>
+</div>
 
-    _log: (r, s) => console.log(r.method, r.url),
-    _example: (r, s) => console.log('returning a falsy value (above) will stop processing'),
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-secure</code>
+  <span>Enable HTTPS (requires cert.pem and key.pem - run ./generate-certs.sh)</span>
+</div>
 
-    api: (r, s, body) => s.end('an api response'),
+<div style="display: flex; gap: 8px; margin: 8px 0;">
+  <code style="background: #f3f4f6; padding: 2px 4px; border-radius: 4px; color: #2563eb;">-help</code>
+  <span>Show help message</span>
+</div>
 
-}, port)  // port is optional (3000)
-````
+## HTTPS Support
 
-###Routes.mjs file example - data is request body + query string
-````
+Instaserve supports HTTPS with self-signed certificates. To enable HTTPS:
+
+1. **Generate certificates:**
+   ```bash
+   ./generate-certs.sh
+   ```
+   This creates `cert.pem` and `key.pem` files and adds them to your system's trust store.
+
+2. **Run with HTTPS:**
+   ```bash
+   npx instaserve -secure
+   ```
+
+The certificate generation script:
+- Creates a self-signed certificate valid for 365 days
+- Automatically adds the certificate to your system trust store (macOS/Linux)
+- Prevents browser security warnings
+
+## Routes
+
+The routes file (`routes.js` by default) defines your API endpoints. Each route is a function that handles requests to a specific URL path.
+
+### Basic Route Example
+
+```javascript
 export default {
-      _debug: ({ method, url }, s, data) => !console.log(method, url, data),
-      _example: (r, s, data) => console.log('returning a truthy value (above) will stop the chain'),
-      api: (r, s, data) => s.end('an example api response')
+    // Handle GET /hello
+    hello: (req, res, data) => {
+        return { message: 'Hello World' }
+    }
 }
-````
+```
+
+### Special Routes (Middleware)
+
+Routes starting with `_` are middleware functions that run on **every request** before the main route handler. They are useful for:
+
+- Logging requests
+- Authentication
+- Request modification
+- Response headers
+
+Middleware functions can:
+- Return `false` to continue to the next middleware or main route
+- Return a truthy value to stop processing and use that as the response
+- Modify the request or response objects
+
+#### Middleware Example
 
-###Helpers
-````
-saveJSON(url, file, fetch_options)
-````
+```javascript
+export default {
+    // Log every request
+    _log: (req, res, data) => {
+        console.log(`${req.method} ${req.url}`)
+        return false // Continue processing
+    },
+
+    // Block unauthorized requests
+    _auth: (req, res, data) => {
+        if (!data.token) {
+            res.writeHead(401)
+            return 'Unauthorized'
+        }
+        return false // Continue if authorized
+    }
+}
+```
+
+### Route Parameters
+
+Each route function receives:
+- `req` - The HTTP request object
+- `res` - The HTTP response object
+- `data` - Combined data from:
+  - POST body (if JSON)
+  - URL query parameters
+  - Form data
+
+### Example Routes File
+
+```javascript
+// routes.js
+export default {
+    // Middleware example
+    _debug: (req, res, data) => {
+        console.log('Request:', req.url)
+        return false // Continue to next route
+    },
+
+    // API endpoint
+    api: (req, res, data) => {
+        return { status: 'ok', data }
+    },
+
+    // Error handling
+    testerror: () => {
+        throw new Error('Test error')
+    }
+}
+```

package/generate-certs.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+echo "Generating self-signed certificates for Instaserve..."
+
+# Create openssl config file
+cat > openssl.conf << EOF
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+C = US
+ST = State
+L = City
+O = Instaserve
+OU = Development
+CN = localhost
+
+[v3_req]
+basicConstraints = CA:FALSE
+keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+extendedKeyUsage = serverAuth, clientAuth
+subjectAltName = @alt_names
+
+[alt_names]
+DNS.1 = localhost
+DNS.2 = *.localhost
+IP.1 = 127.0.0.1
+IP.2 = ::1
+EOF
+
+# Generate private key
+openssl genrsa -out key.pem 2048
+
+# Generate certificate with config
+openssl req -new -x509 -key key.pem -out cert.pem -days 365 -config openssl.conf -extensions v3_req
+
+# Clean up config
+rm openssl.conf
+
+echo "Certificates generated: cert.pem and key.pem"
+
+# Add to system trust store (macOS)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    echo "Adding certificate to macOS trust store..."
+    sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain cert.pem
+    echo "Certificate added to macOS trust store"
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    echo "Adding certificate to Linux trust store..."
+    sudo cp cert.pem /usr/local/share/ca-certificates/instaserve.crt
+    sudo update-ca-certificates
+    echo "Certificate added to Linux trust store"
+else
+    echo "Please manually add cert.pem to your system's trust store"
+fi
+
+echo "HTTPS certificates ready! Use 'npx instaserve -secure' to enable HTTPS"
+echo "Note: You may still see browser warnings for self-signed certificates" 

package/instaserve

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk'
+import fs from 'node:fs'
+
+console.log(chalk.cyan('\nInstaserve - Instant Web Stack\n'))
+console.log(chalk.yellow('Usage:'))
+console.log(chalk.green('  npx instaserve [options]\n'))
+console.log(chalk.yellow('Options:'))
+console.log(chalk.green('  -port <number>') + '    Port to listen on (default: 3000)')
+console.log(chalk.green('  -ip <address>') + '     IP address to bind to (default: 127.0.0.1)')
+console.log(chalk.green('  -public <path>') + '    Public directory path (default: ./public)')
+console.log(chalk.green('  -api <file>') + '       Path to routes file (default: ./routes.js)')
+console.log(chalk.green('  -secure') + '           Enable HTTPS (requires cert.pem and key.pem: run generate-certs.sh)')
+console.log(chalk.green('  -help') + '             Show this help message\n')
+
+if (process.argv.includes('-help')) {
+    process.exit(0)
+}
+
+import server from './module.mjs'
+
+const args = process.argv.slice(2)
+const params = {}
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('-')) {
+        const key = arg.slice(1)
+        const nextArg = args[i + 1]
+        if (nextArg && !nextArg.startsWith('-')) {
+            params[key] = nextArg
+            i++ // Skip the next argument since we used it
+        } else {
+            params[key] = true // Boolean flag
+        }
+    }
+}
+
+// Load routes file
+let routes = {}
+const routesFile = params.api || './routes.js'
+if (fs.existsSync(routesFile)) {
+    try {
+        const imported = await import(routesFile)
+        routes = imported.default || imported
+    } catch (e) {
+        console.log(chalk.yellow(`Warning: Could not load routes file ${routesFile}: ${e.message}`))
+    }
+}
+
+server(routes) 

package/module.mjs

@@ -1,31 +1,55 @@
 import http from 'node:http'
+import https from 'node:https'
 import fs from 'node:fs'
 
-global.saveJSON = async (url, filename, options) => {
-    const f = await fetch(url, options)
-    const j = await f.json()
-    fs.writeFileSync(filename, JSON.stringify(j, null, 2))
+const args = process.argv.slice(2)
+const params = {}
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith('-')) {
+        const key = arg.slice(1)
+        const nextArg = args[i + 1]
+        if (nextArg && !nextArg.startsWith('-')) {
+            params[key] = nextArg
+            i++ // Skip the next argument since we used it
+        } else {
+            params[key] = true // Boolean flag
+        }
+    }
 }
 
-const {debug, port, ip} = process.env
-
 function public_file(r, s) {
     if (r.url == '/') r.url = '/index.html'
-    const fn = `./public${r.url.replace('..', '')}`
+    const fn = `${params.public || './public'}${r.url.replace(/\.\./g, '')}`
     if (fs.existsSync(fn)) {
-        if (fn.match(/.js$/)) s.writeHead(200, { 'Content-Type': 'application/javascript' })
-        return fs.readFileSync(fn, 'utf-8')
+        const content = fs.readFileSync(fn, 'utf-8')
+        if (fn.match(/.js$/)) {
+            s.writeHead(200, { 'Content-Type': 'application/javascript' })
+        } else {
+            s.writeHead(200)
+        }
+        s.end(content)
+        return true // Indicate file was served
     }
+    return false // Indicate no file was served
 }
 
-export default function (routes, port = 3000, ip = '127.0.0.1') {
-    const server = http.createServer(async (r, s) => {
+export default async function (routes, port = params.port || 3000, ip = params.ip || '127.0.0.1') {
+    const publicDir = params.public || './public'
+    if (publicDir.includes('..')) {
+        throw new Error('Public directory path cannot contain ".."')
+    }
+    if (!fs.existsSync(publicDir)) {
+        throw new Error(`Public directory "${publicDir}" does not exist`)
+    }
+
+    const requestHandler = async (r, s) => {
         let sdata = '', rrurl = r.url || ''
+        let responseSent = false
+        
         r.on('data', (s) => sdata += s.toString().trim())
         r.on('end', (x) => {
             try {
-                if (debug) console.log(`routes: "${JSON.stringify(routes)}"`)
-                
                 // Compose data object
                 const data = sdata ? JSON.parse(sdata) : {}
                 const qs = rrurl.split('?')
@@ -36,29 +60,72 @@ export default function (routes, port = 3000, ip = '127.0.0.1') {
 
                 const midware = Object.keys(routes)
                     .filter((k) => k.startsWith('_'))
-                    .find((k) => routes[k](r, s, data))
+                    .find((k) => {
+                        const result = routes[k](r, s, data)
+                        if (result && !responseSent) {
+                            responseSent = true
+                            s.end(typeof result === 'string' ? result : JSON.stringify(result))
+                        }
+                        return result
+                    })
 
                 // Response closed by middleware
-                if(s.finished) return
+                if(responseSent || s.writableEnded) return
 
-                const fc = public_file(r, s)
-                if(fc) return s.end(fc)
+                // Try to serve public file
+                if(public_file(r, s)) {
+                    responseSent = true
+                    return
+                }
 
                 const url = rrurl.split('/')[1].split('?')[0]
                 if (routes[url]) {
                     const resp = routes[url](r, s, data)
-                    if(debug) console.log(`route: ${url}, returned: ${JSON.stringify(resp)}`)
-                    return s.end(typeof resp === 'string' ? resp:JSON.stringify(resp))
+                    if (!responseSent && !s.writableEnded) {
+                        responseSent = true
+                        s.end(typeof resp === 'string' ? resp:JSON.stringify(resp))
+                    }
+                    return
+                }
+                
+                if (!responseSent && !s.writableEnded) {
+                    responseSent = true
+                    s.writeHead(404);
+                    s.end();
                 }
-                throw Error(r.url + ' not found')
             } catch (e) {
                 console.error(e.stack)
-                s.writeHead(500).end()
+                if (!responseSent && !s.writableEnded) {
+                    responseSent = true
+                    s.writeHead(500).end()
+                }
             }
         })
-    }).listen(port || 3000, ip || '')
+    }
+
+    let server
+    if (params.secure) {
+        const certPath = './cert.pem'
+        const keyPath = './key.pem'
+        
+        if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
+            throw new Error('Certificate files not found. Run ./generate-certs.sh first.')
+        }
+        
+        const options = {
+            cert: fs.readFileSync(certPath),
+            key: fs.readFileSync(keyPath)
+        }
+        
+        server = https.createServer(options, requestHandler)
+    } else {
+        server = http.createServer(requestHandler)
+    }
+
+    server.listen(port || 3000, ip || '')
 
-    console.log(`started on: ${(process.env.ip || ip)}:${(process.env.port || port)}, using routes: ${Object.keys(routes)}`)
+    const protocol = params.secure ? 'https' : 'http'
+    console.log(`started on: ${protocol}://${(process.env.ip || ip)}:${(process.env.port || port)}, public: ${publicDir}, ${Object.keys(routes).length > 0 ? `using routes: ${Object.keys(routes)}` : 'not using routes'}`)
     
     return {
         routes: routes,
@@ -66,5 +133,4 @@ export default function (routes, port = 3000, ip = '127.0.0.1') {
         server: server,
         stop: () => { server.close(); return true }
     }
-
-}
+}

package/package.json

@@ -1,13 +1,14 @@
 {
     "name": "instaserve",
-    "version": "0.1.24",
+    "version": "1.0.1",
     "description": "Instant web stack",
     "main": "module.mjs",
-    "bin": "./server.mjs",
+    "bin": "./instaserve",
     "scripts": {
-        "start": "node server.mjs",
-        "deno": "deno run --allow-env --unstable --allow-net --allow-read deno/server.js",
-        "bun": "bun run bun/http.js",
-        "test": "node --no-warnings test.mjs"
+        "start": "node instaserve"
+    },
+    "type": "module",
+    "dependencies": {
+        "chalk": "^5.4.1"
     }
 }

package/public/index.html

@@ -1,13 +1,209 @@
 <!DOCTYPE html>
-<link rel="icon" href="data:;base64,iVBORw0KGgo=">
-<script src="enigmatic.js"></script>
-
-<script>
-  // navigator.serviceWorker.register('sw.js')
-</script>
-<link rel='stylesheet' href='https://cdnjs.cloudflare.com/ajax/libs/tailwindcss/2.2.19/tailwind.min.css'>
-
-<div class='bg-yellow-200'>hello</div>
-<script>
-  document.write(enigmatic.version)
-</script>
+<html>
+<head>
+    <title>Instaserve</title>
+    <style>
+        :root {
+            --primary: #3b82f6;
+            --primary-dark: #2563eb;
+            --text: #1f2937;
+            --text-light: #6b7280;
+            --bg: #f9fafb;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            line-height: 1.5;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px 15px;
+            color: var(--text);
+            background: var(--bg);
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 20px;
+        }
+        .orb {
+            width: 60px;
+            height: 60px;
+            background: radial-gradient(circle at 30% 30%, #60a5fa, var(--primary));
+            border-radius: 50%;
+            margin: 0 auto 10px;
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+        }
+        h1 { 
+            color: var(--primary);
+            font-size: 2rem;
+            margin: 0;
+        }
+        .subtitle {
+            color: var(--text-light);
+            font-size: 1rem;
+            margin: 5px 0;
+        }
+        h2 { 
+            color: var(--text);
+            font-size: 1.3rem;
+            margin: 20px 0 10px;
+            padding-bottom: 5px;
+            border-bottom: 2px solid var(--primary);
+        }
+        h3 {
+            color: var(--text);
+            font-size: 1.1rem;
+            margin: 15px 0 8px;
+        }
+        code {
+            background: #f3f4f6;
+            padding: 2px 4px;
+            border-radius: 4px;
+            font-family: 'SF Mono', Menlo, monospace;
+            color: var(--primary-dark);
+        }
+        pre {
+            background: #f3f4f6;
+            padding: 10px;
+            border-radius: 6px;
+            overflow-x: auto;
+            border: 1px solid #e5e7eb;
+            margin: 10px 0;
+            font-size: 0.9rem;
+        }
+        .option {
+            margin: 8px 0;
+            padding-left: 0;
+            position: relative;
+            display: flex;
+            gap: 8px;
+        }
+        .option:before {
+            display: none;
+        }
+        .option code {
+            flex-shrink: 0;
+        }
+        ul {
+            padding-left: 15px;
+            margin: 8px 0;
+        }
+        li {
+            margin: 5px 0;
+        }
+        .usage {
+            background: white;
+            padding: 15px;
+            border-radius: 6px;
+            box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+            margin: 15px 0;
+        }
+        p {
+            margin: 8px 0;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <div class="orb"></div>
+        <h1>Instaserve</h1>
+        <p class="subtitle">Instant web stack for Node.js</p>
+    </div>
+
+    <div class="usage">
+        <h2>Usage</h2>
+        <pre><code>npx instaserve [options]</code></pre>
+    </div>
+
+    <h2>Options</h2>
+    <div class="option"><code>-port &lt;number&gt;</code> - Port to listen on (default: 3000)</div>
+    <div class="option"><code>-ip &lt;address&gt;</code> - IP address to bind to (default: 127.0.0.1)</div>
+    <div class="option"><code>-public &lt;path&gt;</code> - Public directory path (default: ./public)</div>
+    <div class="option"><code>-api &lt;file&gt;</code> - Path to routes file (default: ./routes.js)</div>
+    <div class="option"><code>-secure</code> - Enable HTTPS (requires cert.pem and key.pem - run ./generate-certs.sh)</div>
+    <div class="option"><code>-help</code> - Show help message</div>
+
+    <h2>HTTPS Support</h2>
+    <p>Instaserve supports HTTPS with self-signed certificates. To enable HTTPS:</p>
+    <ol>
+        <li><strong>Generate certificates:</strong> <code>./generate-certs.sh</code></li>
+        <li><strong>Run with HTTPS:</strong> <code>npx instaserve -secure</code></li>
+    </ol>
+    <p>The certificate generation script creates trusted certificates that won't show browser warnings.</p>
+
+    <h2>Routes</h2>
+    <p>The routes file (<code>routes.js</code> by default) defines your API endpoints. Each route is a function that handles requests to a specific URL path.</p>
+
+    <h3>Basic Route Example</h3>
+    <pre><code>export default {
+    // Handle GET /hello
+    hello: (req, res, data) => {
+        return { message: 'Hello World' }
+    }
+}</code></pre>
+
+    <h3>Special Routes (Middleware)</h3>
+    <p>Routes starting with <code>_</code> are middleware functions that run on <strong>every request</strong> before the main route handler. They are useful for:</p>
+    <ul>
+        <li>Logging requests</li>
+        <li>Authentication</li>
+        <li>Request modification</li>
+        <li>Response headers</li>
+    </ul>
+    <p>Middleware functions can:</p>
+    <ul>
+        <li>Return <code>false</code> to continue to the next middleware or main route</li>
+        <li>Return a truthy value to stop processing and use that as the response</li>
+        <li>Modify the request or response objects</li>
+    </ul>
+
+    <h4>Middleware Example</h4>
+    <pre><code>export default {
+    // Log every request
+    _log: (req, res, data) => {
+        console.log(`${req.method} ${req.url}`)
+        return false // Continue processing
+    },
+
+    // Block unauthorized requests
+    _auth: (req, res, data) => {
+        if (!data.token) {
+            res.writeHead(401)
+            return 'Unauthorized'
+        }
+        return false // Continue if authorized
+    }
+}</code></pre>
+
+    <h3>Route Parameters</h3>
+    <p>Each route function receives:</p>
+    <ul>
+        <li><code>req</code> - The HTTP request object</li>
+        <li><code>res</code> - The HTTP response object</li>
+        <li><code>data</code> - Combined data from:
+            <ul>
+                <li>POST body (if JSON)</li>
+                <li>URL query parameters</li>
+                <li>Form data</li>
+            </ul>
+        </li>
+    </ul>
+
+    <h3>Example Routes File</h3>
+    <pre><code>export default {
+    // Middleware example
+    _debug: (req, res, data) => {
+        console.log('Request:', req.url)
+        return false // Continue to next route
+    },
+
+    // API endpoint
+    api: (req, res, data) => {
+        return { status: 'ok', data }
+    },
+
+    // Error handling
+    testerror: () => {
+        throw new Error('Test error')
+    }
+}</code></pre>
+</body>
+</html>

package/routes.js

@@ -0,0 +1,54 @@
+/*
+ * This file defines the API routes and middleware for the Instaserve web server.
+ * 
+ * The file exports a default object containing route handlers and middleware functions.
+ * 
+ * Middleware functions (prefixed with _):
+ * - _debug: Logs request method, URL and data to console
+ * - _returnfalsy: Example middleware that returns true to stop request processing
+ * - _example: Demonstrates middleware behavior with console log
+ * - _end: Example of early response termination (commented out)
+ * 
+ * Route handlers:
+ * - api: Returns a string response with the request data
+ * - testerror: Throws an error for testing error handling
+ * - testdata: Example route that returns the context parameter
+ * 
+ * Each route handler receives:
+ * - req: HTTP request object
+ * - s: HTTP response object
+ * - data: Combined request data (POST body, query params, form data)
+ */
+
+export default {
+    // Middleware functions (prefixed with _) run on every request
+    // Return false to continue processing, or a value to use as response
+    
+    // Example: Log all requests
+    _log: (req, res, data) => {
+        console.log(`${req.method} ${req.url}`)
+        return false // Continue to next middleware or route
+    },
+
+    /**** Example: Basic authentication
+    _auth: (req, res, data) => {
+        if (!data.token) {
+            res.writeHead(401)
+            return 'Unauthorized'
+        }
+        return false // Continue if authorized
+    }, */
+
+    // Regular route handlers
+    hello: (req, res, data) => {
+        return { message: 'Hello World' }
+    },
+
+    _debug: ({method, url}, s, data) => { console.log(method, url, data) },
+    _example: (r, s) => console.log('in routes.mjs, returning a truthy value (above) will stop the chain'),
+    // _returnfalsy: (r, s) => { return true }, // Commented out - interferes with static file serving
+
+    api: (r, s, data) => 'an example api response, data:' + JSON.stringify(data),
+    testerror: () => { throw new Error('this from testerror') },
+    testdata: (r, s, c, d) => c
+}

package/.devcontainer/Dockerfile

@@ -1,9 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.245.2/containers/alpine/.devcontainer/base.Dockerfile
-
-# [Choice] Alpine version: 3.16, 3.15, 3.14, 3.13
-ARG VARIANT="3.16"
-FROM mcr.microsoft.com/vscode/devcontainers/base:0-alpine-${VARIANT}
-
-# ** [Optional] Uncomment this section to install additional packages. **
-# RUN apk update \
-#     && apk add --no-cache <your-package-list-here>

package/.devcontainer/devcontainer.json

@@ -1,22 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.245.2/containers/alpine
-{
-	"name": "Alpine-NodeJS",
-	"build": {
-		"dockerfile": "Dockerfile",
-		// Update 'VARIANT' to pick an Alpine version: 3.13, 3.14, 3.15, 3.16
-		"args": { "VARIANT": "3.16" }
-	},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "uname -a",
-
-	// Replace when using a ptrace-based debugger like C++, Go, and Rust
-	// "runArgs": [ "--init", "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
-
-	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
-}

package/bun/http.js

@@ -1,50 +0,0 @@
-import {existsSync} from 'fs'
-import { pathToFileURL } from 'node:url'
-import { resolve } from 'node:path'
-const routesfile = resolve(process.env.routes || '../routes.mjs')
-const routesurl = pathToFileURL(routesfile).href
-
-const routes = (await import(routesurl)).default
-const port = process.env.port || 3000
-
-class s {
-    end(s) {
-        this.resp = s
-    }
-}
-
-Bun.serve({
-    port: port,
-    async fetch(r) {
-
-        let url = new URL(r.url).pathname
-        const data = await r.text()
-
-        const ru = {method: r.method, url: url}
-        const rs = new s()
-        
-        const midware = Object.keys(routes)
-            .filter(k => k.startsWith('_'))
-            .find(k => routes[k](ru, rs, data))
-
-        // Routes.mjs
-        if(routes[url]) {
-            const f = routes[url](ru, rs, data)
-            return new Response(rs.resp)
-        }
-        
-        // Static
-        const fn = (url == '/') ? `public/index.html` : `public/${url}`
-        if (existsSync(fn))
-          return new Response(Bun.file(fn))
-
-        return new Response('', { status: 404 })
-
-    },
-    error(e) {
-        console.error(e)
-        return new Response('', { status: 404 })
-    }
-})
-
-console.log(`Started on: ${port}, using routes: ${Object.keys(routes)}`)

package/deno/server.js

@@ -1,39 +0,0 @@
-import { existsSync } from "https://deno.land/std/fs/mod.ts"; 
-
-const routesfile = Deno.env.get('routes') || '../routes.mjs'
-const port = Deno.env.get('port') || 3000
-const routes = (await import(routesfile)).default
-
-class s {
-  end(s) {
-    this.resp = s
-  }
-}
-
-Deno.serve(async (r) => {
-
-  const data = await r.text()
-  let url = new URL(r.url).pathname
-  const ru = { method: r.method, url: url }
-  const rs = new s()
-
-  const midware = Object.keys(routes)
-    .filter((k) => k.startsWith('_'))
-    .find((k) => routes[k](ru, rs, data))
-
-  // Routes.mjs
-  if (routes[url]) {
-    const f = routes[url](ru, rs, data)
-    return new Response(rs.resp)
-  }
-
-  // Static
-  const fn = (url == '/') ? `public/index.html` : `public/${url}`
-  if (existsSync(fn))
-    return new Response(await Deno.readTextFile(fn), { headers: { 'Content-Type': 'text/html' } })
-
-  return new Response('', { status: 404 })
-
-}, {port: port})
-
-console.log(`routes: ${Object.keys(routes)}`)

package/public/enigmatic.js

@@ -1,150 +0,0 @@
-const w = {}, d = document
-
-// helpers
-
-w.$ = d.querySelector.bind(d)
-w.$$ = d.querySelectorAll.bind(d)
-w.loadJS = (src) => {
-    return new Promise((r, j) => {
-        if ($(`script[src="${src}"]`)) return r(true)
-        const s = d.createElement('script')
-        s.src = src
-        s.addEventListener('load', r)
-        d.head.appendChild(s)
-    })
-}
-w.loadCSS = (src) => {
-    return new Promise((r, j) => {
-        const s = document.createElement('link')
-        s.rel = 'stylesheet'
-        s.href = src
-        s.addEventListener('load', r)
-        d.head.appendChild(s)
-    })
-}
-w.wait = (ms) => new Promise((r) => setTimeout(r, ms))
-w.ready = async () => {
-    return new Promise((r) => {
-        if (document.readyState === 'complete') r(true)
-        document.onreadystatechange = () => {
-            if (document.readyState === 'complete') r()
-        }
-    })
-}
-w.child = (type = 'div', html = '') => {
-    const e = d.createElement(type)
-    e.innerHTML = html
-    d.body.appendChild(e)
-    return e
-}
-
-// Custom element
-
-w.element = (name, { onMount = x => x, beforeData = x => x, style, template = '' }) => {
-    customElements.define(name, class extends HTMLElement {
-        async connectedCallback(props) {
-            await onMount()
-            if (style) {
-                const s = document.createElement('style')
-                s.innerHTML = `${name} {${style}}`
-                d.body.appendChild(s)
-            }
-            this.template = template
-            if (!this.template.match('{'))
-                this.innerHTML = this.template
-        }
-        set(o) {
-            this.innerHTML = ''
-            o = beforeData(o)
-            if (!Array.isArray(o)) o = [o]
-            const m = new Function('o', 'return `' + this.template + '`')
-            o.map((i) => (this.innerHTML += m(o)))
-        }
-    })
-}
-
-if (window.components) {
-    for (let name in window.components)
-        w.element(name, window.components[name])
-}
-
-// Data
-
-w.state = new Proxy(
-    {}, {
-    set: (obj, prop, value) => {
-        let ret = []
-        for (const e of $$(`[data*=${prop}]`)) {
-            console.log(['setting e', e.tagName, e.id, value])
-            e.set(value)
-        }
-        obj[prop] = value
-    },
-    get: (obj, prop, receiver) => {
-        if (prop == '_state') return obj
-        return obj[prop]
-    },
-}
-)
-
-w.dataEvent = (x) => console.log(`dataevent: ${x}`)
-
-w.fetchJSON = async (url, key) => {
-    const j = await (await fetch(url)).json()
-    if (key) state[key] = j
-    dataEvent(j)
-    return j
-}
-
-w.streamJSON = async (url, key) => {
-    const ev = new EventSource(url)
-    ev.onmessage = (ev) => {
-        const j = JSON.parse(ev.data)
-        if (key) state[key] = j
-        dataEvent(j)
-        return j
-    }
-}
-
-// State changes
-
-w.trackStateChanges = () =>
-(w.dataEvent = (o) =>
-    localStorage.set(new Date().toISOString(), JSON.stringify(o)))
-w.untrackStateChanges = () =>
-    (w.dataEvent = (o) => console.log('dataevent:', o))
-
-// Startup
-
-w.start = async () => {
-    await w.ready();
-    [...$$('div')].map((e) => {
-        if (!e.id)
-            e.id = Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 3)
-        e.pr = {};
-        [...e.attributes].map((a) => (e.pr[a.name] = a.value))
-        if (e.pr.fetch) e.fetch = fetchJSON.bind(null, e.pr.fetch, e.id)
-        if ('immediate' in e.pr) e.fetch()
-        if (e.pr.stream) e.stream = streamJSON.bind(null, e.pr.stream, e.id)
-        if (e.pr.data) {
-            if (e.innerHTML && e.innerHTML.includes('{')) {
-                e.template = e.innerHTML.replaceAll('{', '${')
-                e.innerHTML = ''
-            }
-            e.set = (o) => {
-                e.innerHTML = ''
-                if (!Array.isArray(o)) o = [o]
-                const m = new Function('o', 'return `' + e.template + '`')
-                o.map((i) => (e.innerHTML += m(i)))
-            }
-        }
-    })
-}
-
-w.enigmatic = { version: '2022-03-05 0.10.2' }
-Object.assign(window, w);
-
-(async () => {
-    await w.start()
-    if (window.main) window.main()
-})()

package/public/sw.js

@@ -1,18 +0,0 @@
-self.addEventListener('fetch', event => {
-  const cache = await caches.open('e')
-  const req = event.request
-
-  event.respondWith(async () => {
-    if(!req.url.match(/\.js$|\.css$/))
-      return fetch(req)
-
-    const response = await cache.match(req)
-    if(response) return response
-    response = await fetch(req)
-
-    if(response.status == 200)
-      cache.put(req, response)
-
-    return response
-  })
-})

package/public/test.html

@@ -1 +0,0 @@
-ok

package/routes.mjs

@@ -1,13 +0,0 @@
-import url from 'node:url'
-
-export default {
-        /*_testerror: ()=>console.testerrors(),*/
-        _debug: ({method, url}, s, data) => { console.log(method, url, data) },
-        _returnfalsy: (r, s) => { return true },
-        _example: (r, s) => console.log('returning a truthy value (above) will stop the chain'),
-        //_end: (r, s) => s.end('ended early'),
-
-        api: (r, s, data) => 'an example api response, data:' + JSON.stringify(data),
-        testerror: () => { throw new Error('this from testerror') },
-        testdata: (r, s, c, d) => c
-  }

package/server.mjs

@@ -1,22 +0,0 @@
-#!/usr/local/bin/node
-
-// > npx instaserve
-// > port=8080 npx instaserve
-
-import server from './module.mjs'
-import { pathToFileURL } from 'node:url'
-import fs from 'node:fs'
-const [npx, instaserve, cmd] = process.argv
-const {port, ip} = process.env
-
-if (cmd === 'create' && !fs.existsSync('routes.mjs')) {
-  fs.writeFileSync('routes.mjs', `export default {
-        _debug: ({method, url}, s) => !console.log(method, url),
-        _example: (r, s) => console.log('returning a falsy value (above) will stop the chain'),
-        api: (r, s) => 'an example api response'
-  }`)
-}
-
-const routesurl = pathToFileURL('routes.mjs').href
-const routes = (await import(routesurl)).default
-server(routes, Number(port||3000), ip)

package/test.mjs

@@ -1,48 +0,0 @@
-import serve from './module.mjs'
-import { get, te, tde } from '../instax/module.mjs'
-
-const port = 8080
-const server = serve({
-    api: (r, s) => 'Hello!',
-    api2: (r, s, data) => JSON.stringify(data)
-}, port)
-te(server.port, port)
-
-// Routes
-const resp = await get('http://localhost:8080/api')
-te(resp, 'Hello!')
-const resp2 = await get('http://localhost:8080/api2', {method: 'POST', body: JSON.stringify({a:1})})
-tde(resp2, {a:1})
-
-// Public
-const testhtml = await get('http://localhost:8080/test.html')
-te(testhtml, 'ok')
-te(server.stop(), true)
-
-// Test route returned values
-const db = {}
-const server2 = serve({
-    _: ({url}) => console.log(url),
-    __: ({headers: {host}, method, url}) => console.log(host, method, url),
-    str: () => 'ok',
-    obj: x => ({a: 'ok'}),
-    undef: () => undefined,
-    testerror: () => { throw new Error('this from testerror')}
-}, 8085)
-te(server2.port, 8085)
-te(server2.routes.str(), 'ok')
-
-const return_str = await get('http://localhost:8085/str') 
-te(return_str, 'ok')
-
-const return_obj = await get('http://localhost:8085/obj')
-te(return_obj.a, 'ok')
-
-const return_undefined = await get('http://localhost:8085/undef')
-te(return_undefined, '')
-
-const test_error = await get('http://localhost:8085/testerror')
-te(test_error.error, 'this from testerror')
-
-server2.stop()
-console.log('tests complete')