axiodb 16.2.0 → 17.0.0

package/README.md

@@ -30,6 +30,7 @@
   - [Simple: connect without authentication](#simple-connect-without-authentication)
   - [Advanced: TCP authentication](#advanced-tcp-authentication)
   - [Advanced: TLS encryption](#advanced-tls-encryption)
+- [AxioDB CLI — Command Line Interface](#-axiodb-cli--command-line-interface)
 - [Troubleshooting](#-troubleshooting)
 - [Docker Deployment](#-docker-deployment)
   - [Simple: run the container](#simple-run-the-container)
@@ -338,6 +339,92 @@ The rule: the `-e AXIODB_TLS_CERT_PATH=...` value must always match the *right-h
 
 ---
 
+## 💻 AxioDB CLI — Command Line Interface
+
+A Go-based CLI tool for interacting with AxioDB servers via the TCP protocol. Supports all database operations with both single-command and interactive REPL modes. Export and import databases via the HTTP API.
+
+### Quick Install
+
+**Linux/macOS:**
+```bash
+curl -fsSL https://raw.githubusercontent.com/nexoral/AxioDB/main/cli/Scripts/install.sh | bash
+```
+
+**Windows (PowerShell):**
+```powershell
+irm https://raw.githubusercontent.com/nexoral/AxioDB/main/cli/Scripts/install.ps1 | iex
+```
+
+**Or download directly:** [GitHub Releases](https://github.com/nexoral/AxioDB/releases?q=cli-v&expanded=true)
+
+### Supported Platforms
+
+| OS | Architectures |
+|------|--------------|
+| Linux | amd64, arm64, 386, armv7 |
+| macOS | amd64 (Intel), arm64 (Apple Silicon) |
+| Windows | amd64, arm64, 386 |
+| FreeBSD | amd64 |
+| OpenBSD | amd64 |
+| NetBSD | amd64 |
+
+### Usage
+
+**Single commands:**
+```bash
+axiodb -c axiodb://127.0.0.1:27019 ping
+axiodb -c axiodb://127.0.0.1:27019 db list
+axiodb -c axiodb://127.0.0.1:27019 document insert '{"name":"Alice"}' --db mydb --collection users
+axiodb -c axiodb://127.0.0.1:27019 document query '{}' --db mydb --collection users
+```
+
+**Interactive REPL (MongoDB shell style):**
+```bash
+axiodb connect
+# axiodb> use mydb
+# axiodb:mydb> show collections
+# axiodb:mydb> use mydb.users
+# axiodb:mydb:users> db.users.find({})
+# axiodb:mydb:users> db.users.insert({name: "Bob"})
+# axiodb:mydb:users> exit
+```
+
+**With authentication:**
+```bash
+axiodb -c axiodb://127.0.0.1:27019 -u admin -p admin connect
+```
+
+**With TLS:**
+```bash
+axiodb -c axiodb://127.0.0.1:27019 --tls --tls-cert ./cert.pem connect
+```
+
+**Export database (via HTTP API):**
+```bash
+axiodb export mydb --http-host localhost --http-port 27018 -u admin -p secret
+# Saves mydb.tar.gz in current directory
+```
+
+**Import database (via HTTP API):**
+```bash
+axiodb import ./backups/mydb.tar.gz --http-host localhost --http-port 27018 -u admin -p secret
+# Tab completes .tar.gz file paths
+```
+
+### Features
+
+- **All 23 commands:** database, collection, document CRUD, aggregation, indexing, export, import
+- **Interactive REPL:** MongoDB shell syntax (`use`, `show dbs`, `db.coll.find()`)
+- **Export & Import:** backup/restore databases via HTTP API, tab-completes file paths
+- **TLS support:** `--tls`, `--tls-cert`, `--tls-skip-verify`
+- **Auth support:** `-u` / `-p` flags (TCP and HTTP)
+- **JSON output:** `--output json` for scripting
+- **Tab autocomplete** in REPL mode and file path completion
+
+👉 **[Full CLI Documentation](https://github.com/nexoral/AxioDB/tree/main/cli)**
+
+---
+
 ## 🔧 Troubleshooting
 
 ### "Not connected to server" right after calling `connect()`

package/cli/VERSION

@@ -1 +1 @@
-16.2.0
+17.0.0

package/cli/cmd/db_export.go

@@ -0,0 +1,66 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/nexoral/axiodb-cli/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var exportCmd = &cobra.Command{
+	Use:   "export <dbname>",
+	Short: "Export a database to a .tar.gz file via HTTP",
+	Long:  "Export an AxioDB database to a .tar.gz archive. Uses the HTTP API (port 27018), not TCP.",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		dbName := args[0]
+		cfg, err := config.FromFlags(cmd)
+		if err != nil {
+			return err
+		}
+
+		if cfg.Username == "" || cfg.Password == "" {
+			return fmt.Errorf("username and password required for HTTP auth (-u, -p)")
+		}
+
+		client := cfg.NewHTTPClient()
+
+		fmt.Fprintf(os.Stderr, "Logging in to %s:%d...\n", cfg.HTTPHost, cfg.HTTPPort)
+		if err := client.Login(cfg.Username, cfg.Password); err != nil {
+			return err
+		}
+		defer client.Logout()
+
+		fmt.Fprintf(os.Stderr, "Exporting %s...\n", dbName)
+		filename, size, err := client.Export(dbName)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(os.Stderr, "Exported %s (%s)\n", filename, formatBytes(size))
+		return nil
+	},
+}
+
+func formatBytes(bytes int64) string {
+	const (
+		KB = 1024
+		MB = 1024 * KB
+		GB = 1024 * MB
+	)
+	switch {
+	case bytes >= GB:
+		return fmt.Sprintf("%.1f GB", float64(bytes)/float64(GB))
+	case bytes >= MB:
+		return fmt.Sprintf("%.1f MB", float64(bytes)/float64(MB))
+	case bytes >= KB:
+		return fmt.Sprintf("%.1f KB", float64(bytes)/float64(KB))
+	default:
+		return fmt.Sprintf("%d B", bytes)
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(exportCmd)
+}

package/cli/cmd/db_import.go

@@ -0,0 +1,84 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/nexoral/axiodb-cli/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var importCmd = &cobra.Command{
+	Use:   "import <file>",
+	Short: "Import a database from a .tar.gz file via HTTP",
+	Long:  "Import an AxioDB database from a .tar.gz archive. Uses the HTTP API (port 27018), not TCP.",
+	Args:  cobra.ExactArgs(1),
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		dir := "."
+		prefix := toComplete
+
+		if idx := strings.LastIndex(toComplete, "/"); idx >= 0 {
+			dir = toComplete[:idx+1]
+			prefix = toComplete[idx+1:]
+		}
+
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+
+		var completions []string
+		for _, entry := range entries {
+			if entry.IsDir() {
+				continue
+			}
+			name := entry.Name()
+			if strings.HasPrefix(name, prefix) && strings.HasSuffix(name, ".tar.gz") {
+				completions = append(completions, filepath.Join(dir, name))
+			}
+		}
+		return completions, cobra.ShellCompDirectiveNoFileComp
+	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		filePath := args[0]
+		cfg, err := config.FromFlags(cmd)
+		if err != nil {
+			return err
+		}
+
+		if cfg.Username == "" || cfg.Password == "" {
+			return fmt.Errorf("username and password required for HTTP auth (-u, -p)")
+		}
+
+		info, err := os.Stat(filePath)
+		if err != nil {
+			return fmt.Errorf("file not found: %s", filePath)
+		}
+		if info.IsDir() {
+			return fmt.Errorf("not a file: %s", filePath)
+		}
+
+		client := cfg.NewHTTPClient()
+
+		fmt.Fprintf(os.Stderr, "Logging in to %s:%d...\n", cfg.HTTPHost, cfg.HTTPPort)
+		if err := client.Login(cfg.Username, cfg.Password); err != nil {
+			return err
+		}
+		defer client.Logout()
+
+		fmt.Fprintf(os.Stderr, "Importing %s...\n", filepath.Base(filePath))
+		dbName, err := client.Import(filePath)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(os.Stderr, "Imported database: %s\n", dbName)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(importCmd)
+}

package/cli/cmd/root.go

@@ -33,4 +33,6 @@ func init() {
 	rootCmd.PersistentFlags().Int("timeout", 30, "Request timeout in seconds")
 	rootCmd.PersistentFlags().String("db", "", "Database name")
 	rootCmd.PersistentFlags().String("collection", "", "Collection name")
+	rootCmd.PersistentFlags().String("http-host", "localhost", "HTTP server host (for export/import)")
+	rootCmd.PersistentFlags().Int("http-port", 27018, "HTTP server port (for export/import)")
 }

package/cli/internal/config/config.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/nexoral/axiodb-cli/pkg/httpclient"
 	"github.com/nexoral/axiodb-cli/pkg/protocol"
 	"github.com/spf13/cobra"
 )
@@ -23,6 +24,8 @@ type Config struct {
 	Timeout       int
 	DB            string
 	Collection    string
+	HTTPHost      string
+	HTTPPort      int
 }
 
 func FromFlags(cmd *cobra.Command) (*Config, error) {
@@ -40,6 +43,8 @@ func FromFlags(cmd *cobra.Command) (*Config, error) {
 	cfg.Timeout, _ = cmd.Flags().GetInt("timeout")
 	cfg.DB, _ = cmd.Flags().GetString("db")
 	cfg.Collection, _ = cmd.Flags().GetString("collection")
+	cfg.HTTPHost, _ = cmd.Flags().GetString("http-host")
+	cfg.HTTPPort, _ = cmd.Flags().GetInt("http-port")
 
 	if cfg.ConnString != "" {
 		host, port, err := parseConnectionString(cfg.ConnString)
@@ -109,3 +114,7 @@ func GetCollectionContext(cmd *cobra.Command) string {
 	coll, _ := cmd.Flags().GetString("collection")
 	return coll
 }
+
+func (c *Config) NewHTTPClient() *httpclient.HTTPClient {
+	return httpclient.New(c.HTTPHost, c.HTTPPort, time.Duration(c.Timeout)*time.Second)
+}

package/cli/pkg/httpclient/client.go

@@ -0,0 +1,160 @@
+package httpclient
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type HTTPClient struct {
+	baseURL    string
+	httpClient *http.Client
+}
+
+func New(host string, port int, timeout time.Duration) *HTTPClient {
+	jar, _ := cookiejar.New(nil)
+	return &HTTPClient{
+		baseURL: fmt.Sprintf("http://%s:%d", host, port),
+		httpClient: &http.Client{
+			Timeout: timeout,
+			Jar:     jar,
+		},
+	}
+}
+
+func (c *HTTPClient) Login(username, password string) error {
+	body, _ := json.Marshal(map[string]string{
+		"username": username,
+		"password": password,
+	})
+
+	resp, err := c.httpClient.Post(c.baseURL+"/api/auth/login", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("login request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		return nil
+	}
+
+	var errResp struct {
+		Message string `json:"message"`
+	}
+	json.NewDecoder(resp.Body).Decode(&errResp)
+	msg := errResp.Message
+	if msg == "" {
+		msg = resp.Status
+	}
+	return fmt.Errorf("login failed: %s", msg)
+}
+
+func (c *HTTPClient) Logout() error {
+	resp, err := c.httpClient.Post(c.baseURL+"/api/auth/logout", "application/json", nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return nil
+}
+
+func (c *HTTPClient) Export(dbName string) (string, int64, error) {
+	url := fmt.Sprintf("%s/api/db/export-database/?dbName=%s", c.baseURL, dbName)
+	resp, err := c.httpClient.Get(url)
+	if err != nil {
+		return "", 0, fmt.Errorf("export request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		var errResp struct {
+			Message string `json:"message"`
+		}
+		json.NewDecoder(resp.Body).Decode(&errResp)
+		msg := errResp.Message
+		if msg == "" {
+			msg = resp.Status
+		}
+		return "", 0, fmt.Errorf("export failed: %s", msg)
+	}
+
+	filename := dbName + ".tar.gz"
+	if cd := resp.Header.Get("Content-Disposition"); cd != "" {
+		if idx := strings.Index(cd, "filename="); idx >= 0 {
+			name := cd[idx+9:]
+			name = strings.Trim(name, "\"")
+			if name != "" {
+				filename = filepath.Base(name)
+			}
+		}
+	}
+
+	out, err := os.Create(filename)
+	if err != nil {
+		return "", 0, fmt.Errorf("create file: %w", err)
+	}
+	defer out.Close()
+
+	written, err := io.Copy(out, resp.Body)
+	if err != nil {
+		os.Remove(filename)
+		return "", 0, fmt.Errorf("write file: %w", err)
+	}
+
+	return filename, written, nil
+}
+
+func (c *HTTPClient) Import(filePath string) (string, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return "", fmt.Errorf("open file: %w", err)
+	}
+	defer file.Close()
+
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
+	if err != nil {
+		return "", fmt.Errorf("create form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		return "", fmt.Errorf("write form data: %w", err)
+	}
+	writer.Close()
+
+	resp, err := c.httpClient.Post(
+		c.baseURL+"/api/db/import-database/",
+		writer.FormDataContentType(),
+		&body,
+	)
+	if err != nil {
+		return "", fmt.Errorf("import request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var result struct {
+		Message  string `json:"message"`
+		Database string `json:"database"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("parse response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		msg := result.Message
+		if msg == "" {
+			msg = fmt.Sprintf("HTTP %d", resp.StatusCode)
+		}
+		return "", fmt.Errorf("import failed: %s", msg)
+	}
+
+	return result.Database, nil
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axiodb",
-  "version": "16.2.0",
+  "version": "17.0.0",
   "description": "The Pure JavaScript Alternative to SQLite. Embedded NoSQL database for Node.js with MongoDB-style queries, zero native dependencies, built-in InMemoryCache, and web GUI. Perfect for desktop apps, CLI tools, and embedded systems. No compilation, no platform issues—pure JavaScript from npm install to production.",
   "main": "./lib/config/DB.js",
   "types": "./lib/config/DB.d.ts",