@babylen/legion 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# Tanuki Legion
+
+Legion is a lightweight agent that connects your devices to Tanuki Cloud, enabling remote development and automation capabilities.
+
+## Installation
+
+### Quick Install
+
+```bash
+curl -sL https://tanuki.sabw.ru/install-legion | LEGION_TOKEN=your_token_here bash
+```
+
+### Manual Installation
+
+1. **Install dependencies:**
+
+```bash
+bun install
+```
+
+2. **Configure:**
+
+Create `~/.tanuki/config.json`:
+
+```json
+{
+  "token": "your_legion_token",
+  "serverUrl": "wss://tanuki.sabw.ru"
+}
+```
+
+Or set environment variables:
+
+```bash
+export LEGION_TOKEN=your_token_here
+export TANUKI_SERVER_URL=wss://tanuki.sabw.ru
+```
+
+3. **Run:**
+
+```bash
+bun run dev
+```
+
+## Features
+
+- 🔗 **Cloud Connection**: Seamlessly connect to Tanuki Cloud via WebSocket
+- 🛡️ **Secure Authentication**: Token-based authentication for device access
+- 🔄 **Auto-Reconnection**: Automatic reconnection on network interruptions
+- 📊 **Device Management**: Manage multiple devices from Tanuki Cloud dashboard
+
+## Configuration
+
+Configuration is stored in `~/.tanuki/config.json`:
+
+- `token`: Your Legion device token (required)
+- `serverUrl`: Tanuki Cloud server URL (default: `wss://tanuki.sabw.ru`)
+
+## Getting a Token
+
+1. Log in to [Tanuki Cloud](https://tanuki.sabw.ru)
+2. Go to Settings → Devices
+3. Click "Connect New Device"
+4. Copy the installation command or token
+
+## Development
+
+This project uses [Bun](https://bun.sh) as the JavaScript runtime.
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Type check
+bun run typecheck
+
+# Build
+bun run build
+```
+
+## License
+
+Proprietary - Tanuki Cloud

package/dist/index.js

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_socket = require("socket.io-client");
+var os3 = __toESM(require("os"));
+
+// src/core/config.ts
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_zod = require("zod");
+var ConfigSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  // Token ID from database (for faster lookup)
+  token: import_zod.z.string(),
+  // Secret token (lg_xxx format)
+  serverUrl: import_zod.z.string().url()
+});
+var HOME_DIR = import_os.default.homedir();
+var CONFIG_DIR = import_path.default.join(HOME_DIR, ".tanuki");
+var CONFIG_FILE = import_path.default.join(CONFIG_DIR, "config.json");
+async function loadConfig() {
+  try {
+    const content = await import_promises.default.readFile(CONFIG_FILE, "utf-8");
+    const data2 = JSON.parse(content);
+    return ConfigSchema.parse(data2);
+  } catch (error) {
+    return null;
+  }
+}
+async function getConfig() {
+  const fileConfig = await loadConfig();
+  const id = fileConfig?.id || process.env.LEGION_TOKEN_ID || void 0;
+  const token = fileConfig?.token || process.env.LEGION_TOKEN_SECRET || process.env.LEGION_TOKEN;
+  const serverUrl = fileConfig?.serverUrl || process.env.TANUKI_SERVER_URL || "wss://tanuki.sabw.ru";
+  if (!token) {
+    throw new Error(
+      "Legion token not found. Please set LEGION_TOKEN_SECRET (or LEGION_TOKEN) environment variable or configure ~/.tanuki/config.json"
+    );
+  }
+  const config2 = {
+    token,
+    serverUrl
+  };
+  if (id) {
+    config2.id = id;
+  }
+  return config2;
+}
+
+// src/util/log.ts
+var import_path3 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+
+// src/core/global.ts
+var import_os2 = __toESM(require("os"));
+var import_path2 = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"));
+var HOME_DIR2 = import_os2.default.homedir();
+var data = import_path2.default.join(HOME_DIR2, ".tanuki", "legion");
+var cache = import_path2.default.join(HOME_DIR2, ".tanuki", "legion", "cache");
+var config = import_path2.default.join(HOME_DIR2, ".tanuki");
+var state = import_path2.default.join(HOME_DIR2, ".tanuki", "legion", "state");
+var Global;
+((Global2) => {
+  Global2.Path = {
+    // Allow override via LEGION_TEST_HOME for test isolation
+    get home() {
+      return process.env.LEGION_TEST_HOME || import_os2.default.homedir();
+    },
+    data,
+    bin: import_path2.default.join(data, "bin"),
+    log: import_path2.default.join(data, "log"),
+    cache,
+    config,
+    state
+  };
+  async function init() {
+    await Promise.all([
+      import_promises2.default.mkdir(Global2.Path.data, { recursive: true }),
+      import_promises2.default.mkdir(Global2.Path.config, { recursive: true }),
+      import_promises2.default.mkdir(Global2.Path.state, { recursive: true }),
+      import_promises2.default.mkdir(Global2.Path.log, { recursive: true }),
+      import_promises2.default.mkdir(Global2.Path.bin, { recursive: true })
+    ]);
+  }
+  Global2.init = init;
+})(Global || (Global = {}));
+
+// src/util/log.ts
+var import_zod2 = __toESM(require("zod"));
+var Log;
+((Log2) => {
+  Log2.Level = import_zod2.default.enum(["DEBUG", "INFO", "WARN", "ERROR"]);
+  const levelPriority = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3
+  };
+  let level = "INFO";
+  function shouldLog(input) {
+    return levelPriority[input] >= levelPriority[level];
+  }
+  const loggers = /* @__PURE__ */ new Map();
+  Log2.Default = create({ service: "default" });
+  let logpath = "";
+  function file() {
+    return logpath;
+  }
+  Log2.file = file;
+  let write = (msg) => {
+    process.stderr.write(msg);
+    return msg.length;
+  };
+  let logStream = null;
+  async function init(options) {
+    if (options.level) level = options.level;
+    await Global.init().catch(() => {
+    });
+    cleanup(Global.Path.log).catch(() => {
+    });
+    if (options.print) return;
+    logpath = import_path3.default.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : (/* @__PURE__ */ new Date()).toISOString().split(".")[0].replace(/:/g, "") + ".log"
+    );
+    try {
+      await import_promises3.default.writeFile(logpath, "", { flag: "w" });
+      logStream = (0, import_fs.createWriteStream)(logpath, { flags: "a" });
+    } catch {
+    }
+    write = (msg) => {
+      if (logStream) {
+        const written = logStream.write(msg);
+        return written ? msg.length : 0;
+      }
+      process.stderr.write(msg);
+      return msg.length;
+    };
+  }
+  Log2.init = init;
+  async function cleanup(dir) {
+    try {
+      const files = await import_promises3.default.readdir(dir);
+      const logFiles = files.filter((f) => /^\d{4}-\d{2}-\d{2}T\d{6}\.log$/.test(f));
+      if (logFiles.length <= 5) return;
+      const filesToDelete = logFiles.slice(0, -10);
+      await Promise.all(filesToDelete.map((file2) => import_promises3.default.unlink(import_path3.default.join(dir, file2)).catch(() => {
+      })));
+    } catch {
+    }
+  }
+  function formatError(error, depth = 0) {
+    const result = error.message;
+    return error.cause instanceof Error && depth < 10 ? result + " Caused by: " + formatError(error.cause, depth + 1) : result;
+  }
+  let last = Date.now();
+  function create(tags) {
+    tags = tags || {};
+    const service = tags["service"];
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service);
+      if (cached) {
+        return cached;
+      }
+    }
+    function build(message, extra) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra
+      }).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
+        const prefix2 = `${key}=`;
+        if (value instanceof Error) return prefix2 + formatError(value);
+        if (typeof value === "object") return prefix2 + JSON.stringify(value);
+        return prefix2 + value;
+      }).join(" ");
+      const next = /* @__PURE__ */ new Date();
+      const diff = next.getTime() - last;
+      last = next.getTime();
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n";
+    }
+    const result = {
+      debug(message, extra) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra));
+        }
+      },
+      info(message, extra) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra));
+        }
+      },
+      error(message, extra) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra));
+        }
+      },
+      warn(message, extra) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra));
+        }
+      },
+      tag(key, value) {
+        if (tags) tags[key] = value;
+        return result;
+      },
+      clone() {
+        return Log2.create({ ...tags });
+      },
+      time(message, extra) {
+        const now = Date.now();
+        result.info(message, { status: "started", ...extra });
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra
+          });
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop();
+          }
+        };
+      }
+    };
+    if (service && typeof service === "string") {
+      loggers.set(service, result);
+    }
+    return result;
+  }
+  Log2.create = create;
+})(Log || (Log = {}));
+
+// src/index.ts
+var log = Log.create({ service: "legion" });
+async function main() {
+  try {
+    await Global.init();
+    log.info("\u{1F6E1}\uFE0F  Legion v0.1 starting...");
+    const config2 = await getConfig();
+    log.info("\u{1F517} Connecting to server", { serverUrl: config2.serverUrl });
+    const socket = (0, import_socket.io)(config2.serverUrl, {
+      auth: {
+        id: config2.id,
+        // Token ID for faster lookup (optional)
+        token: config2.token,
+        // Secret token for authentication
+        type: "legion"
+      },
+      transports: ["websocket"],
+      reconnection: true,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      reconnectionAttempts: Infinity
+    });
+    socket.on("connect", () => {
+      log.info("\u2705 Connected to server", { socketId: socket.id });
+      const handshakeData = {
+        hostname: os3.hostname(),
+        platform: os3.platform(),
+        release: os3.release(),
+        cwd: process.cwd()
+      };
+      socket.emit("legion:handshake", handshakeData);
+      log.debug("\u{1F4E4} Sent handshake", handshakeData);
+    });
+    socket.on("connect_error", (err) => {
+      log.error("\u274C Connection error", {
+        message: err.message,
+        type: err.type
+      });
+      if (err.message.includes("auth") || err.message.includes("token")) {
+        log.error("\u{1F510} Authentication failed. Please check your token.");
+        log.error("\u{1F4A1} Re-authenticate by updating ~/.tanuki/config.json or LEGION_TOKEN env var");
+        process.exit(1);
+      }
+    });
+    socket.on("disconnect", (reason) => {
+      log.warn("\u26A0\uFE0F  Disconnected from server", { reason });
+      if (reason === "io server disconnect") {
+        log.error("\u{1F6AB} Server disconnected this client. Please check your token.");
+        process.exit(1);
+      }
+    });
+    socket.on("server:ping", (data2) => {
+      log.debug("\u{1F4E9} Ping from server", data2);
+      socket.emit("legion:pong", { ts: Date.now() });
+    });
+    socket.on("reconnect", (attemptNumber) => {
+      log.info("\u{1F504} Reconnected to server", { attempt: attemptNumber });
+    });
+    socket.on("reconnect_attempt", (attemptNumber) => {
+      log.debug("\u{1F504} Reconnection attempt", { attempt: attemptNumber });
+    });
+    socket.on("reconnect_error", (error) => {
+      log.error("\u{1F504} Reconnection error", { message: error.message });
+    });
+    socket.on("reconnect_failed", () => {
+      log.error("\u{1F504} Reconnection failed after all attempts");
+      process.exit(1);
+    });
+    process.stdin.resume();
+    const shutdown = () => {
+      log.info("\u{1F6D1} Shutting down...");
+      socket.disconnect();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("unhandledRejection", (reason) => {
+      log.error("Unhandled rejection", { reason });
+    });
+    process.on("uncaughtException", (error) => {
+      log.error("Uncaught exception", { error: error.message, stack: error.stack });
+      shutdown();
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      log.error("Failed to start Legion", {
+        message: error.message,
+        stack: error.stack
+      });
+      console.error("\n\u274C", error.message);
+      console.error("\n\u{1F4A1} Make sure you have configured your token:");
+      console.error("   - Set LEGION_TOKEN environment variable, or");
+      console.error("   - Create ~/.tanuki/config.json with your token");
+    } else {
+      log.error("Failed to start Legion", { error });
+      console.error("\n\u274C Unknown error occurred");
+    }
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@babylen/legion",
+  "version": "0.1.0",
+  "description": "Legion agent for connecting devices to Tanuki Cloud",
+  "main": "./dist/index.js",
+  "keywords": [
+    "legion"
+  ],
+  "author": "",
+  "license": "PROPRIETARY",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "legion": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "dev": "bun run --conditions=browser ./src/index.ts",
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "socket.io-client": "^4.7.4",
+    "better-sqlite3": "^9.4.0",
+    "@opentui/core": "0.1.73",
+    "@opentui/solid": "0.1.73",
+    "solid-js": "^1.8.15",
+    "chokidar": "4.0.3",
+    "zod": "^3.22.4",
+    "bun-pty": "0.4.4",
+    "clipboardy": "4.0.0",
+    "diff": "^5.2.0",
+    "fuzzysort": "3.1.0",
+    "ignore": "7.0.5",
+    "jsonc-parser": "3.3.1",
+    "minimatch": "10.0.3",
+    "open": "10.1.2",
+    "opentui-spinner": "0.0.6",
+    "strip-ansi": "7.1.2",
+    "tree-sitter-bash": "0.25.0",
+    "turndown": "7.2.0",
+    "ulid": "^2.3.0",
+    "web-tree-sitter": "0.25.10",
+    "xdg-basedir": "5.1.0",
+    "yargs": "18.0.0"
+  },
+  "devDependencies": {
+    "@tsconfig/bun": "^1.0.4",
+    "@types/better-sqlite3": "^7.6.9",
+    "@types/bun": "latest",
+    "@types/node": "^25.0.9",
+    "@types/yargs": "17.0.33",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "trustedDependencies": [
+    "tree-sitter-bash"
+  ]
+}