@involvex/syncstuff-cli 0.0.1

package/.eslintignore

@@ -0,0 +1 @@
+eslint.config.ts

package/.prettierrc

@@ -0,0 +1,12 @@
+{
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "jsxBracketSameLine": false,
+  "arrowParens": "avoid",
+  "plugins": ["prettier-plugin-organize-imports"]
+}

package/Readme.md

@@ -0,0 +1,98 @@
+# SyncStuff CLI
+
+SyncStuff CLI is a command line interface for the [SyncStuff](https://syncstuff-web.involvex.workers.dev/) service.
+
+[![npm version](https://badge.fury.io/js/@involvex%2Fsyncstuff-cli.svg)](https://badge.fury.io/js/@involvex%2Fsyncstuff-cli)
+
+## Installation
+
+```bash
+npm install -g @involvex/syncstuff-cli
+```
+
+## Usage
+
+```bash
+syncstuff help              # Show help
+syncstuff help <command>    # Show help for a specific command
+syncstuff --version / -v    # Show CLI version
+```
+
+### Global Flags
+
+All commands support the following global flags:
+
+| Flag          | Description                           |
+| ------------- | ------------------------------------- |
+| `-h, --help`  | Show help for any command             |
+| `-d, --debug` | Enable debug mode with verbose output |
+
+**Examples:**
+
+```bash
+syncstuff devices -d        # List devices with debug output
+syncstuff device -h         # Show help for device command
+syncstuff --debug login     # Login with debug output
+```
+
+### Authentication
+
+```bash
+syncstuff login             # Login to your account
+syncstuff whoami            # Display your user profile
+syncstuff logout            # Logout from your account
+```
+
+### Device Management
+
+```bash
+# List all devices
+syncstuff devices
+
+# Device command with subcommands
+syncstuff device --list     # List available devices (alias: -l)
+syncstuff device            # Interactive device selection
+syncstuff device <id>       # Connect to a specific device by ID
+```
+
+### File Transfer
+
+```bash
+syncstuff transfer <file>   # Transfer a file to a connected device
+```
+
+## Debug Mode
+
+Enable debug mode to see detailed output including API requests, config state, and command execution details:
+
+```bash
+syncstuff -d devices        # Debug flag before command
+syncstuff devices -d        # Debug flag after command
+```
+
+## Sponsor
+
+[![Sponsor](https://img.shields.io/badge/Sponsor-involvex-ff69b4)](https://github.com/sponsors/involvex)
+
+## Author
+
+[![GitHub](https://img.shields.io/badge/GitHub-involvex-000000)](https://github.com/involvex)
+
+## License
+
+MIT
+
+## Changelog
+
+- 0.0.1
+  - Initial release
+
+## Contributing
+
+Contributions are welcome! Please read our [contributing guidelines](CONTRIBUTING.md) for more information.
+
+## Support
+
+Support the development of SyncStuff CLI by sponsoring [involvex](https://github.com/sponsors/involvex).
+or on PayPal: [involvex](https://paypal.me/involvex)
+Buy me a coffee: [involvex](https://www.buymeacoffee.com/involvex)

package/bunfig.toml

@@ -0,0 +1,26 @@
+[build]
+# Build output directory
+outdir = "dist"
+
+# Minification
+minify = true
+
+# Source maps
+# sourcemap = true
+
+# Target environment
+target = "node"
+ 
+[run]
+# Node.js compatibility mode
+compat = "node"
+
+# Loader configuration for file types
+loader = {
+  ".css" = "css",
+  ".js" = "jsx", 
+  ".ts" = "tsx",
+  ".tsx" = "tsx",
+  ".json" = "json",
+  ".txt" = "text"
+}

package/eslint.config.ts

@@ -0,0 +1,61 @@
+import js from "@eslint/js";
+// import globals from "globals";
+import json from "@eslint/json";
+import { defineConfig, globalIgnores } from "eslint/config";
+import tseslint from "typescript-eslint";
+
+export default defineConfig([
+  globalIgnores([
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/bin/**",
+  ]),
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    ignores: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/coverage/**",
+      "**/bin/**",
+    ],
+
+    plugins: { js },
+    extends: ["js/recommended"],
+    languageOptions: {
+      globals: {
+        window: "readonly",
+        document: "readonly",
+        console: "readonly",
+        localStorage: "readonly",
+        module: "readonly",
+        setTimeout: "readonly",
+        clearTimeout: "readonly",
+        setInterval: "readonly",
+        clearInterval: "readonly",
+        IntersectionObserver: "readonly",
+        navigator: "readonly",
+        fetch: "readonly",
+        node: "readonly",
+      },
+    },
+  },
+  tseslint.configs.recommended,
+  {
+    files: ["**/*.jsonc"],
+    plugins: { json },
+    language: "json/jsonc",
+    extends: ["json/recommended"],
+  },
+  {
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      parserOptions: {
+        tsconfigRootDir: import.meta.dirname,
+        project: "./tsconfig.json",
+      },
+    },
+  },
+]);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@involvex/syncstuff-cli",
+  "version": "0.0.1",
+  "type": "module",
+  "homepage": "https://syncstuff-web.involvex.workers.dev/",
+  "sponsor": {
+    "url": "https://github.com/sponsors/involvex"
+  },
+  "author": {
+    "name": "involvex"
+  },
+  "bin": {
+    "syncstuff": "src/cli/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/cli/index.ts",
+    "build": "bun build --target node --outfile dist/cli.js src/cli/index.ts",
+    "lint": "eslint src ",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "prebuild": "bun run format && bun run lint:fix && bun run typecheck",
+    "prepublish": "bun run build"
+  },
+  "dependencies": {
+    "@types/node": "25.0.3",
+    "chalk": "5.6.2",
+    "inquirer": "13.1.0",
+    "ora": "9.0.0",
+    "boxen": "8.0.1",
+    "table": "6.9.0"
+  },
+  "devDependencies": {
+    "@eslint/css": "0.14.1",
+    "@eslint/js": "9.39.2",
+    "@eslint/json": "0.14.0",
+    "@types/bun": "1.3.5",
+    "@types/inquirer": "9.0.9",
+    "eslint": "9.39.2",
+    "globals": "17.0.0",
+    "prettier": "3.7.4",
+    "prettier-plugin-organize-imports": "4.3.0",
+    "typescript-eslint": "8.52.0"
+  },
+  "peerDependencies": {
+    "typescript": "5.9.3"
+  }
+}

package/src/cli/commands/debug.ts

@@ -0,0 +1,9 @@
+import type { DebugMode } from "../../core";
+
+export const showDebug = (debugMode: DebugMode) => {
+  if (!debugMode.enabled) {
+    return;
+  } else {
+    console.log("Debug mode enabled");
+  }
+};

package/src/cli/commands/device.ts

@@ -0,0 +1,224 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { apiClient, type Device } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import {
+  createSpinner,
+  createTable,
+  error,
+  info,
+  printHeader,
+  printSeparator,
+  success,
+  warning,
+} from "../../utils/ui.js";
+
+/**
+ * Device command - connect to a specific device or list available devices
+ * Usage:
+ *   device --list / -l    List available devices
+ *   device <deviceId>     Connect to a specific device
+ *   device                Interactive device selection
+ */
+export async function device(
+  args: string[],
+  ctx: CommandContext,
+): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Device command called with args:", args);
+
+  // Check for --list flag
+  if (args.includes("--list") || args.includes("-l")) {
+    await listAvailableDevices(ctx);
+    return;
+  }
+
+  // Check authentication
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in. Please run 'syncstuff login' first.");
+    process.exit(1);
+  }
+
+  const deviceId = args.find(arg => !arg.startsWith("-"));
+
+  if (deviceId) {
+    await connectToDevice(deviceId, ctx);
+  } else {
+    await interactiveDeviceSelect(ctx);
+  }
+}
+
+/**
+ * List all available devices
+ */
+async function listAvailableDevices(ctx: CommandContext): Promise<Device[]> {
+  debugLog(ctx, "Fetching available devices...");
+
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in. Please run 'syncstuff login' first.");
+    process.exit(1);
+  }
+
+  const spinner = createSpinner("Fetching devices...");
+  spinner.start();
+
+  try {
+    const response = await apiClient.getDevices();
+    debugLog(ctx, "API response:", response);
+
+    if (response.success && response.data) {
+      spinner.succeed("Devices loaded");
+      printSeparator();
+
+      if (response.data.length === 0) {
+        info("No devices found. Connect a device to get started.");
+        printSeparator();
+        return [];
+      }
+
+      const tableData = response.data.map(device => [
+        device.id.substring(0, 8) + "...",
+        device.name,
+        device.type,
+        device.platform,
+        device.is_online ? chalk.green("Online") : chalk.red("Offline"),
+        new Date(device.last_seen).toLocaleString(),
+      ]);
+
+      const table = createTable(tableData, [
+        "ID",
+        "Name",
+        "Type",
+        "Platform",
+        "Status",
+        "Last Seen",
+      ]);
+
+      console.log(table);
+      printSeparator();
+      success(`Found ${response.data.length} device(s)`);
+      printSeparator();
+
+      return response.data;
+    } else {
+      spinner.fail("Failed to fetch devices");
+      if (
+        response.error?.includes("404") ||
+        response.error?.includes("Not found")
+      ) {
+        info("Devices endpoint not yet implemented in API");
+        info("This feature will be available soon!");
+      } else {
+        error(response.error || "Unknown error");
+      }
+      return [];
+    }
+  } catch (err) {
+    spinner.fail("Error fetching devices");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    debugLog(ctx, "Full error:", err);
+    return [];
+  }
+}
+
+/**
+ * Connect to a specific device by ID
+ */
+async function connectToDevice(
+  deviceId: string,
+  ctx: CommandContext,
+): Promise<void> {
+  debugLog(ctx, "Connecting to device:", deviceId);
+
+  const spinner = createSpinner(`Connecting to device ${deviceId}...`);
+  spinner.start();
+
+  try {
+    // First, verify the device exists
+    const response = await apiClient.getDevices();
+    debugLog(ctx, "Devices response:", response);
+
+    if (!response.success || !response.data) {
+      spinner.fail("Failed to fetch devices");
+      error(response.error || "Could not retrieve device list");
+      return;
+    }
+
+    const targetDevice = response.data.find(
+      d => d.id === deviceId || d.id.startsWith(deviceId),
+    );
+
+    if (!targetDevice) {
+      spinner.fail("Device not found");
+      error(`No device found with ID: ${deviceId}`);
+      info("Run 'syncstuff device --list' to see available devices");
+      return;
+    }
+
+    if (!targetDevice.is_online) {
+      spinner.warn("Device is offline");
+      warning(`Device "${targetDevice.name}" is currently offline`);
+      info("The device must be running SyncStuff to connect");
+      return;
+    }
+
+    // TODO: Implement actual WebRTC/signaling connection
+    spinner.succeed(`Connected to "${targetDevice.name}"`);
+    printSeparator();
+
+    console.log(chalk.cyan("Device Details:"));
+    console.log(`  Name:     ${targetDevice.name}`);
+    console.log(`  ID:       ${targetDevice.id}`);
+    console.log(`  Platform: ${targetDevice.platform}`);
+    console.log(`  Type:     ${targetDevice.type}`);
+    console.log(
+      `  Status:   ${targetDevice.is_online ? chalk.green("Online") : chalk.red("Offline")}`,
+    );
+
+    printSeparator();
+    info("Connection established. Ready for file transfer.");
+    info("Use 'syncstuff transfer <file>' to send files to this device.");
+    printSeparator();
+  } catch (err) {
+    spinner.fail("Connection failed");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    debugLog(ctx, "Full error:", err);
+  }
+}
+
+/**
+ * Interactive device selection
+ */
+async function interactiveDeviceSelect(ctx: CommandContext): Promise<void> {
+  debugLog(ctx, "Starting interactive device selection");
+
+  const devices = await listAvailableDevices(ctx);
+
+  if (devices.length === 0) {
+    return;
+  }
+
+  const onlineDevices = devices.filter(d => d.is_online);
+
+  if (onlineDevices.length === 0) {
+    warning("No online devices available to connect to");
+    info("Make sure SyncStuff is running on your other devices");
+    return;
+  }
+
+  printSeparator();
+
+  const { selectedDevice } = await inquirer.prompt<{ selectedDevice: string }>([
+    {
+      type: "list",
+      name: "selectedDevice",
+      message: "Select a device to connect to:",
+      choices: onlineDevices.map(d => ({
+        name: `${d.name} (${d.platform}) - ${d.type}`,
+        value: d.id,
+      })),
+    },
+  ]);
+
+  await connectToDevice(selectedDevice, ctx);
+}

package/src/cli/commands/devices.ts

@@ -0,0 +1,78 @@
+import chalk from "chalk";
+import { apiClient } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import {
+  createSpinner,
+  createTable,
+  error,
+  info,
+  printHeader,
+  printSeparator,
+  success,
+} from "../../utils/ui.js";
+
+export async function listDevices(ctx: CommandContext): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Fetching devices list");
+
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in. Please run 'syncstuff login' first.");
+    process.exit(1);
+  }
+
+  const spinner = createSpinner("Fetching devices...");
+  spinner.start();
+
+  try {
+    const response = await apiClient.getDevices();
+
+    if (response.success && response.data) {
+      spinner.succeed("Devices loaded");
+      printSeparator();
+
+      if (response.data.length === 0) {
+        info("No devices found. Connect a device to get started.");
+        printSeparator();
+        return;
+      }
+
+      const tableData = response.data.map(device => [
+        device.id.substring(0, 8) + "...",
+        device.name,
+        device.type,
+        device.platform,
+        device.is_online ? chalk.green("Online") : chalk.red("Offline"),
+        new Date(device.last_seen).toLocaleString(),
+      ]);
+
+      const table = createTable(tableData, [
+        "ID",
+        "Name",
+        "Type",
+        "Platform",
+        "Status",
+        "Last Seen",
+      ]);
+
+      console.log(table);
+      printSeparator();
+      success(`Found ${response.data.length} device(s)`);
+      printSeparator();
+    } else {
+      spinner.fail("Failed to fetch devices");
+      if (
+        response.error?.includes("404") ||
+        response.error?.includes("Not found")
+      ) {
+        info("Devices endpoint not yet implemented in API");
+        info("This feature will be available soon!");
+      } else {
+        error(response.error || "Unknown error");
+      }
+    }
+  } catch (err) {
+    spinner.fail("Error fetching devices");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}