neurondb 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pisani da Arq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# N-Bash — Remote Bash for NeuronDB
+
+Interactive SNL terminal and remote bash executor for NeuronDB.
+
+## Install
+
+```bash
+npm install -g neuron-bash
+```
+
+## Usage
+
+```bash
+nbash
+# or
+neuron-bash
+```
+
+You'll be prompted for:
+- **Node URL** — NeuronDB server (e.g., `https://api.neuron-db.com`)
+- **Instance** — NeuronDB instance (default: `system`)
+- **Username** / **Password** — Your NeuronDB credentials
+- **Session name** — Name for this bash session (default: hostname)
+
+## Features
+
+### Interactive SNL Terminal
+Type any SNL command and it executes on the server:
+```
+nbash> GET() ON(main.users.*) GO()
+nbash> SET() VALUE({"hello":"world"}) ON(main.test.key1) GO()
+```
+
+### Remote Bash Execution
+From NeuronDB Studio or another terminal, run commands on the machine where nbash is connected:
+```
+BASH("ls -la") GO(result)
+BASH("echo hello", "my-laptop") GO(result)
+CATALOG(Bash) GO()
+```
+
+Results are written to `__nbash_results.{request_id}` and can be retrieved with:
+```
+GET() ON(system.main.__nbash_results.{request_id}) GO(data)
+```
+
+### Sandbox Security
+All commands execute in `~/neuron-home/{instance}/` with:
+- Restricted PATH
+- 30s timeout
+- 1MB output buffer
+- Blocked dangerous commands (sudo, rm /, etc.)
+- Path traversal prevention
+
+## Requirements
+
+- Node.js >= 18.0.0
+- A running NeuronDB server
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+/**
+ * N-Bash CLI Entry Point
+ * neuron-bash / nbash
+ */
+
+import { main } from '../src/app.js';
+
+main().catch((err) => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "neurondb",
+  "version": "1.0.0",
+  "description": "N-Bash — Interactive SNL terminal and remote bash executor for NeuronDB",
+  "bin": {
+    "neuron": "./bin/cli.js",
+    "neuron-bash": "./bin/cli.js",
+    "nbash": "./bin/cli.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "neurondb",
+    "database",
+    "snl",
+    "bash",
+    "remote-execution",
+    "cli",
+    "terminal"
+  ],
+  "author": "Pisani da Arq",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nickmpisani/N-Bash.git"
+  },
+  "homepage": "https://neuron-db.com",
+  "dependencies": {
+    "blessed": "^0.1.81",
+    "chalk": "^5.3.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE",
+    "README.md"
+  ]
+}

package/src/api.js

@@ -0,0 +1,144 @@
+/**
+ * N-Bash API Client — HTTP communication with NeuronDB
+ */
+
+import https from 'node:https';
+import http from 'node:http';
+
+/** Reusable agent that ignores self-signed certs */
+const insecureAgent = new https.Agent({ rejectUnauthorized: false });
+
+export class NdbApi {
+  constructor(baseUrl) {
+    // Normalize: remove trailing slash
+    this.baseUrl = baseUrl.replace(/\/+$/, '');
+    this.token = null;
+    this.isHttps = this.baseUrl.startsWith('https');
+    // Store credentials for auto-reconnect
+    this._creds = null;
+    this._reconnecting = false;
+  }
+
+  /**
+   * Login and get auth token
+   * @param {string} username
+   * @param {string} password
+   * @param {string} instance
+   * @returns {Promise<{token: string, success: boolean, message: string}>}
+   */
+  async login(username, password, instance) {
+    const body = JSON.stringify({ username, password, instance });
+    const result = await this._request('POST', '/login', body);
+
+    // Token can be at result.token or result.data.token
+    const token = result.token || result.data?.token;
+    if (token) {
+      this.token = token;
+      this._creds = { username, password, instance };
+      return { success: true, token, message: 'Logged in' };
+    }
+    return { success: false, token: null, message: result.message || result.error || 'Login failed' };
+  }
+
+  /**
+   * Auto-reconnect on 401 — re-login with stored credentials
+   */
+  async _reconnect() {
+    if (this._reconnecting || !this._creds) return false;
+    this._reconnecting = true;
+    try {
+      const { username, password, instance } = this._creds;
+      const result = await this.login(username, password, instance);
+      return result.success;
+    } catch {
+      return false;
+    } finally {
+      this._reconnecting = false;
+    }
+  }
+
+  /**
+   * Execute SNL command
+   * @param {string} snl - SNL command string
+   * @returns {Promise<object>} - Server response
+   */
+  async execute(snl) {
+    const body = JSON.stringify({ command: snl });
+    const result = await this._request('POST', '/execute', body);
+
+    // Auto-reconnect on auth failure
+    if (result.error === 'No token' || result.error === 'Invalid token') {
+      const ok = await this._reconnect();
+      if (ok) return this._request('POST', '/execute', body);
+    }
+    return result;
+  }
+
+  /**
+   * Execute SNL and return parsed result
+   * @param {string} snl
+   * @returns {Promise<{success: boolean, message: string, data: any}>}
+   */
+  async snl(snl) {
+    const resp = await this.execute(snl);
+    return {
+      success: resp.success !== false && resp.success !== 0,
+      message: resp.info?.message || resp.message || '',
+      data: resp.result ?? resp.data ?? null,
+      raw: resp,
+    };
+  }
+
+  /**
+   * Low-level HTTP request
+   */
+  _request(method, path, body) {
+    return new Promise((resolve, reject) => {
+      const url = new URL(path, this.baseUrl);
+      const mod = this.isHttps ? https : http;
+
+      const options = {
+        method,
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body || ''),
+        },
+      };
+
+      if (this.isHttps) {
+        options.agent = insecureAgent;
+      }
+
+      if (this.token) {
+        options.headers['Authorization'] = `Bearer ${this.token}`;
+      }
+
+      const req = mod.request(options, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            resolve({ success: false, message: 'Invalid JSON response', raw: data });
+          }
+        });
+      });
+
+      req.on('error', (err) => {
+        resolve({ success: false, message: `Connection error: ${err.message}` });
+      });
+
+      req.setTimeout(60000, () => {
+        req.destroy();
+        resolve({ success: false, message: 'Request timeout' });
+      });
+
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+}