@scriptdb/cli 1.0.0

package/README.md

@@ -0,0 +1,155 @@
+# ScriptDB CLI
+
+Command-line interface for ScriptDB - Database management with TypeScript scripting.
+
+## Installation
+
+### From Binary (Info Only)
+
+Pre-built binaries are available for download:
+
+- **Linux x64**: `scriptdb-linux-x64`
+- **Linux ARM64**: `scriptdb-linux-arm64`
+- **Linux x64 (musl)**: `scriptdb-linux-x64-musl`
+- **Linux ARM64 (musl)**: `scriptdb-linux-arm64-musl`
+- **macOS x64 (Intel)**: `scriptdb-darwin-x64`
+- **macOS ARM64 (Apple Silicon)**: `scriptdb-darwin-arm64`
+- **Windows x64**: `scriptdb-windows-x64.exe`
+
+**Note**: These binaries are standalone info-only builds. They show help/version but don't include server functionality. For full functionality, install from source.
+
+Make it executable (Linux/macOS):
+```bash
+chmod +x scriptdb-*
+sudo mv scriptdb-* /usr/local/bin/scriptdb
+```
+
+### From Source (Recommended for Full Functionality)
+
+```bash
+bun install
+bun run build:all
+```
+
+## Usage
+
+### Server Management
+
+Start the server in daemon mode (background):
+```bash
+scriptdb start -d
+```
+
+Start the server in foreground:
+```bash
+scriptdb start
+```
+
+Stop the server:
+```bash
+scriptdb stop
+```
+
+Restart the server:
+```bash
+scriptdb restart -d
+```
+
+Check server status:
+```bash
+scriptdb status
+```
+
+View server logs:
+```bash
+scriptdb logs
+```
+
+### Interactive Shell
+
+Start the interactive shell (requires server to be running):
+```bash
+scriptdb shell
+```
+
+Shell commands:
+- `.exit`, `.quit` - Exit the shell
+- `.help` - Show help
+- `.dbs` - List all databases
+- `.use <name>` - Switch to a database
+- `.create <name>` - Create a new database
+
+Execute TypeScript code:
+```bash
+> const x = 1 + 1
+> x
+2
+> [1,2,3].map(n => n * 2)
+[2, 4, 6]
+```
+
+### Configuration
+
+Configuration file: `~/.scriptdb/config.json`
+
+Example:
+```json
+{
+  "host": "localhost",
+  "port": 1234,
+  "users": [
+    {
+      "username": "admin",
+      "password": "your-password",
+      "hash": false
+    }
+  ],
+  "folder": "databases",
+  "secure": false
+}
+```
+
+## Building
+
+### Build for all platforms (local)
+
+```bash
+bun run build:binary
+```
+
+### Build using Docker (recommended for cross-platform)
+
+```bash
+bun run build:docker
+```
+
+This will build binaries for all platforms inside a Docker container.
+
+### Build for specific platform
+
+```bash
+bun run build:linux-x64
+bun run build:linux-arm64
+bun run build:windows-x64
+bun run build:darwin-x64
+bun run build:darwin-arm64
+bun run build:linux-x64-musl
+bun run build:linux-arm64-musl
+```
+
+## Development
+
+```bash
+bun run dev
+```
+
+## Files
+
+- PID file: `~/.scriptdb/scriptdb.pid`
+- Log file: `~/.scriptdb/scriptdb.log`
+- Config file: `~/.scriptdb/config.json`
+- Databases: `~/.scriptdb/databases/`
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,761 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { server } from "@scriptdb/server";
+import { spawn } from "child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// ../../node_modules/.bun/ps-list@9.0.0/node_modules/ps-list/index.js
+import process2 from "node:process";
+import fs from "node:fs";
+import { promisify } from "node:util";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import childProcess from "node:child_process";
+var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_MAX_BUFFER = 64000000;
+var MAXIMUM_PATH_COMBINATION_ATTEMPTS = 6;
+var execFile = promisify(childProcess.execFile);
+var PROCESS_FIELDS = {
+  CPU_PERCENT: "%cpu",
+  MEMORY_PERCENT: "%mem",
+  PROCESS_ID: "pid",
+  PARENT_PROCESS_ID: "ppid",
+  USER_ID: "uid",
+  START_TIME: "lstart",
+  COMMAND_NAME: "comm",
+  ARGUMENTS: "args"
+};
+var buildProcessCommandFlags = (includeAllUsersProcesses) => (includeAllUsersProcesses === false ? "" : "a") + "wwxo";
+var makeStartTime = (startTimeString) => {
+  if (!startTimeString) {
+    return;
+  }
+  const parsedDate = new Date(startTimeString);
+  return Number.isNaN(parsedDate.getTime()) ? undefined : parsedDate;
+};
+var extractExecutablePath = (commandLine) => {
+  if (!commandLine) {
+    return "";
+  }
+  if (!commandLine.startsWith("/") && !commandLine.startsWith('"')) {
+    return "";
+  }
+  if (commandLine.startsWith('"')) {
+    const quotedPathMatch = commandLine.match(/^"([^"]+)"/);
+    if (quotedPathMatch && fs.existsSync(quotedPathMatch[1])) {
+      return quotedPathMatch[1];
+    }
+    return "";
+  }
+  const commandParts = commandLine.split(" ");
+  const firstCommandToken = commandParts[0];
+  if (fs.existsSync(firstCommandToken)) {
+    return firstCommandToken;
+  }
+  const maximumCombinationAttempts = Math.min(commandParts.length, MAXIMUM_PATH_COMBINATION_ATTEMPTS);
+  for (let tokenCount = 2;tokenCount <= maximumCombinationAttempts; tokenCount++) {
+    const candidateExecutablePath = commandParts.slice(0, tokenCount).join(" ");
+    if (fs.existsSync(candidateExecutablePath)) {
+      return candidateExecutablePath;
+    }
+  }
+  return "";
+};
+var resolveExecutablePath = (operatingSystemPlatform, processId, commandLine) => {
+  if (operatingSystemPlatform === "linux" && processId) {
+    try {
+      const symbolicLink = fs.readlinkSync(`/proc/${processId}/exe`);
+      return symbolicLink.replace(/\s+\(deleted\)$/, "");
+    } catch {}
+  }
+  return extractExecutablePath(commandLine);
+};
+var parseNumericField = (fieldValue, parserFunction = Number.parseInt, defaultValue = 0) => {
+  if (!fieldValue) {
+    return defaultValue;
+  }
+  const parsedValue = parserFunction(fieldValue, 10);
+  return Number.isNaN(parsedValue) ? defaultValue : parsedValue;
+};
+var parseIntegerOrUndefined = (fieldValue) => {
+  if (fieldValue === undefined || fieldValue === "") {
+    return;
+  }
+  const parsedValue = Number.parseInt(fieldValue, 10);
+  return Number.isNaN(parsedValue) ? undefined : parsedValue;
+};
+var parseProcessFields = ({ processId, parentProcessId, userId, cpuUsage, memoryUsage, commandName, startTimeString, command }) => {
+  const parsedProcessId = parseNumericField(processId);
+  const parsedParentProcessId = parseNumericField(parentProcessId);
+  const parsedUserId = parseIntegerOrUndefined(userId);
+  const parsedCpuUsagePercentage = parseNumericField(cpuUsage, Number.parseFloat);
+  const parsedMemoryUsagePercentage = parseNumericField(memoryUsage, Number.parseFloat);
+  const resolvedExecutablePath = resolveExecutablePath(process2.platform, parsedProcessId, command);
+  const derivedProcessName = resolvedExecutablePath ? path.basename(resolvedExecutablePath) : commandName || "";
+  return {
+    pid: parsedProcessId,
+    ppid: parsedParentProcessId,
+    uid: parsedUserId,
+    cpu: parsedCpuUsagePercentage,
+    memory: parsedMemoryUsagePercentage,
+    name: derivedProcessName,
+    path: resolvedExecutablePath,
+    startTime: makeStartTime(startTimeString),
+    cmd: command || ""
+  };
+};
+var windows = async () => {
+  let binary;
+  switch (process2.arch) {
+    case "x64": {
+      binary = "fastlist-0.3.0-x64.exe";
+      break;
+    }
+    case "ia32": {
+      binary = "fastlist-0.3.0-x86.exe";
+      break;
+    }
+    case "arm64": {
+      throw new Error("Windows ARM64 is not supported yet.");
+    }
+    default: {
+      throw new Error(`Unsupported architecture: ${process2.arch}`);
+    }
+  }
+  const binaryPath = path.join(__dirname2, "vendor", binary);
+  const { stdout } = await execFile(binaryPath, {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    windowsHide: true,
+    encoding: "utf8"
+  });
+  return stdout.trim().split(/\r?\n/).map((line) => line.split("\t")).map(([processId, parentProcessId, processName]) => ({
+    pid: Number.parseInt(processId, 10),
+    ppid: Number.parseInt(parentProcessId, 10),
+    name: processName
+  }));
+};
+var nonWindowsFallbackMultipleCalls = async (options = {}) => {
+  const processDataByProcessId = {};
+  const processCommandFlags = buildProcessCommandFlags(options.all);
+  const fields = [
+    PROCESS_FIELDS.COMMAND_NAME,
+    PROCESS_FIELDS.ARGUMENTS,
+    PROCESS_FIELDS.PARENT_PROCESS_ID,
+    PROCESS_FIELDS.USER_ID,
+    PROCESS_FIELDS.CPU_PERCENT,
+    PROCESS_FIELDS.MEMORY_PERCENT,
+    PROCESS_FIELDS.START_TIME
+  ];
+  await Promise.all(fields.map(async (fieldName) => {
+    const { stdout } = await execFile("ps", [processCommandFlags, `${PROCESS_FIELDS.PROCESS_ID}=,${fieldName}=`], {
+      maxBuffer: DEFAULT_MAX_BUFFER,
+      encoding: "utf8",
+      env: {
+        ...process2.env,
+        LC_ALL: "C",
+        LANG: "C"
+      }
+    });
+    for (const line of stdout.trim().split(`
+`)) {
+      const trimmedLine = line.trim();
+      const spaceIndex = trimmedLine.indexOf(" ");
+      if (spaceIndex === -1) {
+        const processId2 = trimmedLine;
+        const fieldValue2 = "";
+        processDataByProcessId[processId2] ??= {};
+        processDataByProcessId[processId2][fieldName] = fieldValue2;
+        continue;
+      }
+      const processId = trimmedLine.slice(0, spaceIndex);
+      const fieldValue = trimmedLine.slice(spaceIndex + 1).trim();
+      processDataByProcessId[processId] ??= {};
+      processDataByProcessId[processId][fieldName] = fieldValue;
+    }
+  }));
+  return Object.entries(processDataByProcessId).filter(([, data]) => data[PROCESS_FIELDS.COMMAND_NAME] && data[PROCESS_FIELDS.PARENT_PROCESS_ID] !== undefined).map(([processId, data]) => parseProcessFields({
+    processId,
+    parentProcessId: data[PROCESS_FIELDS.PARENT_PROCESS_ID],
+    userId: data[PROCESS_FIELDS.USER_ID],
+    cpuUsage: data[PROCESS_FIELDS.CPU_PERCENT],
+    memoryUsage: data[PROCESS_FIELDS.MEMORY_PERCENT],
+    commandName: data[PROCESS_FIELDS.COMMAND_NAME],
+    startTimeString: data[PROCESS_FIELDS.START_TIME],
+    command: data[PROCESS_FIELDS.ARGUMENTS] ?? ""
+  }));
+};
+var nonWindowsCall = async (options = {}) => {
+  const processCommandFlags = buildProcessCommandFlags(options.all);
+  const executeFileOptions = {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    encoding: "utf8",
+    env: {
+      ...process2.env,
+      LC_ALL: "C",
+      LANG: "C"
+    }
+  };
+  const processFieldCommaSeparatedList = [
+    PROCESS_FIELDS.PROCESS_ID,
+    PROCESS_FIELDS.PARENT_PROCESS_ID,
+    PROCESS_FIELDS.USER_ID,
+    PROCESS_FIELDS.CPU_PERCENT,
+    PROCESS_FIELDS.MEMORY_PERCENT,
+    PROCESS_FIELDS.START_TIME,
+    PROCESS_FIELDS.COMMAND_NAME
+  ].map((fieldName) => `${fieldName}=`).join(",");
+  const commandFieldCommaSeparatedList = [
+    PROCESS_FIELDS.PROCESS_ID,
+    PROCESS_FIELDS.ARGUMENTS
+  ].map((fieldName) => `${fieldName}=`).join(",");
+  const processListingPromises = [
+    execFile("ps", [processCommandFlags, processFieldCommaSeparatedList], executeFileOptions),
+    execFile("ps", [processCommandFlags, commandFieldCommaSeparatedList], executeFileOptions)
+  ];
+  const [processOutput, commandOutput] = await Promise.all(processListingPromises);
+  const processLines = processOutput.stdout.trim().split(`
+`);
+  const commandLines = commandOutput.stdout.trim().split(`
+`);
+  const commandLinesByProcessId = {};
+  for (const line of commandLines) {
+    const trimmedLine = line.trim();
+    const spaceIndex = trimmedLine.indexOf(" ");
+    if (spaceIndex === -1) {
+      const processId2 = trimmedLine;
+      commandLinesByProcessId[processId2] = "";
+      continue;
+    }
+    const processId = trimmedLine.slice(0, spaceIndex);
+    const command = trimmedLine.slice(spaceIndex + 1).trim();
+    commandLinesByProcessId[processId] = command;
+  }
+  const processes = [];
+  for (const line of processLines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine) {
+      continue;
+    }
+    const processLineRegexMatch = trimmedLine.match(/^(\d+)\s+(\d+)\s+(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+)/);
+    if (!processLineRegexMatch) {
+      continue;
+    }
+    const [, processId, parentProcessId, userId, cpuUsage, memoryUsage, dateAndCommandPortion] = processLineRegexMatch;
+    const startTimeRegexMatch = dateAndCommandPortion.match(/^((?:\w{3}\s+){2}\d{1,2}\s+(?:\d{2}:){2}\d{2}\s+\d{4})\s+(.*)$/);
+    let startTimeString = "";
+    let processCommandName = dateAndCommandPortion;
+    if (startTimeRegexMatch) {
+      startTimeString = startTimeRegexMatch[1];
+      processCommandName = startTimeRegexMatch[2] || "";
+    }
+    processes.push(parseProcessFields({
+      processId,
+      parentProcessId,
+      userId,
+      cpuUsage,
+      memoryUsage,
+      commandName: processCommandName,
+      startTimeString,
+      command: commandLinesByProcessId[processId] ?? ""
+    }));
+  }
+  return processes;
+};
+var nonWindows = async (options = {}) => {
+  try {
+    return await nonWindowsCall(options);
+  } catch {
+    return nonWindowsFallbackMultipleCalls(options);
+  }
+};
+var psList = process2.platform === "win32" ? windows : nonWindows;
+var ps_list_default = psList;
+
+// src/shell.ts
+import { createInterface } from "readline";
+import Client from "@scriptdb/client";
+async function startShell(options) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "> "
+  });
+  console.log(`
+ScriptDB Shell`);
+  console.log("==============");
+  console.log(`Connecting to ${options.host}:${options.port}...`);
+  const username = await question(rl, "Username: ");
+  const password = await question(rl, "Password: ", true);
+  let client;
+  let token;
+  try {
+    client = new Client(`scriptdb://${options.host}:${options.port}`, {
+      secure: options.secure || false,
+      logger: {
+        debug: () => {},
+        info: () => {},
+        warn: console.warn,
+        error: console.error
+      }
+    });
+    await client.connect();
+    const loginResult = await client.execute({
+      action: "login",
+      data: { username, password }
+    });
+    if (loginResult.error) {
+      console.error(`
+✗ Login failed:`, loginResult.error);
+      await client.close();
+      rl.close();
+      return;
+    }
+    token = loginResult.token;
+    console.log(`
+✓ Connected successfully!`);
+    console.log(`
+Type your TypeScript code and press Enter to execute.`);
+    console.log("Commands: .exit, .quit, .help, .dbs, .use <name>, .create <name>");
+    console.log();
+    let currentDb;
+    rl.prompt();
+    rl.on("line", async (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        rl.prompt();
+        return;
+      }
+      if (trimmed === ".exit" || trimmed === ".quit") {
+        console.log("Goodbye!");
+        await client.close();
+        rl.close();
+        return;
+      }
+      if (trimmed === ".help") {
+        printShellHelp();
+        rl.prompt();
+        return;
+      }
+      if (trimmed === ".dbs") {
+        try {
+          const result = await client.execute({
+            action: "list-dbs",
+            data: { token }
+          });
+          if (result.error) {
+            console.error("Error:", result.error);
+          } else {
+            console.log(`
+Databases:`);
+            if (result.databases && result.databases.length > 0) {
+              result.databases.forEach((db) => {
+                const marker = db === currentDb ? " *" : "";
+                console.log(`  - ${db}${marker}`);
+              });
+            } else {
+              console.log("  (no databases)");
+            }
+            console.log();
+          }
+        } catch (err) {
+          console.error("Error:", err);
+        }
+        rl.prompt();
+        return;
+      }
+      if (trimmed.startsWith(".use ")) {
+        currentDb = trimmed.substring(5).trim();
+        console.log(`✓ Using database: ${currentDb}`);
+        rl.prompt();
+        return;
+      }
+      if (trimmed.startsWith(".create ")) {
+        const dbName = trimmed.substring(8).trim();
+        try {
+          const result = await client.execute({
+            action: "create-db",
+            data: { token, databaseName: dbName }
+          });
+          if (result.error) {
+            console.error("Error:", result.error);
+          } else {
+            console.log(`✓ Created database: ${dbName}`);
+            currentDb = dbName;
+          }
+        } catch (err) {
+          console.error("Error:", err);
+        }
+        rl.prompt();
+        return;
+      }
+      if (!currentDb) {
+        console.error("Error: No database selected. Use .use <name> or .create <name>");
+        rl.prompt();
+        return;
+      }
+      try {
+        const result = await client.execute({
+          action: "script-code",
+          data: {
+            token,
+            databaseName: currentDb,
+            code: trimmed
+          }
+        });
+        if (result.error) {
+          console.error("Error:", result.error);
+        } else {
+          if (result.result !== undefined) {
+            console.log(formatResult(result.result));
+          }
+        }
+      } catch (err) {
+        console.error("Error:", err.message || err);
+      }
+      rl.prompt();
+    });
+    rl.on("close", async () => {
+      console.log(`
+Goodbye!`);
+      await client.close();
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error(`
+✗ Connection failed:`, err.message || err);
+    rl.close();
+    process.exit(1);
+  }
+}
+function question(rl, prompt, silent = false) {
+  return new Promise((resolve) => {
+    if (silent) {
+      const stdin = process.stdin;
+      stdin.setRawMode?.(true);
+      process.stdout.write(prompt);
+      let password = "";
+      stdin.on("data", function onData(char) {
+        const c = char.toString();
+        if (c === `
+` || c === "\r" || c === "\x04") {
+          stdin.setRawMode?.(false);
+          stdin.removeListener("data", onData);
+          process.stdout.write(`
+`);
+          resolve(password);
+        } else if (c === "\x03") {
+          stdin.setRawMode?.(false);
+          process.exit(1);
+        } else if (c === "" || c === "\b") {
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else {
+          password += c;
+          process.stdout.write("*");
+        }
+      });
+    } else {
+      rl.question(prompt, (answer) => {
+        resolve(answer);
+      });
+    }
+  });
+}
+function formatResult(result) {
+  if (result === null)
+    return "null";
+  if (result === undefined)
+    return "undefined";
+  if (typeof result === "object") {
+    try {
+      return JSON.stringify(result, null, 2);
+    } catch {
+      return String(result);
+    }
+  }
+  return String(result);
+}
+function printShellHelp() {
+  console.log(`
+Shell Commands:
+  .exit, .quit      Exit the shell
+  .help             Show this help
+  .dbs              List all databases
+  .use <name>       Switch to a database
+  .create <name>    Create a new database
+
+Execute TypeScript:
+  Just type your code and press Enter
+
+Examples:
+  .create mydb
+  .use mydb
+  const x = 1 + 1
+  x
+  [1,2,3].map(n => n * 2)
+`);
+}
+
+// src/index.ts
+var PID_FILE = join(homedir(), ".scriptdb", "scriptdb.pid");
+var LOG_FILE = join(homedir(), ".scriptdb", "scriptdb.log");
+var CONFIG_FILE = join(homedir(), ".scriptdb", "config.json");
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const isDaemon = args.includes("-d") || args.includes("--daemon");
+  if (!command || command === "start") {
+    await startCommand(isDaemon);
+  } else if (command === "stop") {
+    await stopCommand();
+  } else if (command === "restart") {
+    await restartCommand(isDaemon);
+  } else if (command === "status") {
+    await statusCommand();
+  } else if (command === "logs") {
+    showLogs();
+  } else if (command === "shell") {
+    await shellCommand();
+  } else if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+  } else if (command === "version" || command === "--version" || command === "-v") {
+    printVersion();
+  } else {
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "scriptdb help" for usage information');
+    process.exit(1);
+  }
+}
+async function startCommand(daemon) {
+  const running = await isServerRunning();
+  if (running) {
+    console.error("ScriptDB server is already running");
+    console.log('Run "scriptdb status" to check status');
+    console.log('Run "scriptdb stop" to stop the server');
+    process.exit(1);
+  }
+  if (daemon) {
+    console.log("Starting ScriptDB server in daemon mode...");
+    startDaemon();
+  } else {
+    console.log("Starting ScriptDB server...");
+    try {
+      await server();
+    } catch (err) {
+      console.error("Failed to start server:", err);
+      process.exit(1);
+    }
+  }
+}
+function startDaemon() {
+  const child = spawn(process.execPath, [process.argv[1], "_run_server"], {
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const logStream = __require("fs").createWriteStream(LOG_FILE, { flags: "a" });
+  child.stdout?.pipe(logStream);
+  child.stderr?.pipe(logStream);
+  writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+  console.log(`ScriptDB server started with PID: ${child.pid}`);
+  console.log(`Logs: ${LOG_FILE}`);
+  console.log('Run "scriptdb status" to check status');
+  process.exit(0);
+}
+async function stopCommand() {
+  const running = await isServerRunning();
+  if (!running) {
+    console.log("ScriptDB server is not running");
+    return;
+  }
+  const pid = getPid();
+  if (!pid) {
+    console.error("Could not read PID file");
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Stopping ScriptDB server (PID: ${pid})...`);
+    let attempts = 0;
+    while (attempts < 30) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      try {
+        process.kill(pid, 0);
+        attempts++;
+      } catch {
+        break;
+      }
+    }
+    if (existsSync(PID_FILE)) {
+      unlinkSync(PID_FILE);
+    }
+    console.log("ScriptDB server stopped");
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      console.log("ScriptDB server is not running");
+      if (existsSync(PID_FILE)) {
+        unlinkSync(PID_FILE);
+      }
+    } else {
+      console.error("Failed to stop server:", err);
+      process.exit(1);
+    }
+  }
+}
+async function restartCommand(daemon) {
+  console.log("Restarting ScriptDB server...");
+  await stopCommand();
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  await startCommand(daemon);
+}
+async function statusCommand() {
+  const running = await isServerRunning();
+  const pid = getPid();
+  if (running && pid) {
+    console.log("✓ ScriptDB server is running");
+    console.log(`  PID: ${pid}`);
+    console.log(`  Logs: ${LOG_FILE}`);
+    try {
+      const processes = await ps_list_default();
+      const proc = processes.find((p) => p.pid === pid);
+      if (proc) {
+        if (proc.cpu !== undefined) {
+          console.log(`  CPU: ${proc.cpu.toFixed(1)}%`);
+        }
+        if (proc.memory !== undefined) {
+          console.log(`  Memory: ${(proc.memory / 1024 / 1024).toFixed(1)} MB`);
+        }
+      }
+    } catch {}
+  } else {
+    console.log("✗ ScriptDB server is not running");
+  }
+}
+function showLogs() {
+  if (!existsSync(LOG_FILE)) {
+    console.log("No logs found");
+    return;
+  }
+  const logs = readFileSync(LOG_FILE, "utf-8");
+  console.log(logs);
+}
+async function shellCommand() {
+  const running = await isServerRunning();
+  if (!running) {
+    console.error("✗ ScriptDB server is not running");
+    console.log("Start the server first with: scriptdb start -d");
+    process.exit(1);
+  }
+  let host = "localhost";
+  let port = 1234;
+  let secure = false;
+  if (existsSync(CONFIG_FILE)) {
+    try {
+      const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      if (config.host)
+        host = config.host;
+      if (config.port)
+        port = config.port;
+      if (config.secure)
+        secure = config.secure;
+    } catch {}
+  }
+  await startShell({ host, port, secure });
+}
+async function isServerRunning() {
+  const pid = getPid();
+  if (!pid)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getPid() {
+  if (!existsSync(PID_FILE))
+    return null;
+  try {
+    const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim());
+    return isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+if (process.argv[2] === "_run_server") {
+  server().catch((err) => {
+    console.error("Server error:", err);
+    process.exit(1);
+  });
+} else {
+  main().catch((err) => {
+    console.error("Unexpected error:", err);
+    process.exit(1);
+  });
+}
+function printHelp() {
+  console.log(`
+ScriptDB CLI - Database management with TypeScript scripting
+
+Usage:
+  scriptdb [command] [options]
+
+Commands:
+  start           Start the ScriptDB server
+    -d, --daemon  Run in background (daemon mode)
+  stop            Stop the running server
+  restart         Restart the server
+    -d, --daemon  Run in background after restart
+  status          Check server status
+  logs            Show server logs
+  shell           Start interactive shell (requires server running)
+  help            Show this help message
+  version         Show version information
+
+Examples:
+  scriptdb start -d       Start server in background
+  scriptdb status         Check if server is running
+  scriptdb shell          Start interactive shell
+  scriptdb stop           Stop the server
+  scriptdb restart -d     Restart in background
+  scriptdb logs           View server logs
+
+Configuration:
+  Configuration file: ~/.scriptdb/config.json
+
+  Example config.json:
+  {
+    "host": "localhost",
+    "port": 1234,
+    "users": [
+      {
+        "username": "admin",
+        "password": "your-password",
+        "hash": false
+      }
+    ],
+    "folder": "databases",
+    "secure": false
+  }
+
+Process Management:
+  - PID file: ~/.scriptdb/scriptdb.pid
+  - Log file: ~/.scriptdb/scriptdb.log
+`);
+}
+function printVersion() {
+  const version = "1.0.0";
+  console.log(`ScriptDB CLI v${version}`);
+}
+main().catch((err) => {
+  console.error("Unexpected error:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@scriptdb/cli",
+  "version": "1.0.0",
+  "description": "CLI tool to start and manage ScriptDB server",
+  "type": "module",
+  "bin": {
+    "scriptdb": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "bun --watch src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --external '@scriptdb/*'",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:all": "bun run build && bun run build:types",
+    "test": "bun test",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "scriptdb",
+    "cli",
+    "server",
+    "database"
+  ],
+  "devDependencies": {
+    "@types/bun": "^1.3.2",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "bun-types": "latest",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@scriptdb/server": "^1.0.0",
+    "@scriptdb/client": "^1.0.0",
+    "ps-list": "^9.0.0"
+  }
+}