@involvex/syncstuff-cli 0.0.1

package/src/utils/api-client.ts

@@ -0,0 +1,174 @@
+import { readConfig, writeConfig } from "./config.js";
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface LoginResponse {
+  token: string;
+  user: {
+    id: string;
+    email: string;
+    username: string;
+    full_name?: string;
+    role: string;
+  };
+}
+
+export interface UserProfile {
+  id: string;
+  email: string;
+  username: string;
+  full_name?: string;
+  role: "user" | "admin" | "moderator";
+  status: "active" | "suspended" | "pending";
+  preferences?: unknown;
+  created_at: number;
+  updated_at: number;
+}
+
+export interface Device {
+  id: string;
+  name: string;
+  type: string;
+  platform: string;
+  last_seen: number;
+  is_online: boolean;
+}
+
+class ApiClient {
+  private baseUrl: string;
+  private token: string | null = null;
+
+  constructor() {
+    this.baseUrl =
+      process.env.SYNCSTUFF_API_URL ||
+      "https://syncstuff-api.involvex.workers.dev";
+    this.loadToken();
+  }
+
+  private loadToken(): void {
+    const config = readConfig();
+    this.token = config.token || null;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<ApiResponse<T>> {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      ...(options.headers as Record<string, string>),
+    };
+
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+      });
+
+      const contentType = response.headers.get("Content-Type");
+      let data: ApiResponse<T>;
+
+      if (contentType?.includes("application/json")) {
+        data = (await response.json()) as ApiResponse<T>;
+      } else {
+        const text = await response.text();
+        try {
+          data = JSON.parse(text) as ApiResponse<T>;
+        } catch {
+          return {
+            success: false,
+            error: text || `HTTP ${response.status}: ${response.statusText}`,
+          };
+        }
+      }
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error:
+            data.error || `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      return data;
+    } catch (error) {
+      return {
+        success: false,
+        error:
+          error instanceof Error ? error.message : "Network error occurred",
+      };
+    }
+  }
+
+  async login(
+    email: string,
+    password: string,
+  ): Promise<ApiResponse<LoginResponse>> {
+    const response = await this.request<LoginResponse>("/api/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password }),
+    });
+
+    if (response.success && response.data?.token) {
+      this.token = response.data.token;
+      const config = readConfig();
+      config.token = this.token;
+      config.user = response.data.user;
+      writeConfig(config);
+    }
+
+    return response;
+  }
+
+  async logout(): Promise<void> {
+    const config = readConfig();
+    config.token = null;
+    config.user = null;
+    writeConfig(config);
+    this.token = null;
+  }
+
+  async getProfile(): Promise<ApiResponse<UserProfile>> {
+    return this.request<UserProfile>("/api/user/profile", {
+      method: "GET",
+    });
+  }
+
+  async getDevices(): Promise<ApiResponse<Device[]>> {
+    // TODO: Implement when API endpoint is available
+    return this.request<Device[]>("/api/devices", {
+      method: "GET",
+    });
+  }
+
+  async transferFile(
+    deviceId: string,
+    filePath: string,
+  ): Promise<ApiResponse<{ transferId: string }>> {
+    // TODO: Implement when API endpoint is available
+    return this.request<{ transferId: string }>("/api/transfer", {
+      method: "POST",
+      body: JSON.stringify({ deviceId, filePath }),
+    });
+  }
+
+  isAuthenticated(): boolean {
+    return !!this.token;
+  }
+
+  getToken(): string | null {
+    return this.token;
+  }
+}
+
+export const apiClient = new ApiClient();

package/src/utils/config.ts

@@ -0,0 +1,41 @@
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export interface Config {
+  token?: string | null;
+  user?: {
+    id: string;
+    email: string;
+    username: string;
+    full_name?: string;
+    role: string;
+  } | null;
+  apiUrl?: string;
+}
+
+const CONFIG_DIR = join(homedir(), ".syncstuff");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+function ensureConfigDir(): void {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  } catch {
+    // Directory might already exist
+  }
+}
+
+export function readConfig(): Config {
+  ensureConfigDir();
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content) as Config;
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(config: Config): void {
+  ensureConfigDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}

package/src/utils/context.ts

@@ -0,0 +1,68 @@
+export interface CommandContext {
+  debug: boolean;
+}
+
+export interface ParsedArgs {
+  command: string | undefined;
+  flags: {
+    debug: boolean;
+    help: boolean;
+  };
+  commandArgs: string[];
+}
+
+/**
+ * Parse command line arguments to extract global flags
+ * Global flags: -d/--debug, -h/--help
+ */
+export function parseArgs(args: string[]): ParsedArgs {
+  const flags = {
+    debug: false,
+    help: false,
+  };
+
+  const remainingArgs: string[] = [];
+
+  for (const arg of args) {
+    if (arg === "-d" || arg === "--debug") {
+      flags.debug = true;
+    } else if (arg === "-h" || arg === "--help") {
+      flags.help = true;
+    } else {
+      remainingArgs.push(arg);
+    }
+  }
+
+  return {
+    command: remainingArgs[0],
+    flags,
+    commandArgs: remainingArgs.slice(1),
+  };
+}
+
+/**
+ * Debug logging - only outputs when debug mode is enabled
+ */
+export function debugLog(ctx: CommandContext, ...args: unknown[]): void {
+  if (ctx.debug) {
+    console.log("[DEBUG]", ...args);
+  }
+}
+
+/**
+ * Debug info logging
+ */
+export function debugInfo(ctx: CommandContext, ...args: unknown[]): void {
+  if (ctx.debug) {
+    console.log("[DEBUG INFO]", ...args);
+  }
+}
+
+/**
+ * Debug error logging
+ */
+export function debugError(ctx: CommandContext, ...args: unknown[]): void {
+  if (ctx.debug) {
+    console.error("[DEBUG ERROR]", ...args);
+  }
+}

package/src/utils/ui.ts

@@ -0,0 +1,83 @@
+import boxen from "boxen";
+import chalk from "chalk";
+import ora from "ora";
+import Table from "table";
+
+export function success(message: string): void {
+  console.log(chalk.green(`✓ ${message}`));
+}
+
+export function error(message: string): void {
+  console.log(chalk.red(`✗ ${message}`));
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue(`ℹ ${message}`));
+}
+
+export function warning(message: string): void {
+  console.log(chalk.yellow(`⚠ ${message}`));
+}
+
+export function createSpinner(text: string): ReturnType<typeof ora> {
+  return ora({
+    text,
+    spinner: "dots",
+    color: "cyan",
+  });
+}
+
+export function createBox(
+  content: string,
+  options?: Parameters<typeof boxen>[1],
+): string {
+  return boxen(content, {
+    padding: 1,
+    margin: 1,
+    borderStyle: "round",
+    borderColor: "cyan",
+    ...options,
+  });
+}
+
+export function createTable(data: string[][], headers?: string[]): string {
+  const tableData = headers ? [headers, ...data] : data;
+  return Table.table(tableData, {
+    border: Table.getBorderCharacters("norc"),
+    header: headers
+      ? {
+          alignment: "center",
+          content: headers.join(" | "),
+        }
+      : undefined,
+  });
+}
+
+export function animateText(text: string, delay: number = 50): Promise<void> {
+  return new Promise(resolve => {
+    let index = 0;
+    const interval = setInterval(() => {
+      process.stdout.write(text[index] || "");
+      index++;
+      if (index >= text.length) {
+        clearInterval(interval);
+        process.stdout.write("\n");
+        resolve();
+      }
+    }, delay);
+  });
+}
+
+export function printHeader(): void {
+  const header = chalk.cyan.bold(`
+╔═══════════════════════════════════════╗
+║        Syncstuff CLI v0.0.1          ║
+║     Seamless Sync Across Devices      ║
+╚═══════════════════════════════════════╝
+  `);
+  console.log(header);
+}
+
+export function printSeparator(): void {
+  console.log(chalk.gray("─".repeat(50)));
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "esnext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "rootDir": "./",
+    "project": "./tsconfig.json"
+  }
+}