@involvex/syncstuff-cli 0.0.1

package/src/cli/commands/help.ts

@@ -0,0 +1,159 @@
+import chalk from "chalk";
+import { createBox, printHeader, printSeparator } from "../../utils/ui.js";
+
+const commandHelp: Record<string, string> = {
+  login: `${chalk.cyan.bold("login")}
+
+Log in to your Syncstuff account.
+
+${chalk.bold("Usage:")}
+  syncstuff login
+
+${chalk.bold("Description:")}
+  Authenticates with the Syncstuff API using your email and password.
+  Your credentials are stored securely for future sessions.`,
+
+  logout: `${chalk.cyan.bold("logout")}
+
+Log out from your Syncstuff account.
+
+${chalk.bold("Usage:")}
+  syncstuff logout
+
+${chalk.bold("Description:")}
+  Clears your stored authentication credentials.`,
+
+  whoami: `${chalk.cyan.bold("whoami")}
+
+Display your user profile.
+
+${chalk.bold("Usage:")}
+  syncstuff whoami
+
+${chalk.bold("Description:")}
+  Shows information about the currently logged-in user.`,
+
+  devices: `${chalk.cyan.bold("devices")}
+
+List all your connected devices.
+
+${chalk.bold("Usage:")}
+  syncstuff devices
+
+${chalk.bold("Description:")}
+  Displays a table of all devices registered to your account,
+  including their status, platform, and last seen time.`,
+
+  device: `${chalk.cyan.bold("device")}
+
+Connect to a specific device or list available devices.
+
+${chalk.bold("Usage:")}
+  syncstuff device [options] [deviceId]
+
+${chalk.bold("Options:")}
+  --list, -l    List all available devices
+
+${chalk.bold("Examples:")}
+  syncstuff device --list       List all devices
+  syncstuff device              Interactive device selection
+  syncstuff device abc123       Connect to device with ID abc123`,
+
+  transfer: `${chalk.cyan.bold("transfer")}
+
+Transfer a file to a connected device.
+
+${chalk.bold("Usage:")}
+  syncstuff transfer <file>
+
+${chalk.bold("Description:")}
+  Sends the specified file to a connected device.
+  You must be connected to a device first.`,
+
+  version: `${chalk.cyan.bold("version")}
+
+Show CLI version.
+
+${chalk.bold("Usage:")}
+  syncstuff version
+  syncstuff --version
+  syncstuff -v`,
+};
+
+export async function showHelp(command?: string): Promise<void> {
+  printHeader();
+
+  // Show command-specific help if requested
+  if (command && commandHelp[command]) {
+    const helpContent = createBox(commandHelp[command], {
+      title: `Help: ${command}`,
+      titleAlignment: "center",
+      padding: 1,
+    });
+
+    console.log(helpContent);
+    printSeparator();
+    return;
+  }
+
+  // Show general help
+  const helpContent = createBox(
+    chalk.cyan.bold("Available Commands\n\n") +
+      chalk.bold("Authentication:\n") +
+      "  " +
+      chalk.green("login") +
+      "               Login to your Syncstuff account\n" +
+      "  " +
+      chalk.green("logout") +
+      "              Logout from your account\n" +
+      "  " +
+      chalk.green("whoami") +
+      "              Display your user profile\n\n" +
+      chalk.bold("Device Management:\n") +
+      "  " +
+      chalk.green("devices") +
+      "             List all your connected devices\n" +
+      "  " +
+      chalk.green("device --list") +
+      "       List available devices\n" +
+      "  " +
+      chalk.green("device <id>") +
+      "         Connect to a specific device\n" +
+      "  " +
+      chalk.green("transfer <file>") +
+      "     Transfer a file to a device\n\n" +
+      chalk.bold("General:\n") +
+      "  " +
+      chalk.green("help [command]") +
+      "      Show help (or command-specific help)\n" +
+      "  " +
+      chalk.green("version") +
+      "             Show CLI version\n\n" +
+      chalk.bold("Global Flags:\n") +
+      "  " +
+      chalk.yellow("-h, --help") +
+      "          Show help for any command\n" +
+      "  " +
+      chalk.yellow("-d, --debug") +
+      "         Enable debug mode\n\n" +
+      chalk.gray("Examples:\n") +
+      "  syncstuff devices -d     " +
+      chalk.gray("List devices with debug output\n") +
+      "  syncstuff device -h      " +
+      chalk.gray("Show help for device command"),
+    {
+      title: "Syncstuff CLI Help",
+      titleAlignment: "center",
+      padding: 1,
+    },
+  );
+
+  console.log(helpContent);
+  printSeparator();
+  console.log(
+    chalk.gray(
+      "For more information, visit: https://syncstuff-web.involvex.workers.dev/",
+    ),
+  );
+  printSeparator();
+}

package/src/cli/commands/login.ts

@@ -0,0 +1,69 @@
+import inquirer from "inquirer";
+import { apiClient } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import {
+  createSpinner,
+  error,
+  info,
+  printHeader,
+  printSeparator,
+  success,
+} from "../../utils/ui.js";
+
+export async function login(ctx: CommandContext): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Starting login flow");
+
+  try {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "email",
+        message: "Email address:",
+        validate: (input: string) => {
+          if (!input || !input.includes("@")) {
+            return "Please enter a valid email address";
+          }
+          return true;
+        },
+      },
+      {
+        type: "password",
+        name: "password",
+        message: "Password:",
+        mask: "*",
+        validate: (input: string) => {
+          if (!input || input.length < 1) {
+            return "Password cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    const spinner = createSpinner("Logging in...");
+    spinner.start();
+
+    const response = await apiClient.login(answers.email, answers.password);
+
+    if (response.success && response.data) {
+      spinner.succeed("Login successful!");
+      printSeparator();
+      success(
+        `Welcome, ${response.data.user.username || response.data.user.email}!`,
+      );
+      info(`Role: ${response.data.user.role}`);
+      if (response.data.user.full_name) {
+        info(`Name: ${response.data.user.full_name}`);
+      }
+      printSeparator();
+    } else {
+      spinner.fail("Login failed");
+      error(response.error || "Invalid credentials");
+      process.exit(1);
+    }
+  } catch (err) {
+    error(`Login error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/logout.ts

@@ -0,0 +1,23 @@
+import { apiClient } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import { error, printHeader, printSeparator, success } from "../../utils/ui.js";
+
+export async function logout(ctx: CommandContext): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Starting logout flow");
+
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in");
+    process.exit(1);
+  }
+
+  try {
+    await apiClient.logout();
+    printSeparator();
+    success("Logged out successfully");
+    printSeparator();
+  } catch (err) {
+    error(`Logout error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/transfer.ts

@@ -0,0 +1,148 @@
+import chalk from "chalk";
+import { existsSync, statSync } from "fs";
+import inquirer from "inquirer";
+import { resolve } from "path";
+import { apiClient } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import {
+  createSpinner,
+  error,
+  info,
+  printHeader,
+  printSeparator,
+  success,
+} from "../../utils/ui.js";
+
+export async function transferFile(
+  filePath: string | undefined,
+  ctx: CommandContext,
+): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Starting file transfer", { filePath });
+
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in. Please run 'syncstuff login' first.");
+    process.exit(1);
+  }
+
+  let targetFile = filePath;
+
+  // If no file path provided, prompt for it
+  if (!targetFile) {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "filePath",
+        message: "File path to transfer:",
+        validate: (input: string) => {
+          if (!input) {
+            return "Please enter a file path";
+          }
+          const resolved = resolve(input);
+          if (!existsSync(resolved)) {
+            return "File does not exist";
+          }
+          if (!statSync(resolved).isFile()) {
+            return "Path is not a file";
+          }
+          return true;
+        },
+      },
+    ]);
+    targetFile = answers.filePath;
+  }
+
+  if (!targetFile) {
+    error("No file path provided");
+    process.exit(1);
+  }
+
+  const resolvedPath = resolve(targetFile);
+
+  if (!existsSync(resolvedPath)) {
+    error(`File not found: ${resolvedPath}`);
+    process.exit(1);
+  }
+
+  if (!statSync(resolvedPath).isFile()) {
+    error(`Path is not a file: ${resolvedPath}`);
+    process.exit(1);
+  }
+
+  // Get file info
+  const stats = statSync(resolvedPath);
+  const fileSize = (stats.size / 1024 / 1024).toFixed(2);
+
+  info(`File: ${resolvedPath}`);
+  info(`Size: ${fileSize} MB`);
+
+  // Get device list
+  const devicesSpinner = createSpinner("Fetching devices...");
+  devicesSpinner.start();
+
+  const devicesResponse = await apiClient.getDevices();
+  devicesSpinner.stop();
+
+  if (
+    !devicesResponse.success ||
+    !devicesResponse.data ||
+    devicesResponse.data.length === 0
+  ) {
+    error(
+      "No devices available. Please ensure at least one device is connected.",
+    );
+    process.exit(1);
+  }
+
+  // Prompt for device selection
+  const deviceChoices = devicesResponse.data.map(device => ({
+    name: `${device.name} (${device.platform}) - ${device.is_online ? "Online" : "Offline"}`,
+    value: device.id,
+    disabled: !device.is_online ? "Offline" : false,
+  }));
+
+  const deviceAnswer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "deviceId",
+      message: "Select target device:",
+      choices: deviceChoices,
+    },
+  ]);
+
+  // Transfer file
+  const transferSpinner = createSpinner(
+    `Transferring ${chalk.cyan(resolvedPath)} to device...`,
+  );
+  transferSpinner.start();
+
+  try {
+    const transferResponse = await apiClient.transferFile(
+      deviceAnswer.deviceId,
+      resolvedPath,
+    );
+
+    if (transferResponse.success) {
+      transferSpinner.succeed("File transfer initiated!");
+      printSeparator();
+      success(`Transfer ID: ${transferResponse.data?.transferId || "N/A"}`);
+      info("File is being synced to the target device");
+      printSeparator();
+    } else {
+      transferSpinner.fail("Transfer failed");
+      if (
+        transferResponse.error?.includes("404") ||
+        transferResponse.error?.includes("Not found")
+      ) {
+        info("File transfer endpoint not yet implemented in API");
+        info("This feature will be available soon!");
+      } else {
+        error(transferResponse.error || "Unknown error");
+      }
+    }
+  } catch (err) {
+    transferSpinner.fail("Transfer error");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/version.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createBox, printHeader, printSeparator } from "../../utils/ui.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export function showversion() {
+  printHeader();
+
+  try {
+    const packagePath = join(__dirname, "../../../package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const version = packageJson.version || "0.0.1";
+
+    const versionBox = createBox(
+      chalk.cyan.bold("Syncstuff CLI\n\n") +
+        chalk.bold("Version:") +
+        ` ${chalk.green(version)}\n` +
+        chalk.bold("Package:") +
+        ` @involvex/syncstuff-cli`,
+      {
+        title: "Version Information",
+        titleAlignment: "center",
+      },
+    );
+
+    console.log(versionBox);
+    printSeparator();
+  } catch {
+    console.log(chalk.yellow("Version: 0.0.1 (unable to read package.json)"));
+  }
+}

package/src/cli/commands/whoami.ts

@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import { apiClient } from "../../utils/api-client.js";
+import { debugLog, type CommandContext } from "../../utils/context.js";
+import {
+  createBox,
+  createSpinner,
+  error,
+  printHeader,
+  printSeparator,
+} from "../../utils/ui.js";
+
+export async function whoami(ctx: CommandContext): Promise<void> {
+  printHeader();
+  debugLog(ctx, "Fetching user profile");
+
+  if (!apiClient.isAuthenticated()) {
+    error("You are not logged in. Please run 'syncstuff login' first.");
+    process.exit(1);
+  }
+
+  const spinner = createSpinner("Fetching user profile...");
+  spinner.start();
+
+  try {
+    const response = await apiClient.getProfile();
+
+    if (response.success && response.data) {
+      spinner.succeed("Profile loaded");
+      printSeparator();
+
+      const user = response.data;
+
+      const profileBox = createBox(
+        chalk.cyan.bold("User Profile\n\n") +
+          `${chalk.bold("ID:")}        ${user.id}\n` +
+          `${chalk.bold("Email:")}      ${user.email}\n` +
+          `${chalk.bold("Username:")}   ${user.username}\n` +
+          (user.full_name
+            ? `${chalk.bold("Full Name:")}  ${user.full_name}\n`
+            : "") +
+          `${chalk.bold("Role:")}       ${chalk.yellow(user.role)}\n` +
+          `${chalk.bold("Status:")}     ${chalk.green(user.status)}\n` +
+          `${chalk.bold("Created:")}    ${new Date(user.created_at).toLocaleString()}\n` +
+          `${chalk.bold("Updated:")}    ${new Date(user.updated_at).toLocaleString()}`,
+        {
+          title: "Syncstuff Account",
+          titleAlignment: "center",
+        },
+      );
+
+      console.log(profileBox);
+      printSeparator();
+    } else {
+      spinner.fail("Failed to fetch profile");
+      error(response.error || "Unknown error");
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail("Error fetching profile");
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { debugLog, parseArgs, type CommandContext } from "../utils/context.js";
+import { printHeader } from "../utils/ui.js";
+
+export async function run() {
+  const args = process.argv.slice(2);
+  const { command, flags, commandArgs } = parseArgs(args);
+
+  const ctx: CommandContext = { debug: flags.debug };
+
+  // Debug mode: log parsed arguments
+  debugLog(ctx, "Parsed arguments:", { command, flags, commandArgs });
+
+  // Handle help flag - show command-specific or general help
+  if (flags.help) {
+    const { showHelp } = await import("./commands/help.js");
+    await showHelp(command);
+    return;
+  }
+
+  // Handle no command
+  if (!command) {
+    const { showHelp } = await import("./commands/help.js");
+    await showHelp();
+    return;
+  }
+
+  switch (command) {
+    case "login":
+      {
+        const { login } = await import("./commands/login.js");
+        await login(ctx);
+      }
+      break;
+    case "whoami":
+      {
+        const { whoami } = await import("./commands/whoami.js");
+        await whoami(ctx);
+      }
+      break;
+    case "logout":
+      {
+        const { logout } = await import("./commands/logout.js");
+        await logout(ctx);
+      }
+      break;
+    case "devices":
+      {
+        const { listDevices } = await import("./commands/devices.js");
+        await listDevices(ctx);
+      }
+      break;
+    case "device":
+      {
+        const { device } = await import("./commands/device.js");
+        await device(commandArgs, ctx);
+      }
+      break;
+    case "transfer":
+      {
+        const { transferFile } = await import("./commands/transfer.js");
+        await transferFile(commandArgs[0], ctx);
+      }
+      break;
+    case "help":
+      {
+        const { showHelp } = await import("./commands/help.js");
+        await showHelp(commandArgs[0]);
+      }
+      break;
+    case "version":
+    case "--version":
+    case "-v": {
+      const { showversion } = await import("./commands/version.js");
+      showversion();
+      return;
+    }
+    default:
+      printHeader();
+      console.log(`❌ Unknown command: ${command}`);
+      console.log("Run 'syncstuff help' to see available commands");
+      process.exit(1);
+  }
+}
+
+run();

package/src/core.ts

@@ -0,0 +1,13 @@
+// Core types moved to utils/api-client.ts
+export type { UserProfile as User } from "./utils/api-client.js";
+
+export interface Device {
+  id: string;
+  name: string;
+  platform: string;
+  is_online: boolean;
+}
+
+export type DebugMode = {
+  enabled: boolean;
+};