@claude-sync/cli 0.1.0

package/dist/src/index.js

@@ -0,0 +1,1298 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/config.ts
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { CONFIG_DIR, CONFIG_FILE, MANIFEST_FILE, encodePath } from "@claude-sync/utils";
+function getConfigDir() {
+  return join(homedir(), CONFIG_DIR);
+}
+function getConfigPath() {
+  return join(getConfigDir(), CONFIG_FILE);
+}
+async function loadConfig() {
+  try {
+    const content = await readFile(getConfigPath(), "utf-8");
+    return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+async function saveConfig(config) {
+  const existing = await loadConfig();
+  const merged = { ...existing, ...config };
+  await mkdir(getConfigDir(), { recursive: true });
+  await writeFile(getConfigPath(), JSON.stringify(merged, null, 2));
+}
+async function clearConfig() {
+  await saveConfig(DEFAULT_CONFIG);
+}
+async function loadProjectManifest(projectPath) {
+  try {
+    const encoded = encodePath(projectPath);
+    const manifestPath = join(getConfigDir(), "manifests", `${encoded}.json`);
+    const content = await readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+async function saveProjectManifest(projectPath, entries) {
+  const encoded = encodePath(projectPath);
+  const manifestPath = join(getConfigDir(), "manifests", `${encoded}.json`);
+  await mkdir(dirname(manifestPath), { recursive: true });
+  await writeFile(manifestPath, JSON.stringify(entries, null, 2));
+}
+function isAuthenticated(config) {
+  return config.accessToken !== null;
+}
+async function loadProjectLink(projectPath) {
+  try {
+    const encoded = encodePath(projectPath);
+    const linkPath = join(getConfigDir(), "project-links", `${encoded}.json`);
+    const content = await readFile(linkPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveProjectLink(projectPath, link) {
+  const encoded = encodePath(projectPath);
+  const linkPath = join(getConfigDir(), "project-links", `${encoded}.json`);
+  await mkdir(dirname(linkPath), { recursive: true });
+  await writeFile(linkPath, JSON.stringify(link, null, 2));
+}
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      apiUrl: "https://api.claude-sync.com",
+      accessToken: null,
+      refreshToken: null,
+      deviceId: null,
+      deviceName: null,
+      userId: null,
+      email: null
+    };
+  }
+});
+
+// src/lib/api-client.ts
+var ApiClient;
+var init_api_client = __esm({
+  "src/lib/api-client.ts"() {
+    "use strict";
+    init_auth();
+    ApiClient = class {
+      baseUrl;
+      constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+      }
+      async rawRequest(path, options = {}) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15e3);
+        let response;
+        try {
+          response = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            signal: controller.signal
+          });
+        } catch (err) {
+          clearTimeout(timeout);
+          if (err instanceof Error && err.name === "AbortError") {
+            throw new Error("Request timed out. Is the API server running?");
+          }
+          throw err;
+        }
+        clearTimeout(timeout);
+        if (!response.ok) {
+          if (response.status === 401) {
+            throw new Error("Session expired. Run `claude-sync login` to re-authenticate.");
+          }
+          const error2 = await response.json().catch(() => ({
+            statusCode: response.status,
+            message: response.statusText,
+            error: "Request failed"
+          }));
+          throw new Error(error2.message);
+        }
+        const json = await response.json();
+        return json.data !== void 0 ? json.data : json;
+      }
+      async request(path, options = {}) {
+        const token = await getValidToken();
+        const headers = {
+          "Content-Type": "application/json",
+          ...options.headers
+        };
+        if (token) {
+          headers["Authorization"] = `Bearer ${token}`;
+        }
+        return this.rawRequest(path, { ...options, headers });
+      }
+      async requestNoAuth(path, options = {}) {
+        const headers = {
+          "Content-Type": "application/json",
+          ...options.headers
+        };
+        return this.rawRequest(path, { ...options, headers });
+      }
+      async get(path) {
+        return this.request(path, { method: "GET" });
+      }
+      async post(path, body) {
+        return this.request(path, {
+          method: "POST",
+          body: body ? JSON.stringify(body) : void 0
+        });
+      }
+      async patch(path, body) {
+        return this.request(path, {
+          method: "PATCH",
+          body: body ? JSON.stringify(body) : void 0
+        });
+      }
+      async delete(path) {
+        return this.request(path, { method: "DELETE" });
+      }
+    };
+  }
+});
+
+// src/lib/auth.ts
+async function storeTokens(tokens, userId, email) {
+  await saveConfig({
+    accessToken: tokens.accessToken,
+    refreshToken: tokens.refreshToken,
+    userId,
+    email
+  });
+}
+async function refreshAccessToken() {
+  const config = await loadConfig();
+  if (!config.refreshToken) return null;
+  const client = new ApiClient(config.apiUrl);
+  try {
+    const response = await client.requestNoAuth("/api/auth/refresh", {
+      method: "POST",
+      body: JSON.stringify({ refreshToken: config.refreshToken })
+    });
+    await saveConfig({
+      accessToken: response.accessToken,
+      refreshToken: response.refreshToken
+    });
+    return response.accessToken;
+  } catch {
+    return null;
+  }
+}
+async function getValidToken() {
+  const config = await loadConfig();
+  if (!config.accessToken) return null;
+  try {
+    const payload = JSON.parse(
+      Buffer.from(config.accessToken.split(".")[1], "base64").toString()
+    );
+    if (payload.exp * 1e3 > Date.now()) {
+      return config.accessToken;
+    }
+  } catch {
+  }
+  return refreshAccessToken();
+}
+var init_auth = __esm({
+  "src/lib/auth.ts"() {
+    "use strict";
+    init_config();
+    init_api_client();
+  }
+});
+
+// src/lib/progress.ts
+import ora from "ora";
+import chalk from "chalk";
+function createSpinner(text3) {
+  return ora({ text: brandColor(text3), spinner: "dots", color: "magenta" });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function formatProgress(current, total) {
+  const percentage = total > 0 ? Math.round(current / total * 100) : 0;
+  return `${current}/${total} (${percentage}%)`;
+}
+var brandColor;
+var init_progress = __esm({
+  "src/lib/progress.ts"() {
+    "use strict";
+    brandColor = chalk.hex("#8a8cdd");
+  }
+});
+
+// src/lib/theme.ts
+import chalk2 from "chalk";
+function printBanner() {
+  console.log();
+  console.log(`  ${brandBold("claude-sync")} ${dim("v0.1.0")}`);
+  console.log();
+}
+function printIntro(title) {
+  console.log();
+  console.log(`  ${brandBold(title)}`);
+  console.log();
+}
+function printOutro(message) {
+  console.log();
+  console.log(`  ${dim(message)}`);
+  console.log();
+}
+function printSuccess(message) {
+  console.log(`  ${success("\u2714")} ${message}`);
+}
+function printError(message) {
+  console.log(`  ${error("\u2716")} ${message}`);
+}
+function printInfo(message) {
+  console.log(`  ${brand("\u25CF")} ${message}`);
+}
+function printLabel(label, value) {
+  console.log(`  ${dim(label.padEnd(14))} ${white(value)}`);
+}
+function printDivider() {
+  console.log();
+}
+var BRAND_HEX, BRAND_DIM_HEX, SUCCESS_HEX, WARN_HEX, ERROR_HEX, brand, brandBold, brandDim, success, successBold, warn, error, errorBold, dim, bold, white;
+var init_theme = __esm({
+  "src/lib/theme.ts"() {
+    "use strict";
+    BRAND_HEX = "#8a8cdd";
+    BRAND_DIM_HEX = "#6b6db8";
+    SUCCESS_HEX = "#8adda0";
+    WARN_HEX = "#ddcc8a";
+    ERROR_HEX = "#dd8a8a";
+    brand = chalk2.hex(BRAND_HEX);
+    brandBold = chalk2.hex(BRAND_HEX).bold;
+    brandDim = chalk2.hex(BRAND_DIM_HEX);
+    success = chalk2.hex(SUCCESS_HEX);
+    successBold = chalk2.hex(SUCCESS_HEX).bold;
+    warn = chalk2.hex(WARN_HEX);
+    error = chalk2.hex(ERROR_HEX);
+    errorBold = chalk2.hex(ERROR_HEX).bold;
+    dim = chalk2.dim;
+    bold = chalk2.bold;
+    white = chalk2.white;
+  }
+});
+
+// src/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  loginCommand: () => loginCommand
+});
+import { Command } from "commander";
+import { text, password as passwordPrompt, select, isCancel } from "@clack/prompts";
+async function loginWithBrowser(client) {
+  const response = await client.requestNoAuth("/api/auth/cli/initiate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" }
+  });
+  printInfo(`Open this URL in your browser:
+     ${brandBold(response.verifyUrl)}`);
+  printInfo(`Code: ${brandBold(response.code)}`);
+  const spinner = createSpinner("Waiting for browser authorization...").start();
+  const pollInterval = 2e3;
+  const maxAttempts = 150;
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    attempts++;
+    try {
+      const pollResponse = await client.requestNoAuth("/api/auth/cli/poll", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code: response.code })
+      });
+      if (pollResponse.status === "authorized" && pollResponse.tokenPair && pollResponse.user) {
+        spinner.stop();
+        await storeTokens(pollResponse.tokenPair, pollResponse.user.id, pollResponse.user.email);
+        printSuccess(`Logged in as ${brandBold(pollResponse.user.email)}`);
+        return;
+      }
+      if (pollResponse.status === "expired") {
+        spinner.stop();
+        printError("Authorization code expired. Please try again.");
+        process.exit(1);
+      }
+    } catch {
+    }
+  }
+  spinner.stop();
+  printError("Authorization timed out. Please try again.");
+  process.exit(1);
+}
+async function loginWithEmail(client) {
+  const email = await text({ message: `${brand("Email")}:` });
+  if (isCancel(email)) process.exit(0);
+  const password = await passwordPrompt({ message: `${brand("Password")}:` });
+  if (isCancel(password)) process.exit(0);
+  const spinner = createSpinner("Logging in...").start();
+  try {
+    const response = await client.requestNoAuth(
+      "/api/auth/login",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password })
+      }
+    );
+    spinner.stop();
+    await storeTokens(
+      { accessToken: response.accessToken, refreshToken: response.refreshToken, expiresIn: 900 },
+      response.user.id,
+      response.user.email
+    );
+    printSuccess(`Logged in as ${brandBold(response.user.email)}`);
+  } catch (err) {
+    spinner.stop();
+    printError(`Login failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    process.exit(1);
+  }
+}
+function loginCommand() {
+  return new Command("login").description("Authenticate with claude-sync").action(async () => {
+    printIntro("Login");
+    const config = await loadConfig();
+    const client = new ApiClient(config.apiUrl);
+    const method = await select({
+      message: `${brand("How would you like to log in?")}`,
+      options: [
+        { value: "browser", label: `${brand("\u25CB")} Browser ${dim("(recommended)")}` },
+        { value: "email", label: `${brand("\u25CB")} Email & password` }
+      ]
+    });
+    if (isCancel(method)) process.exit(0);
+    if (method === "browser") {
+      await loginWithBrowser(client);
+    } else {
+      await loginWithEmail(client);
+    }
+    printOutro("Authentication complete");
+  });
+}
+var init_login = __esm({
+  "src/commands/login.ts"() {
+    "use strict";
+    init_config();
+    init_auth();
+    init_api_client();
+    init_progress();
+    init_theme();
+  }
+});
+
+// src/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  logoutCommand: () => logoutCommand
+});
+import { Command as Command2 } from "commander";
+function logoutCommand() {
+  return new Command2("logout").description("Log out and revoke tokens").action(async () => {
+    printIntro("Logout");
+    const config = await loadConfig();
+    if (!config.accessToken) {
+      printInfo("Not currently logged in.");
+      printOutro("Done");
+      return;
+    }
+    try {
+      const client = new ApiClient(config.apiUrl);
+      await client.post("/api/auth/logout", {
+        refreshToken: config.refreshToken
+      });
+    } catch {
+    }
+    await clearConfig();
+    printSuccess("Logged out successfully.");
+    printOutro("Done");
+  });
+}
+var init_logout = __esm({
+  "src/commands/logout.ts"() {
+    "use strict";
+    init_config();
+    init_api_client();
+    init_theme();
+  }
+});
+
+// src/commands/device.ts
+var device_exports = {};
+__export(device_exports, {
+  deviceCommand: () => deviceCommand
+});
+import { Command as Command3 } from "commander";
+import { hostname, platform, arch, homedir as homedir2 } from "os";
+import { text as text2, isCancel as isCancel2 } from "@clack/prompts";
+function requireAuth(config) {
+  if (!isAuthenticated(config)) {
+    printError("Not logged in. Run `claude-sync login` first.");
+    process.exit(1);
+  }
+}
+function deviceCommand() {
+  const device = new Command3("device").description("Manage devices");
+  device.command("add").argument("[name]", "Device name").description("Register this machine as a device").action(async (name) => {
+    printIntro("Device Add");
+    const config = await loadConfig();
+    requireAuth(config);
+    const deviceName = name || await (async () => {
+      const input = await text2({ message: `${brand("Device name")}:`, initialValue: hostname() });
+      if (isCancel2(input)) process.exit(0);
+      return input;
+    })();
+    const spinner = createSpinner("Registering device...").start();
+    const client = new ApiClient(config.apiUrl);
+    try {
+      const response = await client.post("/api/devices", {
+        name: deviceName,
+        hostname: hostname(),
+        platform: platform(),
+        homeDir: homedir2(),
+        arch: arch()
+      });
+      await saveConfig({
+        deviceId: response.id,
+        deviceName: response.name
+      });
+      spinner.stop();
+      printSuccess(`Device ${brandBold(`"${response.name}"`)} registered`);
+      printLabel("ID", response.id);
+    } catch (err) {
+      spinner.stop();
+      printError(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
+    }
+    printOutro("Done");
+  });
+  device.command("list").description("List all registered devices").action(async () => {
+    printIntro("Devices");
+    const config = await loadConfig();
+    requireAuth(config);
+    const client = new ApiClient(config.apiUrl);
+    const spinner = createSpinner("Fetching devices...").start();
+    try {
+      const devices = await client.get("/api/devices");
+      spinner.stop();
+      if (devices.length === 0) {
+        printInfo("No devices registered.");
+        return;
+      }
+      console.log();
+      for (const d of devices) {
+        const current = d.id === config.deviceId ? ` ${brandBold("(current)")}` : "";
+        const active = d.isActive ? success("active") : error("inactive");
+        console.log(`  ${brand("\u25CB")} ${white(d.name)}${current}`);
+        console.log(`    ${dim(d.platform)} ${dim("\xB7")} ${active} ${dim("\xB7")} ${dim(d.id)}`);
+      }
+      console.log();
+    } catch (err) {
+      spinner.stop();
+      printError(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  });
+  device.command("remove").argument("<nameOrId>", "Device name or ID").description("Remove a device").action(async (nameOrId) => {
+    const config = await loadConfig();
+    requireAuth(config);
+    const client = new ApiClient(config.apiUrl);
+    const spinner = createSpinner("Removing device...").start();
+    try {
+      await client.delete(`/api/devices/${nameOrId}`);
+      spinner.stop();
+      if (config.deviceId === nameOrId) {
+        await saveConfig({ deviceId: null, deviceName: null });
+      }
+      printSuccess("Device removed.");
+    } catch (err) {
+      spinner.stop();
+      printError(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  });
+  device.command("rename").argument("<name>", "New name").description("Rename the current device").action(async (name) => {
+    const config = await loadConfig();
+    requireAuth(config);
+    if (!config.deviceId) {
+      printError("No device registered. Run `claude-sync device add` first.");
+      process.exit(1);
+    }
+    const client = new ApiClient(config.apiUrl);
+    const spinner = createSpinner("Renaming device...").start();
+    try {
+      const response = await client.patch(`/api/devices/${config.deviceId}`, { name });
+      await saveConfig({ deviceName: response.name });
+      spinner.stop();
+      printSuccess(`Device renamed to ${brandBold(`"${response.name}"`)}`);
+    } catch (err) {
+      spinner.stop();
+      printError(`Failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  });
+  return device;
+}
+var init_device = __esm({
+  "src/commands/device.ts"() {
+    "use strict";
+    init_config();
+    init_api_client();
+    init_progress();
+    init_theme();
+  }
+});
+
+// src/lib/sync-engine.ts
+import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { readdir, stat, lstat, readlink } from "fs/promises";
+import { hashFile, diffManifests, encodePath as encodePath2, CLAUDE_DIR, PROJECTS_DIR, SYNC_EXCLUDE_PATTERNS } from "@claude-sync/utils";
+function shouldExclude(name) {
+  return SYNC_EXCLUDE_PATTERNS.some((pattern) => {
+    if (pattern.startsWith("*")) {
+      return name.endsWith(pattern.slice(1));
+    }
+    return name === pattern;
+  });
+}
+async function walkDirectory(dir, basePath = "") {
+  const entries = [];
+  const items = await readdir(dir, { withFileTypes: true });
+  for (const item of items) {
+    if (shouldExclude(item.name)) continue;
+    const fullPath = join2(dir, item.name);
+    const relativePath = basePath ? `${basePath}/${item.name}` : item.name;
+    if (item.isDirectory()) {
+      const subEntries = await walkDirectory(fullPath, relativePath);
+      entries.push(...subEntries);
+    } else if (item.isFile()) {
+      const fileStat = await stat(fullPath);
+      const hash = await hashFile(fullPath);
+      const isText = !isBinaryPath(item.name);
+      entries.push({
+        path: relativePath,
+        hash,
+        size: fileStat.size,
+        modifiedAt: fileStat.mtime.toISOString(),
+        isCompressed: isText
+      });
+    }
+  }
+  return entries;
+}
+function isBinaryPath(name) {
+  const binaryExtensions = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip", ".gz", ".tar"];
+  return binaryExtensions.some((ext) => name.endsWith(ext));
+}
+async function resolveProjectState(cwd) {
+  const projectsDir = join2(homedir3(), CLAUDE_DIR, PROJECTS_DIR);
+  const encoded = encodePath2(cwd);
+  const projectDir = join2(projectsDir, encoded);
+  let state = "none";
+  let symlinkTarget;
+  try {
+    const stats = await lstat(projectDir);
+    if (stats.isSymbolicLink()) {
+      state = "symlink";
+      symlinkTarget = await readlink(projectDir);
+    } else if (stats.isDirectory()) {
+      state = "real";
+    }
+  } catch {
+    state = "none";
+  }
+  return { cwd, encodedPath: encoded, projectDir, state, symlinkTarget };
+}
+async function buildProjectManifest(cwd) {
+  const ctx = await resolveProjectState(cwd);
+  if (ctx.state === "none") return [];
+  const projectsDir = join2(homedir3(), CLAUDE_DIR, PROJECTS_DIR);
+  let targetDir = ctx.projectDir;
+  if (ctx.state === "symlink" && ctx.symlinkTarget) {
+    targetDir = join2(projectsDir, ctx.symlinkTarget);
+  }
+  try {
+    return await walkDirectory(targetDir);
+  } catch {
+    return [];
+  }
+}
+function computeDiff(local, remote) {
+  return diffManifests(local, remote);
+}
+var init_sync_engine = __esm({
+  "src/lib/sync-engine.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/compress.ts
+import { createGzip, createGunzip } from "zlib";
+import { createReadStream, createWriteStream } from "fs";
+import { pipeline } from "stream/promises";
+function compressBuffer(data) {
+  return new Promise((resolve, reject) => {
+    const gzip = createGzip();
+    const chunks = [];
+    gzip.on("data", (chunk) => chunks.push(chunk));
+    gzip.on("end", () => resolve(Buffer.concat(chunks)));
+    gzip.on("error", reject);
+    gzip.end(data);
+  });
+}
+function decompressBuffer(data) {
+  return new Promise((resolve, reject) => {
+    const gunzip = createGunzip();
+    const chunks = [];
+    gunzip.on("data", (chunk) => chunks.push(chunk));
+    gunzip.on("end", () => resolve(Buffer.concat(chunks)));
+    gunzip.on("error", reject);
+    gunzip.end(data);
+  });
+}
+var init_compress = __esm({
+  "src/lib/compress.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  runSync: () => runSync,
+  syncCommand: () => syncCommand
+});
+import { Command as Command4 } from "commander";
+import { select as select2, isCancel as isCancel3 } from "@clack/prompts";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, lstat as lstat2, symlink, unlink } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+import { homedir as homedir4 } from "os";
+import { CLAUDE_DIR as CLAUDE_DIR2, PROJECTS_DIR as PROJECTS_DIR2 } from "@claude-sync/utils";
+async function runSync(options) {
+  printIntro("Sync");
+  const config = await loadConfig();
+  if (!isAuthenticated(config)) {
+    printError("Not logged in. Run `claude-sync login` first.");
+    return;
+  }
+  if (!config.deviceId) {
+    printError("No device registered. Run `claude-sync device add` first.");
+    return;
+  }
+  const cwd = process.cwd();
+  const ctx = await resolveProjectState(cwd);
+  const client = new ApiClient(config.apiUrl);
+  const projectsDir = join3(homedir4(), CLAUDE_DIR2, PROJECTS_DIR2);
+  const projectLink = await loadProjectLink(cwd);
+  let projectDir = ctx.projectDir;
+  if (ctx.state === "symlink" && ctx.symlinkTarget) {
+    projectDir = join3(projectsDir, ctx.symlinkTarget);
+  }
+  printInfo(`Project: ${brand(cwd)}`);
+  if (ctx.state === "symlink") {
+    printInfo(`Linked to: ${dim(ctx.symlinkTarget || "unknown")}`);
+  }
+  const manifest = await buildProjectManifest(cwd);
+  if (!projectLink) {
+    const result = await handleFirstRun(client, config, cwd, ctx, manifest, projectDir, projectsDir, options);
+    if (result === "cancelled") {
+      printOutro("Cancelled.");
+      return;
+    }
+    if (result === "pulled") {
+      const finalManifest2 = await buildProjectManifest(cwd);
+      await saveProjectManifest(cwd, finalManifest2);
+      printSuccess("Sessions synced from remote device.");
+      printOutro("Done");
+      return;
+    }
+    if (result === "pushed") {
+      const finalManifest2 = await buildProjectManifest(cwd);
+      await saveProjectManifest(cwd, finalManifest2);
+      printOutro("Done");
+      return;
+    }
+    printOutro("Done");
+    return;
+  }
+  let pushResult = { uploaded: 0, projectId: projectLink.projectId, failed: false };
+  let pullResult = { downloaded: 0, failed: false };
+  if (manifest.length > 0) {
+    pushResult = await pushPhase(client, config.deviceId, cwd, manifest, projectDir, projectLink.projectId, options);
+  }
+  if (!pushResult.failed) {
+    pullResult = await pullPhase(client, config.deviceId, cwd, projectDir, projectLink.projectId, options);
+  }
+  if (pushResult.failed && pullResult.failed) {
+    printOutro("Sync failed.");
+    return;
+  }
+  const finalManifest = await buildProjectManifest(cwd);
+  await saveProjectManifest(cwd, finalManifest);
+  if (pushResult.uploaded > 0 || pullResult.downloaded > 0) {
+    const parts = [];
+    if (pushResult.uploaded > 0) parts.push(`${success(`+${pushResult.uploaded}`)} pushed`);
+    if (pullResult.downloaded > 0) parts.push(`${success(`+${pullResult.downloaded}`)} pulled`);
+    printSuccess(`Synced: ${parts.join(", ")}`);
+  } else if (!pushResult.failed && !pullResult.failed) {
+    printSuccess("Everything is up to date.");
+  }
+  printOutro("Done");
+}
+async function handleFirstRun(client, config, cwd, ctx, manifest, projectDir, projectsDir, options) {
+  printInfo(brand("First time syncing this project"));
+  const hasLocalFiles = ctx.state !== "none" && manifest.length > 0;
+  const devicesSpinner = createSpinner("Checking for other devices...").start();
+  let devices;
+  try {
+    devices = await client.get("/api/devices");
+  } catch {
+    devices = [];
+  }
+  devicesSpinner.stop();
+  const otherDevices = devices.filter((d) => d.id !== config.deviceId);
+  const menuOptions = [];
+  if (hasLocalFiles) {
+    menuOptions.push({
+      value: "push",
+      label: "Push to cloud",
+      hint: dim(`Upload ${manifest.length} local files`)
+    });
+  }
+  if (otherDevices.length > 0) {
+    menuOptions.push({
+      value: "continue",
+      label: "Continue from another machine",
+      hint: dim("Pull sessions from a device")
+    });
+  }
+  if (menuOptions.length === 0) {
+    printInfo("No local sessions and no other devices found.");
+    printInfo("Use Claude Code in this directory first, then run sync.");
+    return "cancelled";
+  }
+  if (menuOptions.length === 1 && menuOptions[0].value === "push") {
+    printInfo("No other devices found.");
+  }
+  const choice = await select2({
+    message: brand("What would you like to do?"),
+    options: menuOptions
+  });
+  if (isCancel3(choice)) return "cancelled";
+  if (choice === "push") {
+    const result = await pushPhase(client, config.deviceId, cwd, manifest, projectDir, void 0, options);
+    if (result.failed) {
+      return "cancelled";
+    }
+    if (result.uploaded > 0) {
+      printSuccess(`${success(`+${result.uploaded}`)} files pushed`);
+    }
+    await saveProjectLink(cwd, {
+      projectId: result.projectId,
+      foreignEncodedDir: ctx.encodedPath,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return "pushed";
+  }
+  const deviceChoice = await select2({
+    message: brand("Select device"),
+    options: otherDevices.map((d) => ({
+      value: d.id,
+      label: d.name,
+      hint: dim(`${d.hostname} \xB7 ${d.platform}`)
+    }))
+  });
+  if (isCancel3(deviceChoice)) return "cancelled";
+  const spinner = createSpinner("Loading projects...").start();
+  let projects;
+  try {
+    projects = await client.get(`/api/devices/${deviceChoice}/projects`);
+  } catch {
+    spinner.stop();
+    printError("Failed to load projects from device.");
+    return "cancelled";
+  }
+  spinner.stop();
+  if (projects.length === 0) {
+    printInfo("No projects found on that device.");
+    return "cancelled";
+  }
+  const projectChoice = await select2({
+    message: brand("Select project"),
+    options: projects.map((p) => ({
+      value: p.id,
+      label: p.displayName || p.originalPath,
+      hint: dim(p.localPath)
+    }))
+  });
+  if (isCancel3(projectChoice)) return "cancelled";
+  const selectedProject = projects.find((p) => p.id === projectChoice);
+  const downloaded = await crossMachinePull(
+    client,
+    config.deviceId,
+    cwd,
+    deviceChoice,
+    selectedProject.id,
+    selectedProject.encodedDir,
+    projectsDir,
+    options
+  );
+  if (downloaded === 0 && !options.dryRun) {
+    printInfo("No files to download.");
+    return "cancelled";
+  }
+  if (!options.dryRun) {
+    await createProjectSymlink(projectsDir, ctx.encodedPath, selectedProject.encodedDir);
+    await saveProjectLink(cwd, {
+      projectId: selectedProject.id,
+      foreignEncodedDir: selectedProject.encodedDir,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    printSuccess(`${success(`+${downloaded}`)} files pulled`);
+    printInfo(`Symlink: ${dim(ctx.encodedPath)} \u2192 ${dim(selectedProject.encodedDir)}`);
+  }
+  return "pulled";
+}
+async function createProjectSymlink(projectsDir, localEncoded, foreignEncoded) {
+  const symlinkPath = join3(projectsDir, localEncoded);
+  await mkdir2(projectsDir, { recursive: true });
+  try {
+    const stats = await lstat2(symlinkPath);
+    if (stats.isSymbolicLink()) {
+      await unlink(symlinkPath);
+    } else if (stats.isDirectory()) {
+      printError(`Local session directory already exists. Back it up first:
+  mv "${symlinkPath}" "${symlinkPath}.bak"`);
+      return;
+    }
+  } catch {
+  }
+  await symlink(foreignEncoded, symlinkPath);
+}
+async function crossMachinePull(client, deviceId, projectPath, fromDeviceId, projectId, foreignEncodedDir, projectsDir, options) {
+  const spinner = createSpinner("Preparing pull from remote device...").start();
+  let prepareResponse;
+  try {
+    prepareResponse = await client.post("/api/sync/pull/prepare", {
+      deviceId,
+      projectPath,
+      fromDeviceId,
+      projectId
+    });
+  } catch (err) {
+    spinner.stop();
+    printError(`Pull failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    return 0;
+  }
+  spinner.stop();
+  const filesToDownload = prepareResponse.filesToDownload;
+  if (filesToDownload.length === 0) return 0;
+  printInfo(`${brand(String(filesToDownload.length))} files to pull`);
+  if (options.dryRun) {
+    if (options.verbose) {
+      for (const entry of filesToDownload) {
+        console.log(`    ${brand("\u25CB")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
+      }
+    }
+    return filesToDownload.length;
+  }
+  const targetDir = join3(projectsDir, foreignEncodedDir);
+  let downloaded = 0;
+  for (const entry of filesToDownload) {
+    const dlSpinner = createSpinner(
+      `${formatProgress(downloaded + 1, filesToDownload.length)} ${entry.path}`
+    ).start();
+    try {
+      const urlResponse = await client.post("/api/sync/pull/download-url", {
+        syncEventId: prepareResponse.syncEventId,
+        key: entry.path
+      });
+      const response = await fetch(urlResponse.url);
+      let data = Buffer.from(await response.arrayBuffer());
+      if (entry.isCompressed) {
+        data = await decompressBuffer(data);
+      }
+      const outputPath = join3(targetDir, entry.path);
+      await mkdir2(dirname2(outputPath), { recursive: true });
+      await writeFile2(outputPath, data);
+      downloaded++;
+    } catch {
+    }
+    dlSpinner.stop();
+  }
+  try {
+    await client.post("/api/sync/pull/complete", {
+      syncEventId: prepareResponse.syncEventId,
+      manifest: filesToDownload
+    });
+  } catch {
+  }
+  return downloaded;
+}
+async function pushPhase(client, deviceId, projectPath, manifest, projectDir, projectId, options) {
+  const spinner = createSpinner("Preparing push...").start();
+  let prepareResponse;
+  try {
+    prepareResponse = await client.post("/api/sync/push/prepare", {
+      deviceId,
+      projectPath,
+      projectId,
+      manifest
+    });
+  } catch (err) {
+    spinner.stop();
+    printError(`Push failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    return { uploaded: 0, projectId: projectId || "", failed: true };
+  }
+  spinner.stop();
+  const resolvedProjectId = prepareResponse.projectId;
+  const filesToUpload = prepareResponse.filesToUpload;
+  if (filesToUpload.length === 0) return { uploaded: 0, projectId: resolvedProjectId, failed: false };
+  printInfo(`${brand(String(filesToUpload.length))} files to push`);
+  if (options.dryRun) {
+    if (options.verbose) {
+      for (const entry of filesToUpload) {
+        console.log(`    ${success("+")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
+      }
+    }
+    return { uploaded: filesToUpload.length, projectId: resolvedProjectId, failed: false };
+  }
+  let uploaded = 0;
+  for (const entry of filesToUpload) {
+    const uploadSpinner = createSpinner(
+      `${formatProgress(uploaded + 1, filesToUpload.length)} ${entry.path}`
+    ).start();
+    try {
+      const urlResponse = await client.post("/api/sync/push/upload-url", {
+        syncEventId: prepareResponse.syncEventId,
+        key: entry.path
+      });
+      const filePath = join3(projectDir, entry.path);
+      let body = await readFile2(filePath);
+      if (entry.isCompressed) {
+        body = await compressBuffer(body);
+      }
+      await fetch(urlResponse.url, {
+        method: "PUT",
+        body,
+        headers: { "Content-Type": "application/octet-stream" }
+      });
+      uploaded++;
+    } catch {
+    }
+    uploadSpinner.stop();
+  }
+  try {
+    await client.post("/api/sync/push/complete", {
+      syncEventId: prepareResponse.syncEventId,
+      manifest
+    });
+  } catch {
+  }
+  return { uploaded, projectId: resolvedProjectId, failed: false };
+}
+async function pullPhase(client, deviceId, projectPath, projectDir, projectId, options) {
+  const spinner = createSpinner("Preparing pull...").start();
+  let prepareResponse;
+  try {
+    prepareResponse = await client.post("/api/sync/pull/prepare", {
+      deviceId,
+      projectPath,
+      projectId
+    });
+  } catch (err) {
+    spinner.stop();
+    printError(`Pull failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+    return { downloaded: 0, failed: true };
+  }
+  spinner.stop();
+  const filesToDownload = prepareResponse.filesToDownload;
+  if (filesToDownload.length === 0) return { downloaded: 0, failed: false };
+  printInfo(`${brand(String(filesToDownload.length))} files to pull`);
+  if (options.dryRun) {
+    if (options.verbose) {
+      for (const entry of filesToDownload) {
+        console.log(`    ${brand("\u25CB")} ${entry.path} ${dim(`(${formatBytes(entry.size)})`)}`);
+      }
+    }
+    return { downloaded: filesToDownload.length, failed: false };
+  }
+  let downloaded = 0;
+  for (const entry of filesToDownload) {
+    const dlSpinner = createSpinner(
+      `${formatProgress(downloaded + 1, filesToDownload.length)} ${entry.path}`
+    ).start();
+    try {
+      const urlResponse = await client.post("/api/sync/pull/download-url", {
+        syncEventId: prepareResponse.syncEventId,
+        key: entry.path
+      });
+      const response = await fetch(urlResponse.url);
+      let data = Buffer.from(await response.arrayBuffer());
+      if (entry.isCompressed) {
+        data = await decompressBuffer(data);
+      }
+      const outputPath = join3(projectDir, entry.path);
+      await mkdir2(dirname2(outputPath), { recursive: true });
+      await writeFile2(outputPath, data);
+      downloaded++;
+    } catch {
+    }
+    dlSpinner.stop();
+  }
+  try {
+    await client.post("/api/sync/pull/complete", {
+      syncEventId: prepareResponse.syncEventId,
+      manifest: filesToDownload
+    });
+  } catch {
+  }
+  return { downloaded, failed: false };
+}
+function syncCommand() {
+  return new Command4("sync").description("Sync current project sessions with cloud").option("--dry-run", "Show what would be synced without syncing").option("--verbose", "Show detailed output").action(async (options) => {
+    await runSync(options);
+  });
+}
+var init_sync = __esm({
+  "src/commands/sync.ts"() {
+    "use strict";
+    init_config();
+    init_api_client();
+    init_sync_engine();
+    init_progress();
+    init_compress();
+    init_theme();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+import { Command as Command5 } from "commander";
+function statusCommand() {
+  return new Command5("status").description("Show sync status for current project").action(async () => {
+    printIntro("Status");
+    const config = await loadConfig();
+    const cwd = process.cwd();
+    printLabel("API", config.apiUrl);
+    printLabel("Authenticated", isAuthenticated(config) ? success("yes") : error("no"));
+    printLabel("Device", config.deviceName || dim("none"));
+    printLabel("Project", brand(cwd));
+    const ctx = await resolveProjectState(cwd);
+    printLabel("State", ctx.state === "none" ? dim("no session data") : ctx.state === "symlink" ? `symlink \u2192 ${dim(ctx.symlinkTarget || "unknown")}` : "local");
+    if (!isAuthenticated(config) || ctx.state === "none") return;
+    const spinner = createSpinner("Scanning files...").start();
+    const savedManifest = await loadProjectManifest(cwd);
+    const currentManifest = await buildProjectManifest(cwd);
+    const diff = computeDiff(currentManifest, savedManifest);
+    spinner.stop();
+    const totalSize = currentManifest.reduce((sum, e) => sum + e.size, 0);
+    printDivider();
+    printLabel("Local files", `${brand(String(currentManifest.length))} ${dim(`(${formatBytes(totalSize)})`)}`);
+    console.log();
+    printInfo("Changes since last sync:");
+    console.log(`    ${success(`+${diff.added.length}`)} added  ${warn(`~${diff.modified.length}`)} modified  ${error(`-${diff.deleted.length}`)} deleted`);
+    console.log();
+  });
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_config();
+    init_sync_engine();
+    init_progress();
+    init_theme();
+  }
+});
+
+// src/commands/whoami.ts
+var whoami_exports = {};
+__export(whoami_exports, {
+  whoamiCommand: () => whoamiCommand
+});
+import { Command as Command6 } from "commander";
+function whoamiCommand() {
+  return new Command6("whoami").description("Show current user and device info").action(async () => {
+    printIntro("Who Am I");
+    const config = await loadConfig();
+    if (!isAuthenticated(config)) {
+      printError("Not logged in. Run `claude-sync login` first.");
+      return;
+    }
+    const client = new ApiClient(config.apiUrl);
+    const spinner = createSpinner("Fetching user info...").start();
+    try {
+      const user = await client.get("/api/auth/me");
+      spinner.stop();
+      printLabel("User", `${user.name} ${dim(`(${user.email})`)}`);
+      printLabel("Plan", brand(user.plan));
+      printDivider();
+      printLabel("Device", config.deviceName || dim("none"));
+      printLabel("Device ID", config.deviceId || dim("not registered"));
+    } catch {
+      spinner.stop();
+      printLabel("Email", config.email || dim("unknown"));
+      printLabel("Device", config.deviceName || dim("none"));
+    }
+    console.log();
+  });
+}
+var init_whoami = __esm({
+  "src/commands/whoami.ts"() {
+    "use strict";
+    init_config();
+    init_api_client();
+    init_progress();
+    init_theme();
+  }
+});
+
+// src/index.ts
+init_login();
+init_logout();
+init_device();
+init_sync();
+init_status();
+init_whoami();
+import { Command as Command7 } from "commander";
+
+// src/commands/tui.ts
+init_theme();
+init_config();
+import { select as select3, isCancel as isCancel4 } from "@clack/prompts";
+import chalk3 from "chalk";
+function buildMenu(loggedIn) {
+  if (!loggedIn) {
+    return [
+      { value: "login", label: "Login", hint: "Authenticate with claude-sync" }
+    ];
+  }
+  return [
+    { value: "sync", label: "Sync", hint: "Sync current project" },
+    { value: "status", label: "Status", hint: "Show sync state" },
+    { value: "device:add", label: "Add Device", hint: "Register this machine" },
+    { value: "device:list", label: "List Devices", hint: "Show registered devices" },
+    { value: "device:remove", label: "Remove Device" },
+    { value: "device:rename", label: "Rename Device" },
+    { value: "whoami", label: "Who Am I", hint: "Current user and device" },
+    { value: "logout", label: "Logout", hint: "Sign out" }
+  ];
+}
+async function runTui() {
+  printBanner();
+  const config = await loadConfig();
+  const loggedIn = isAuthenticated(config);
+  if (loggedIn) {
+    console.log(`  ${dim("user")}   ${brand(config.email || "unknown")}`);
+    if (config.deviceName) {
+      console.log(`  ${dim("device")} ${brand(config.deviceName)}`);
+    }
+    console.log();
+  } else {
+    console.log(`  ${dim("Not logged in")}`);
+    console.log();
+  }
+  while (true) {
+    const items = buildMenu(loggedIn);
+    const options = [
+      ...items.map((o) => ({
+        value: o.value,
+        label: o.label,
+        hint: o.hint ? dim(o.hint) : void 0
+      })),
+      { value: "quit", label: chalk3.red("Quit") }
+    ];
+    const choice = await select3({
+      message: brand("What would you like to do?"),
+      options
+    });
+    if (isCancel4(choice) || choice === "quit") {
+      printOutro("Goodbye!");
+      return;
+    }
+    await executeCommand(choice);
+    console.log();
+  }
+}
+async function executeCommand(command) {
+  const { loginCommand: loginCommand2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+  const { logoutCommand: logoutCommand2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+  const { deviceCommand: deviceCommand2 } = await Promise.resolve().then(() => (init_device(), device_exports));
+  const { syncCommand: syncCommand2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+  const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+  const { whoamiCommand: whoamiCommand2 } = await Promise.resolve().then(() => (init_whoami(), whoami_exports));
+  const handlers = {
+    login: () => loginCommand2().parseAsync(["", "", "login"]),
+    logout: () => logoutCommand2().parseAsync(["", "", "logout"]),
+    sync: () => syncCommand2().parseAsync(["", "", "sync"]),
+    status: () => statusCommand2().parseAsync(["", "", "status"]),
+    whoami: () => whoamiCommand2().parseAsync(["", "", "whoami"]),
+    "device:add": () => deviceCommand2().parseAsync(["", "", "device", "add"]),
+    "device:list": () => deviceCommand2().parseAsync(["", "", "device", "list"]),
+    "device:remove": () => deviceCommand2().parseAsync(["", "", "device", "remove"]),
+    "device:rename": () => deviceCommand2().parseAsync(["", "", "device", "rename"])
+  };
+  const handler = handlers[command];
+  if (handler) {
+    try {
+      await handler();
+    } catch {
+    }
+  }
+}
+
+// src/index.ts
+init_config();
+function run() {
+  const program = new Command7();
+  program.name("claude-sync").description("Sync Claude Code sessions across machines").version("0.1.0").option("--menu", "Open interactive menu").action(async (options) => {
+    if (options.menu) {
+      await runTui();
+      return;
+    }
+    const config = await loadConfig();
+    if (isAuthenticated(config) && config.deviceId) {
+      await runSync({});
+    } else {
+      await runTui();
+    }
+  });
+  program.addCommand(loginCommand());
+  program.addCommand(logoutCommand());
+  program.addCommand(deviceCommand());
+  program.addCommand(syncCommand());
+  program.addCommand(statusCommand());
+  program.addCommand(whoamiCommand());
+  program.parse();
+}
+export {
+  run
+};
+//# sourceMappingURL=index.js.map