@anraktech/sync 0.1.0

package/dist/cli.js

@@ -0,0 +1,945 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { resolve } from "path";
+import chalk2 from "chalk";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/logger.ts
+import chalk from "chalk";
+var PREFIX = chalk.bold.blue("[anrak-sync]");
+var log = {
+  info: (msg) => console.log(`${PREFIX} ${msg}`),
+  success: (msg) => console.log(`${PREFIX} ${chalk.green("\u2713")} ${msg}`),
+  warn: (msg) => console.log(`${PREFIX} ${chalk.yellow("\u26A0")} ${msg}`),
+  error: (msg) => console.error(`${PREFIX} ${chalk.red("\u2717")} ${msg}`),
+  debug: (msg) => {
+    if (process.env.ANRAK_DEBUG) console.log(`${PREFIX} ${chalk.gray(msg)}`);
+  },
+  dim: (msg) => console.log(`${PREFIX} ${chalk.dim(msg)}`),
+  file: (action, path) => console.log(`${PREFIX}   ${chalk.cyan(action)} ${chalk.dim(path)}`)
+};
+
+// src/config.ts
+var CONFIG_DIR = join(homedir(), ".anrak-sync");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CACHE_FILE = join(CONFIG_DIR, "cache.json");
+function ensureDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) return null;
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureDir();
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+  log.debug(`Config saved to ${CONFIG_FILE}`);
+}
+function loadCache() {
+  try {
+    if (!existsSync(CACHE_FILE)) return { files: {}, mappings: {} };
+    const raw = readFileSync(CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { files: {}, mappings: {} };
+  }
+}
+function saveCache(cache2) {
+  ensureDir();
+  writeFileSync(CACHE_FILE, JSON.stringify(cache2, null, 2), "utf-8");
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+// src/auth.ts
+import { createClient } from "@supabase/supabase-js";
+import { createServer } from "http";
+import { exec } from "child_process";
+var supabase = null;
+function getSupabase(config) {
+  if (!supabase) {
+    supabase = createClient(config.supabaseUrl, config.supabaseAnonKey, {
+      auth: { persistSession: false }
+    });
+  }
+  return supabase;
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+function findFreePort() {
+  return new Promise((resolve2, reject) => {
+    const srv = createServer();
+    srv.listen(0, () => {
+      const addr = srv.address();
+      if (!addr || typeof addr === "string") {
+        srv.close();
+        reject(new Error("Could not find a free port"));
+        return;
+      }
+      const port = addr.port;
+      srv.close(() => resolve2(port));
+    });
+  });
+}
+async function browserLogin(apiUrl) {
+  const port = await findFreePort();
+  return new Promise(
+    (resolve2, reject) => {
+      let server;
+      const timeout = setTimeout(() => {
+        server?.close();
+        reject(
+          new Error(
+            "Authorization timed out (5 minutes). Run `anrak-sync login` to try again."
+          )
+        );
+      }, 5 * 60 * 1e3);
+      server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+        if (url.pathname !== "/callback") {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        if (!code) {
+          res.writeHead(400);
+          res.end("Missing code");
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<!DOCTYPE html>
+<html><head><title>AnrakLegal Sync</title></head>
+<body style="background:#0a0a0a;color:#fff;font-family:system-ui;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">
+<div style="text-align:center">
+<div style="font-size:48px;margin-bottom:16px">&#10003;</div>
+<h1 style="color:#3b82f6;margin:0 0 8px">Authorized</h1>
+<p style="color:#888;margin:0">You can close this window and return to the terminal.</p>
+</div></body></html>`);
+        try {
+          const resp = await fetch(`${apiUrl}/api/sync/auth/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ code })
+          });
+          if (!resp.ok) {
+            const body = await resp.text().catch(() => "");
+            throw new Error(
+              `Code exchange failed (${resp.status}): ${body.slice(0, 200)}`
+            );
+          }
+          const tokens = await resp.json();
+          clearTimeout(timeout);
+          server.close();
+          resolve2(tokens);
+        } catch (err) {
+          clearTimeout(timeout);
+          server.close();
+          reject(err);
+        }
+      });
+      server.listen(port, () => {
+        const authorizeUrl = `${apiUrl}/sync/authorize?port=${port}`;
+        log.info("Opening browser for authorization...");
+        log.dim(`If browser doesn't open, visit: ${authorizeUrl}`);
+        openBrowser(authorizeUrl);
+      });
+    }
+  );
+}
+async function signIn(config, email, password) {
+  const sb = getSupabase(config);
+  const { data, error } = await sb.auth.signInWithPassword({
+    email,
+    password
+  });
+  if (error) throw new Error(`Login failed: ${error.message}`);
+  if (!data.session) throw new Error("No session returned");
+  return {
+    accessToken: data.session.access_token,
+    refreshToken: data.session.refresh_token
+  };
+}
+async function refreshSession(config) {
+  const sb = getSupabase(config);
+  const { data, error } = await sb.auth.refreshSession({
+    refresh_token: config.refreshToken
+  });
+  if (error || !data.session) {
+    log.warn(
+      "Session refresh failed \u2014 run `anrak-sync login` to re-authenticate"
+    );
+    return null;
+  }
+  config.accessToken = data.session.access_token;
+  config.refreshToken = data.session.refresh_token;
+  saveConfig(config);
+  return data.session.access_token;
+}
+async function getAccessToken(config) {
+  try {
+    const payload = JSON.parse(
+      Buffer.from(config.accessToken.split(".")[1], "base64").toString()
+    );
+    const expiresAt = payload.exp * 1e3;
+    const buffer = 6e4;
+    if (Date.now() < expiresAt - buffer) {
+      return config.accessToken;
+    }
+  } catch {
+  }
+  log.debug("Access token expired, refreshing...");
+  const newToken = await refreshSession(config);
+  if (!newToken) {
+    throw new Error(
+      "Authentication expired. Run `anrak-sync login` to re-authenticate."
+    );
+  }
+  return newToken;
+}
+async function fetchServerConfig(apiUrl) {
+  const resp = await fetch(`${apiUrl}/api/sync/config`);
+  if (!resp.ok) {
+    throw new Error(
+      `Failed to fetch server config (${resp.status}). Is ${apiUrl} reachable?`
+    );
+  }
+  return await resp.json();
+}
+
+// src/api.ts
+import { readFile, stat } from "fs/promises";
+import { basename } from "path";
+import { lookup } from "mime-types";
+async function authHeaders(config) {
+  const token = await getAccessToken(config);
+  return {
+    Authorization: `Bearer ${token}`
+  };
+}
+async function listCases(config) {
+  const headers = await authHeaders(config);
+  const resp = await fetch(`${config.apiUrl}/api/sync/cases`, { headers });
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(`Failed to list cases (${resp.status}): ${body.slice(0, 200)}`);
+  }
+  const data = await resp.json();
+  return data.cases;
+}
+async function uploadFile(config, caseId, filePath) {
+  const headers = await authHeaders(config);
+  const filename = basename(filePath);
+  const mimeType = lookup(filename) || "application/octet-stream";
+  const buffer = await readFile(filePath);
+  const blob = new Blob([buffer], { type: mimeType });
+  const formData = new FormData();
+  formData.append("files", blob, filename);
+  const resp = await fetch(
+    `${config.apiUrl}/api/sync/cases/${caseId}/upload`,
+    {
+      method: "POST",
+      headers,
+      body: formData
+    }
+  );
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(
+      `Upload failed for ${filename} (${resp.status}): ${body.slice(0, 200)}`
+    );
+  }
+  return await resp.json();
+}
+async function createCase(config, caseNumber, caseName) {
+  const headers = await authHeaders(config);
+  const resp = await fetch(`${config.apiUrl}/api/sync/cases`, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+    body: JSON.stringify({ caseNumber, caseName })
+  });
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    throw new Error(`Failed to create case (${resp.status}): ${body.slice(0, 200)}`);
+  }
+  const data = await resp.json();
+  return data.case;
+}
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".ppt",
+  ".pptx",
+  ".xls",
+  ".xlsx",
+  ".txt",
+  ".md",
+  ".csv",
+  ".json",
+  ".xml",
+  ".html",
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".bmp",
+  ".tiff",
+  ".tif",
+  ".webp",
+  ".gif"
+]);
+function isSupportedFile(filename) {
+  const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
+var IGNORED_PATTERNS = [
+  /^\./,
+  // dotfiles
+  /^~\$/,
+  // Office temp files
+  /\.tmp$/i,
+  /\.bak$/i,
+  /^Thumbs\.db$/i,
+  /^desktop\.ini$/i,
+  /^\.DS_Store$/
+];
+function isIgnoredFile(filename) {
+  return IGNORED_PATTERNS.some((p) => p.test(filename));
+}
+
+// src/cache.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+var cache = null;
+function getCache() {
+  if (!cache) cache = loadCache();
+  return cache;
+}
+function persist() {
+  if (cache) saveCache(cache);
+}
+function hashFile(filePath) {
+  return new Promise((resolve2, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve2(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function getFileEntry(filePath) {
+  return getCache().files[filePath] ?? null;
+}
+function hasFileChanged(filePath, currentHash) {
+  const entry = getFileEntry(filePath);
+  if (!entry) return true;
+  return entry.hash !== currentHash;
+}
+function markSynced(filePath, hash, size, caseId, documentId) {
+  getCache().files[filePath] = {
+    hash,
+    size,
+    caseId,
+    documentId,
+    lastSynced: Date.now(),
+    status: "synced"
+  };
+  persist();
+}
+function markPending(filePath, hash, size, caseId) {
+  getCache().files[filePath] = {
+    hash,
+    size,
+    caseId,
+    documentId: null,
+    lastSynced: null,
+    status: "pending"
+  };
+  persist();
+}
+function markError(filePath) {
+  const entry = getCache().files[filePath];
+  if (entry) {
+    entry.status = "error";
+    persist();
+  }
+}
+function getFolderMapping(folderName) {
+  return getCache().mappings[folderName] ?? null;
+}
+function setFolderMapping(folderName, caseId, caseName, caseNumber) {
+  getCache().mappings[folderName] = {
+    caseId,
+    caseName,
+    caseNumber,
+    mappedAt: Date.now()
+  };
+  persist();
+}
+function getAllMappings() {
+  return { ...getCache().mappings };
+}
+function getStats() {
+  const c = getCache();
+  const files = Object.values(c.files);
+  return {
+    totalFiles: files.length,
+    synced: files.filter((f) => f.status === "synced").length,
+    pending: files.filter((f) => f.status === "pending").length,
+    errors: files.filter((f) => f.status === "error").length,
+    mappedFolders: Object.keys(c.mappings).length
+  };
+}
+function resetCache() {
+  cache = { files: {}, mappings: {} };
+  persist();
+}
+
+// src/watcher.ts
+import { watch } from "chokidar";
+import { readdirSync, statSync } from "fs";
+import { join as join2, relative as relative2, basename as basename4 } from "path";
+
+// src/uploader.ts
+import { stat as stat2 } from "fs/promises";
+import { basename as basename3, dirname, relative } from "path";
+
+// src/mapper.ts
+import { basename as basename2 } from "path";
+function normalize(s) {
+  return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function similarity(a, b) {
+  const wordsA = new Set(normalize(a).split(" "));
+  const wordsB = new Set(normalize(b).split(" "));
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  let overlap = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) overlap++;
+  }
+  return overlap / Math.max(wordsA.size, wordsB.size);
+}
+function findBestMatch(folderName, cases) {
+  const normalized = normalize(folderName);
+  for (const c of cases) {
+    const num = normalize(c.caseNumber);
+    if (num && normalized.includes(num)) {
+      return c;
+    }
+  }
+  let bestCase = null;
+  let bestScore = 0;
+  for (const c of cases) {
+    const nameScore = similarity(folderName, c.caseName);
+    const numScore = similarity(folderName, c.caseNumber);
+    const score = Math.max(nameScore, numScore);
+    if (score > bestScore) {
+      bestScore = score;
+      bestCase = c;
+    }
+  }
+  if (bestScore >= 0.5 && bestCase) {
+    return bestCase;
+  }
+  return null;
+}
+function deriveCaseInfo(folderName) {
+  const caseNumPattern = /(\d{4})[\/\-_\s]?([A-Z]{2,5})[\/\-_\s]?(\d{1,6})/i;
+  const match = folderName.match(caseNumPattern);
+  if (match) {
+    const caseNumber = `${match[1]}/${match[2].toUpperCase()}/${match[3]}`;
+    const remaining = folderName.replace(match[0], "").trim().replace(/^[\-_\s]+|[\-_\s]+$/g, "");
+    const caseName = remaining || folderName;
+    return { caseNumber, caseName };
+  }
+  const sanitized = folderName.replace(/[\/\\]/g, "-");
+  return {
+    caseNumber: `SYNC-${Date.now().toString(36).toUpperCase()}`,
+    caseName: sanitized
+  };
+}
+async function resolveFolder(config, folderPath, cases) {
+  const folderName = basename2(folderPath);
+  const cached = getFolderMapping(folderName);
+  if (cached) {
+    return {
+      caseId: cached.caseId,
+      caseName: cached.caseName,
+      caseNumber: cached.caseNumber,
+      created: false
+    };
+  }
+  const allCases = cases ?? await listCases(config);
+  const match = findBestMatch(folderName, allCases);
+  if (match) {
+    log.success(`Mapped "${folderName}" -> ${match.caseNumber} (${match.caseName})`);
+    setFolderMapping(folderName, match.id, match.caseName, match.caseNumber);
+    return {
+      caseId: match.id,
+      caseName: match.caseName,
+      caseNumber: match.caseNumber,
+      created: false
+    };
+  }
+  const { caseNumber, caseName } = deriveCaseInfo(folderName);
+  log.info(`No match for "${folderName}" \u2014 creating case ${caseNumber}`);
+  try {
+    const newCase = await createCase(config, caseNumber, caseName);
+    setFolderMapping(folderName, newCase.id, newCase.caseName, newCase.caseNumber);
+    log.success(`Created case ${newCase.caseNumber} (${newCase.caseName})`);
+    return {
+      caseId: newCase.id,
+      caseName: newCase.caseName,
+      caseNumber: newCase.caseNumber,
+      created: true
+    };
+  } catch (err) {
+    throw new Error(
+      `Failed to create case for folder "${folderName}": ${err instanceof Error ? err.message : err}`
+    );
+  }
+}
+
+// src/uploader.ts
+var MAX_RETRIES = 3;
+var RATE_LIMIT_INTERVAL_MS = 3e3;
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+var queue = [];
+var processing = false;
+var lastUploadTime = 0;
+async function enqueue(filePath, watchFolder) {
+  const filename = basename3(filePath);
+  if (isIgnoredFile(filename)) return;
+  if (!isSupportedFile(filename)) {
+    log.debug(`Skipping unsupported file: ${filename}`);
+    return;
+  }
+  try {
+    const s = await stat2(filePath);
+    if (s.size > MAX_FILE_SIZE) {
+      log.warn(`Skipping ${filename} \u2014 exceeds 50MB limit (${(s.size / 1024 / 1024).toFixed(1)}MB)`);
+      return;
+    }
+    if (s.size === 0) return;
+  } catch {
+    return;
+  }
+  const hash = await hashFile(filePath);
+  if (!hasFileChanged(filePath, hash)) {
+    log.debug(`Unchanged: ${filename}`);
+    return;
+  }
+  const relPath = relative(watchFolder, filePath);
+  const topFolder = relPath.split(/[/\\]/)[0];
+  const folderPath = topFolder === basename3(filePath) ? watchFolder : dirname(filePath).split(/[/\\]/).slice(0, watchFolder.split(/[/\\]/).length + 1).join("/");
+  queue.push({ filePath, folderPath, retries: 0 });
+  log.file("queued", relative(watchFolder, filePath));
+}
+async function processQueue(config, cases) {
+  if (processing) return { uploaded: 0, failed: 0 };
+  processing = true;
+  let uploaded = 0;
+  let failed = 0;
+  while (queue.length > 0) {
+    const item = queue.shift();
+    const filename = basename3(item.filePath);
+    const elapsed = Date.now() - lastUploadTime;
+    if (elapsed < RATE_LIMIT_INTERVAL_MS) {
+      await sleep(RATE_LIMIT_INTERVAL_MS - elapsed);
+    }
+    try {
+      const { caseId, caseName } = await resolveFolder(
+        config,
+        item.folderPath,
+        cases
+      );
+      const hash = await hashFile(item.filePath);
+      const s = await stat2(item.filePath);
+      markPending(item.filePath, hash, s.size, caseId);
+      log.file("uploading", `${filename} -> ${caseName}`);
+      const result = await uploadFile(config, caseId, item.filePath);
+      lastUploadTime = Date.now();
+      if (result.success && result.linkedDocumentIds.length > 0) {
+        markSynced(
+          item.filePath,
+          hash,
+          s.size,
+          caseId,
+          result.linkedDocumentIds[0]
+        );
+        log.success(`Synced ${filename} to ${caseName}`);
+        uploaded++;
+      } else {
+        markError(item.filePath);
+        log.warn(`Upload returned no linked documents for ${filename}`);
+        failed++;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (item.retries < MAX_RETRIES) {
+        item.retries++;
+        queue.push(item);
+        log.warn(`Retry ${item.retries}/${MAX_RETRIES} for ${filename}: ${msg}`);
+      } else {
+        markError(item.filePath);
+        log.error(`Failed ${filename} after ${MAX_RETRIES} retries: ${msg}`);
+        failed++;
+      }
+    }
+  }
+  processing = false;
+  return { uploaded, failed };
+}
+function queueSize() {
+  return queue.length;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/watcher.ts
+async function scanFolder(config) {
+  const folder = config.watchFolder;
+  let scanned = 0;
+  let queued = 0;
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (isIgnoredFile(entry)) continue;
+      const fullPath = join2(dir, entry);
+      let s;
+      try {
+        s = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (s.isDirectory()) {
+        walk(fullPath);
+      } else if (s.isFile() && isSupportedFile(entry)) {
+        scanned++;
+        void enqueue(fullPath, folder).then(() => queued++);
+      }
+    }
+  }
+  walk(folder);
+  await new Promise((r) => setTimeout(r, 500));
+  return { scanned, queued: queueSize() };
+}
+async function pushSync(config) {
+  log.info(`Scanning ${config.watchFolder}...`);
+  const cases = await listCases(config);
+  log.info(`Found ${cases.length} case(s) on server`);
+  const { scanned, queued } = await scanFolder(config);
+  log.info(`Scanned ${scanned} files, ${queued} need syncing`);
+  if (queued === 0) {
+    log.success("Everything up to date");
+    return;
+  }
+  const result = await processQueue(config, cases);
+  log.success(
+    `Sync complete: ${result.uploaded} uploaded, ${result.failed} failed`
+  );
+}
+async function startWatching(config) {
+  const folder = config.watchFolder;
+  log.info(`Scanning ${folder}...`);
+  let cases = await listCases(config);
+  log.info(`Found ${cases.length} case(s) on server`);
+  const { scanned, queued } = await scanFolder(config);
+  log.info(`Scanned ${scanned} files, ${queued} need syncing`);
+  if (queued > 0) {
+    const result = await processQueue(config, cases);
+    log.info(
+      `Initial sync: ${result.uploaded} uploaded, ${result.failed} failed`
+    );
+  }
+  const refreshInterval = setInterval(async () => {
+    try {
+      cases = await listCases(config);
+    } catch {
+    }
+  }, 5 * 60 * 1e3);
+  log.info(`Watching for changes...`);
+  log.dim("Press Ctrl+C to stop\n");
+  const watcher = watch(folder, {
+    ignored: /(^|[\/\\])(\.|~\$|Thumbs\.db|desktop\.ini)/,
+    persistent: true,
+    ignoreInitial: true,
+    // We already scanned
+    awaitWriteFinish: {
+      stabilityThreshold: 2e3,
+      // Wait 2s after last change
+      pollInterval: 500
+    },
+    depth: 5
+    // Max folder depth
+  });
+  let debounceTimer = null;
+  function scheduleProcess() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      if (queueSize() > 0) {
+        const result = await processQueue(config, cases);
+        if (result.uploaded > 0 || result.failed > 0) {
+          log.info(
+            `Batch: ${result.uploaded} uploaded, ${result.failed} failed`
+          );
+        }
+      }
+    }, 3e3);
+  }
+  watcher.on("add", async (path) => {
+    const filename = basename4(path);
+    if (!isSupportedFile(filename) || isIgnoredFile(filename)) return;
+    log.file("detected", relative2(folder, path));
+    await enqueue(path, folder);
+    scheduleProcess();
+  });
+  watcher.on("change", async (path) => {
+    const filename = basename4(path);
+    if (!isSupportedFile(filename) || isIgnoredFile(filename)) return;
+    log.file("changed", relative2(folder, path));
+    await enqueue(path, folder);
+    scheduleProcess();
+  });
+  watcher.on("unlink", (path) => {
+    log.file("deleted", relative2(folder, path));
+  });
+  watcher.on("error", (err) => {
+    log.error(`Watcher error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+  const shutdown = () => {
+    log.info("Shutting down...");
+    clearInterval(refreshInterval);
+    if (debounceTimer) clearTimeout(debounceTimer);
+    watcher.close().then(() => {
+      log.success("Stopped");
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("anrak-sync").description("AnrakLegal desktop file sync \u2014 watches local folders, syncs to case management").version("0.1.0");
+program.command("init").description("Set up AnrakLegal Sync (first-time configuration)").option("--password", "Use email/password login instead of browser").action(async (opts) => {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    console.log(chalk2.bold.blue("\n  AnrakLegal Sync \u2014 Setup\n"));
+    const apiUrl = await rl.question(
+      `  AnrakLegal URL ${chalk2.dim("(https://anrak.legal)")}: `
+    ) || "https://anrak.legal";
+    log.info("Connecting to server...");
+    const serverConfig = await fetchServerConfig(apiUrl);
+    log.success("Server connected");
+    let tokens;
+    if (opts.password) {
+      const email = await rl.question("  Email: ");
+      const password = await rl.question("  Password: ");
+      if (!email || !password) {
+        log.error("Email and password are required");
+        process.exit(1);
+      }
+      log.info("Authenticating...");
+      const partialConfig = {
+        apiUrl,
+        supabaseUrl: serverConfig.supabaseUrl,
+        supabaseAnonKey: serverConfig.supabaseAnonKey,
+        accessToken: "",
+        refreshToken: "",
+        watchFolder: ""
+      };
+      tokens = await signIn(partialConfig, email, password);
+    } else {
+      rl.close();
+      tokens = await browserLogin(apiUrl);
+    }
+    log.success("Authenticated");
+    const rl2 = createInterface({ input: stdin, output: stdout });
+    const defaultFolder = process.platform === "win32" ? "C:\\Cases" : `${process.env.HOME}/Cases`;
+    const watchInput = await rl2.question(
+      `  Watch folder ${chalk2.dim(`(${defaultFolder})`)}: `
+    );
+    const watchFolder = resolve(watchInput || defaultFolder);
+    rl2.close();
+    if (!existsSync2(watchFolder)) {
+      log.warn(
+        `Folder ${watchFolder} does not exist \u2014 it will be created when you add files`
+      );
+    } else if (!statSync2(watchFolder).isDirectory()) {
+      log.error(`${watchFolder} is not a directory`);
+      process.exit(1);
+    }
+    const config = {
+      apiUrl,
+      supabaseUrl: serverConfig.supabaseUrl,
+      supabaseAnonKey: serverConfig.supabaseAnonKey,
+      accessToken: tokens.accessToken,
+      refreshToken: tokens.refreshToken,
+      watchFolder
+    };
+    saveConfig(config);
+    console.log("");
+    log.success("Setup complete!");
+    log.info(`Config saved to ${getConfigDir()}`);
+    log.info(`Watching: ${watchFolder}`);
+    console.log(
+      chalk2.dim("\n  Run `anrak-sync start` to begin syncing\n")
+    );
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("login").description("Re-authenticate with AnrakLegal").option("--password", "Use email/password login instead of browser").action(async (opts) => {
+  const config = requireConfig();
+  try {
+    let tokens;
+    if (opts.password) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      try {
+        const email = await rl.question("  Email: ");
+        const password = await rl.question("  Password: ");
+        log.info("Authenticating...");
+        tokens = await signIn(config, email, password);
+      } finally {
+        rl.close();
+      }
+    } else {
+      tokens = await browserLogin(config.apiUrl);
+    }
+    config.accessToken = tokens.accessToken;
+    config.refreshToken = tokens.refreshToken;
+    saveConfig(config);
+    log.success("Logged in successfully");
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("start").description("Start watching for file changes and syncing").action(async () => {
+  const config = requireConfig();
+  console.log(chalk2.bold.blue("\n  AnrakLegal Sync\n"));
+  log.info(`Watching: ${config.watchFolder}`);
+  log.info(`Server:   ${config.apiUrl}`);
+  console.log("");
+  try {
+    await startWatching(config);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("push").description("One-time sync \u2014 upload all new/changed files, then exit").action(async () => {
+  const config = requireConfig();
+  console.log(chalk2.bold.blue("\n  AnrakLegal Sync \u2014 Push\n"));
+  log.info(`Folder: ${config.watchFolder}`);
+  log.info(`Server: ${config.apiUrl}`);
+  console.log("");
+  try {
+    await pushSync(config);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+program.command("status").description("Show sync status").action(async () => {
+  const config = requireConfig();
+  const stats = getStats();
+  console.log(chalk2.bold.blue("\n  AnrakLegal Sync \u2014 Status\n"));
+  console.log(`  Server:         ${config.apiUrl}`);
+  console.log(`  Watch folder:   ${config.watchFolder}`);
+  console.log(`  Config:         ${getConfigDir()}`);
+  console.log("");
+  console.log(`  Files tracked:  ${stats.totalFiles}`);
+  console.log(`  Synced:         ${chalk2.green(stats.synced)}`);
+  console.log(`  Pending:        ${chalk2.yellow(stats.pending)}`);
+  console.log(`  Errors:         ${chalk2.red(stats.errors)}`);
+  console.log(`  Mapped folders: ${stats.mappedFolders}`);
+  try {
+    const cases = await listCases(config);
+    console.log(`
+  Server cases:   ${cases.length}`);
+    console.log(`  Auth:           ${chalk2.green("valid")}`);
+  } catch {
+    console.log(`
+  Auth:           ${chalk2.red("expired \u2014 run anrak-sync login")}`);
+  }
+  console.log("");
+});
+program.command("map").description("Show folder-to-case mappings").action(async () => {
+  const config = requireConfig();
+  const mappings = getAllMappings();
+  const entries = Object.entries(mappings);
+  console.log(chalk2.bold.blue("\n  AnrakLegal Sync \u2014 Mappings\n"));
+  if (entries.length === 0) {
+    log.info("No mappings yet. Run `anrak-sync push` or `anrak-sync start` to create them.");
+  } else {
+    for (const [folder, mapping] of entries) {
+      console.log(
+        `  ${chalk2.cyan(folder)} -> ${mapping.caseNumber} (${chalk2.dim(mapping.caseName)})`
+      );
+    }
+  }
+  try {
+    const cases = await listCases(config);
+    const mappedIds = new Set(entries.map(([, m]) => m.caseId));
+    const unmapped = cases.filter((c) => !mappedIds.has(c.id));
+    if (unmapped.length > 0) {
+      console.log(chalk2.dim("\n  Unmapped server cases:"));
+      for (const c of unmapped) {
+        console.log(`    ${chalk2.dim(c.caseNumber)} ${chalk2.dim(c.caseName)}`);
+      }
+    }
+  } catch {
+  }
+  console.log("");
+});
+program.command("reset").description("Clear sync cache (will re-scan and re-upload on next sync)").action(() => {
+  resetCache();
+  log.success("Cache cleared. Run `anrak-sync push` to re-sync.");
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  const config = loadConfig();
+  if (config) {
+    config.accessToken = "";
+    config.refreshToken = "";
+    saveConfig(config);
+  }
+  log.success("Logged out. Run `anrak-sync login` to re-authenticate.");
+});
+function requireConfig() {
+  const config = loadConfig();
+  if (!config) {
+    log.error("Not configured. Run `anrak-sync init` first.");
+    process.exit(1);
+  }
+  return config;
+}
+program.parse();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@anraktech/sync",
+  "version": "0.1.0",
+  "description": "AnrakLegal desktop file sync agent — watches local folders and syncs to case management",
+  "type": "module",
+  "bin": {
+    "anrak-sync": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.49.0",
+    "chalk": "^5.4.0",
+    "chokidar": "^4.0.0",
+    "commander": "^13.1.0",
+    "mime-types": "^2.1.35"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^2.1.4",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}