@piut/cli 1.0.2 → 1.1.0

package/README.md

@@ -1,8 +1,12 @@
-# pıut
+# pıut
 
-**Give every AI tool persistent memory about you.**
+**Your AI context, everywhere. Your config files, backed up.**
 
-pıut is a personal context service that works via [MCP (Model Context Protocol)](https://modelcontextprotocol.io). Connect once, and every AI tool you use — Claude, ChatGPT, Cursor, Copilot, and more — knows who you are, what you're working on, and how you like to work.
+pıut does three things that build on each other:
+
+1. **Host your brain** — Centralized personal context as an MCP server. Connect once, and every AI tool you use knows who you are, how you work, and what matters to you.
+2. **Keep it updated** — 6 MCP tools let your AI read, write, search, and organize your context automatically. Add a skill reference and it happens without you lifting a finger.
+3. **Back up your files** — Cloud backup of all your agent config files (CLAUDE.md, .cursorrules, AGENTS.md, etc.) with version history, restore, and cross-machine sync.
 
 ## Quick Start
 
@@ -10,7 +14,10 @@ pıut is a personal context service that works via [MCP (Model Context Protocol)
 npx @piut/cli
 ```
 
-That's it. The CLI auto-detects your AI tools and configures them.
+The CLI does everything in one interactive flow:
+- Configures your AI tools with your MCP server
+- Adds skill.md references to your rules files
+- Scans and backs up your agent config files to the cloud
 
 Or set up manually:
 
@@ -39,9 +46,19 @@ See [piut.com/docs](https://piut.com/docs#add-to-ai) for setup guides for 14+ AI
 Install globally or run with `npx`:
 
 ```bash
-npx @piut/cli              # Auto-detect and configure AI tools
+# Setup & Configuration
+npx @piut/cli              # Interactive setup: MCP + skill.md + cloud backup
 npx @piut/cli status       # Show which tools are connected
 npx @piut/cli remove       # Remove pıut from selected tools
+
+# Cloud Backup
+npx @piut/cli sync         # Show backup status for current workspace
+npx @piut/cli sync --install  # Scan workspace, detect files, upload to cloud
+npx @piut/cli sync --push  # Push local changes to cloud
+npx @piut/cli sync --pull  # Pull cloud changes to local files
+npx @piut/cli sync --history   # Show version history for a file
+npx @piut/cli sync --diff  # Show diff between local and cloud
+npx @piut/cli sync --restore   # Restore files from cloud backup
 ```
 
 **Options:**
@@ -50,17 +67,16 @@ npx @piut/cli remove       # Remove pıut from selected tools
 npx @piut/cli --key pb_... # Pass API key non-interactively
 npx @piut/cli --tool cursor # Configure a single tool
 npx @piut/cli --skip-skill  # Skip skill.md file placement
+npx @piut/cli sync --install --yes  # Non-interactive backup setup
 ```
 
 **Supported tools:** Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed
 
-## How It Works
+## The Three Features
 
-1. **Build your context** — Answer 5 questions or import existing files from your AI tools
-2. **Connect your tools** — Run `npx @piut/cli` or add one config, and every connected AI knows your context
-3. **Stay in sync** — Update your context once, and it's reflected everywhere
+### 1. Host Your Brain (MCP Server)
 
-Your context is organized into 5 sections:
+Your brain is organized into 5 sections, accessible from every AI tool via MCP:
 
 | Section | What it stores |
 |---------|---------------|
@@ -70,21 +86,9 @@ Your context is organized into 5 sections:
 | **Projects** | Active, time-bound work with goals and deadlines |
 | **Memory** | Bookmarks, links, ideas, notes, reference material |
 
-## Documentation
-
-| Document | Description |
-|----------|-------------|
-| [**skill.md**](skill.md) | AI skill file — MCP tools, rate limits, error codes |
-| [**Add to your AI**](https://piut.com/docs#add-to-ai) | Setup guides for Claude, ChatGPT, Cursor, Copilot, and more |
-| [**API Reference**](https://piut.com/docs#api-examples) | Code examples in cURL, Python, Node.js, Go, and Ruby |
-| [**Rate Limits**](https://piut.com/docs#limits) | Limits by plan, error codes, and response headers |
-| [**Context Files**](https://piut.com/docs#context-files) | Where to find your existing context in 14 AI platforms |
-
-All documentation is maintained at [piut.com/docs](https://piut.com/docs) — the interactive version with credential auto-fill and setup guides.
-
-## MCP Tools
+### 2. Keep It Updated (MCP Tools + Skill)
 
-pıut provides 6 tools via MCP:
+6 tools let your AI read and write your brain:
 
 | Tool | Purpose |
 |------|---------|
@@ -95,7 +99,36 @@ pıut provides 6 tools via MCP:
 | `update_brain` | AI-powered smart update across sections |
 | `prompt_brain` | Natural language command (edit, delete, reorganize) |
 
-Full tool documentation: [skill.md](skill.md)
+Add the [skill reference](skill.md) to your rules file and your AI uses these tools automatically.
+
+### 3. Back Up Your Files (Cloud Backup)
+
+The CLI scans your workspace for agent config files and backs them up to the cloud:
+
+| File | Tool |
+|------|------|
+| `CLAUDE.md` | Claude Code |
+| `AGENTS.md` | Multi-agent |
+| `.cursorrules` | Cursor |
+| `.windsurfrules` | Windsurf |
+| `copilot-instructions.md` | GitHub Copilot |
+| `MEMORY.md` | Claude Code |
+| `SOUL.md` | OpenClaw |
+| `rules/*.md` | Various |
+
+Files are encrypted at rest (AES-256-GCM), versioned, and syncable across machines.
+
+## Documentation
+
+| Document | Description |
+|----------|-------------|
+| [**skill.md**](skill.md) | AI skill file — MCP tools, rate limits, error codes |
+| [**Add to your AI**](https://piut.com/docs#add-to-ai) | Setup guides for Claude, ChatGPT, Cursor, Copilot, and more |
+| [**API Reference**](https://piut.com/docs#api-examples) | Code examples in cURL, Python, Node.js, Go, and Ruby |
+| [**Cloud Backup**](https://piut.com/docs#cloud-backup) | Cloud backup setup, commands, and sync workflow |
+| [**Rate Limits**](https://piut.com/docs#limits) | Limits by plan, error codes, and response headers |
+
+All documentation is maintained at [piut.com/docs](https://piut.com/docs) — the interactive version with credential auto-fill and setup guides.
 
 ## Links
 

package/dist/cli.js

@@ -505,10 +505,1172 @@ async function removeCommand() {
   console.log();
 }
 
+// src/commands/sync.ts
+import fs8 from "fs";
+import crypto2 from "crypto";
+import { password as password2, confirm as confirm3, checkbox as checkbox3, select } from "@inquirer/prompts";
+import chalk3 from "chalk";
+
+// src/lib/scanner.ts
+import fs6 from "fs";
+import path6 from "path";
+import os3 from "os";
+var KNOWN_FILES = [
+  "CLAUDE.md",
+  ".claude/MEMORY.md",
+  ".claude/settings.json",
+  "AGENTS.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".github/copilot-instructions.md",
+  ".cursor/rules/*.md",
+  ".cursor/rules/*.mdc",
+  ".windsurf/rules/*.md",
+  ".claude/rules/*.md",
+  "CONVENTIONS.md",
+  ".zed/rules.md"
+];
+var GLOBAL_FILES = [
+  "~/.claude/MEMORY.md",
+  "~/.claude/settings.local.json",
+  "~/.openclaw/workspace/SOUL.md",
+  "~/.openclaw/workspace/MEMORY.md",
+  "~/.openclaw/workspace/IDENTITY.md",
+  "~/.config/agent/IDENTITY.md"
+];
+function detectInstalledTools() {
+  const installed = [];
+  for (const tool of TOOLS) {
+    const paths = resolveConfigPaths(tool.configPaths);
+    for (const configPath of paths) {
+      if (fs6.existsSync(configPath) || fs6.existsSync(path6.dirname(configPath))) {
+        installed.push({ name: tool.name, id: tool.id });
+        break;
+      }
+    }
+  }
+  return installed;
+}
+function categorizeFile(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.includes(".claude/") || lower.includes("claude.md")) return "Claude Code";
+  if (lower.includes(".cursor/") || lower.includes(".cursorrules")) return "Cursor Rules";
+  if (lower.includes(".windsurf/") || lower.includes(".windsurfrules")) return "Windsurf Rules";
+  if (lower.includes(".github/copilot")) return "VS Code / Copilot";
+  if (lower.includes(".aws/amazonq")) return "Amazon Q";
+  if (lower.includes(".zed/")) return "Zed";
+  if (lower.includes(".openclaw/")) return "OpenClaw";
+  return "Custom";
+}
+function matchesGlob(filename, pattern) {
+  if (!pattern.includes("*")) return filename === pattern;
+  const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+  return regex.test(filename);
+}
+function scanDirectory(dir, patterns) {
+  const found = [];
+  for (const pattern of patterns) {
+    const parts = pattern.split("/");
+    if (parts.length === 1) {
+      const filePath = path6.join(dir, pattern);
+      if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+        found.push(filePath);
+      }
+    } else {
+      const lastPart = parts[parts.length - 1];
+      const dirPart = parts.slice(0, -1).join("/");
+      const fullDir = path6.join(dir, dirPart);
+      if (lastPart.includes("*")) {
+        if (fs6.existsSync(fullDir) && fs6.statSync(fullDir).isDirectory()) {
+          try {
+            const entries = fs6.readdirSync(fullDir);
+            for (const entry of entries) {
+              if (matchesGlob(entry, lastPart)) {
+                const fullPath = path6.join(fullDir, entry);
+                if (fs6.statSync(fullPath).isFile()) {
+                  found.push(fullPath);
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      } else {
+        const filePath = path6.join(dir, pattern);
+        if (fs6.existsSync(filePath) && fs6.statSync(filePath).isFile()) {
+          found.push(filePath);
+        }
+      }
+    }
+  }
+  return found;
+}
+function scanForFiles(workspaceDirs) {
+  const home2 = os3.homedir();
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const globalPath of GLOBAL_FILES) {
+    const absPath = expandPath(globalPath);
+    if (fs6.existsSync(absPath) && fs6.statSync(absPath).isFile()) {
+      if (seen.has(absPath)) continue;
+      seen.add(absPath);
+      files.push({
+        absolutePath: absPath,
+        displayPath: globalPath,
+        sizeBytes: fs6.statSync(absPath).size,
+        category: "Global",
+        type: "global",
+        projectName: "Global"
+      });
+    }
+  }
+  const dirs = workspaceDirs || [process.cwd()];
+  for (const dir of dirs) {
+    const absDir = path6.resolve(dir);
+    if (!fs6.existsSync(absDir)) continue;
+    const foundPaths = scanDirectory(absDir, KNOWN_FILES);
+    for (const filePath of foundPaths) {
+      if (seen.has(filePath)) continue;
+      seen.add(filePath);
+      const relativePath = path6.relative(absDir, filePath);
+      const projectName = path6.basename(absDir);
+      files.push({
+        absolutePath: filePath,
+        displayPath: path6.relative(home2, filePath).startsWith("..") ? filePath : "~/" + path6.relative(home2, filePath),
+        sizeBytes: fs6.statSync(filePath).size,
+        category: categorizeFile(filePath),
+        type: "project",
+        projectName
+      });
+    }
+  }
+  return files;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(1)} MB`;
+}
+
+// src/lib/sync-api.ts
+var API_BASE2 = process.env.PIUT_API_BASE || "https://piut.com";
+function authHeaders(apiKey) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+}
+async function uploadFiles(apiKey, files) {
+  const res = await fetch(`${API_BASE2}/api/sync/upload`, {
+    method: "POST",
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ files })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Upload failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function listFiles(apiKey) {
+  const res = await fetch(`${API_BASE2}/api/sync/files`, {
+    headers: authHeaders(apiKey)
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `List failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function pullFiles(apiKey, fileIds, deviceId) {
+  const res = await fetch(`${API_BASE2}/api/sync/pull`, {
+    method: "POST",
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ fileIds, deviceId })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Pull failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function listFileVersions(apiKey, fileId) {
+  const res = await fetch(`${API_BASE2}/api/sync/files/${fileId}/versions`, {
+    headers: authHeaders(apiKey)
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Version list failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function getFileVersion(apiKey, fileId, version) {
+  const res = await fetch(`${API_BASE2}/api/sync/files/${fileId}/versions/${version}`, {
+    headers: authHeaders(apiKey)
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Version fetch failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function resolveConflict(apiKey, fileId, resolution, localContent, deviceId, deviceName) {
+  const res = await fetch(`${API_BASE2}/api/sync/resolve`, {
+    method: "POST",
+    headers: authHeaders(apiKey),
+    body: JSON.stringify({ fileId, resolution, localContent, deviceId, deviceName })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Resolve failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+
+// src/lib/sync-config.ts
+import fs7 from "fs";
+import path7 from "path";
+import os4 from "os";
+import crypto from "crypto";
+var CONFIG_DIR = path7.join(os4.homedir(), ".piut");
+var CONFIG_FILE = path7.join(CONFIG_DIR, "config.json");
+function defaultDeviceName() {
+  return os4.hostname() || "unknown";
+}
+function generateDeviceId() {
+  return `dev_${crypto.randomBytes(8).toString("hex")}`;
+}
+function readSyncConfig() {
+  const defaults = {
+    deviceId: generateDeviceId(),
+    deviceName: defaultDeviceName(),
+    autoDiscover: false,
+    keepBrainUpdated: false,
+    useBrain: false,
+    backedUpFiles: []
+  };
+  try {
+    const raw = fs7.readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...defaults, ...parsed };
+  } catch {
+    return defaults;
+  }
+}
+function writeSyncConfig(config) {
+  fs7.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs7.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function updateSyncConfig(updates) {
+  const config = readSyncConfig();
+  const updated = { ...config, ...updates };
+  writeSyncConfig(updated);
+  return updated;
+}
+function getConfigFile() {
+  return CONFIG_FILE;
+}
+
+// src/lib/sensitive-guard.ts
+var SECRET_PATTERNS = [
+  // API keys and tokens
+  /(?:api[_-]?key|apikey|secret[_-]?key|access[_-]?token|auth[_-]?token|bearer)\s*[:=]\s*['"]?[A-Za-z0-9_\-/.]{20,}/i,
+  // AWS credentials
+  /AKIA[0-9A-Z]{16}/,
+  // Private keys
+  /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+  // Supabase service role JWTs (eyJ...)
+  /SUPABASE_SERVICE_ROLE_KEY\s*[:=]\s*['"]?eyJ/i,
+  // Generic JWT tokens assigned to variables
+  /(?:JWT|TOKEN|SECRET|PASSWORD|CREDENTIAL)\s*[:=]\s*['"]?eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/i,
+  // Connection strings
+  /(?:postgres|mysql|mongodb|redis):\/\/[^\s'"]+:[^\s'"]+@/i,
+  // Stripe keys
+  /sk_(?:live|test)_[A-Za-z0-9]{20,}/,
+  // Anthropic keys
+  /sk-ant-[A-Za-z0-9_-]{20,}/,
+  // OpenAI keys
+  /sk-[A-Za-z0-9]{40,}/,
+  // npm tokens
+  /npm_[A-Za-z0-9]{36}/,
+  // GitHub tokens
+  /gh[pousr]_[A-Za-z0-9]{36,}/,
+  // Generic password assignments
+  /(?:password|passwd|pwd)\s*[:=]\s*['"][^'"]{8,}['"]/i
+];
+var BLOCKED_FILENAMES = [
+  ".env",
+  ".env.local",
+  ".env.production",
+  ".env.development",
+  ".env.staging",
+  ".env.test",
+  "credentials.json",
+  "service-account.json",
+  "secrets.json",
+  "secrets.yaml",
+  "secrets.yml",
+  ".netrc",
+  ".npmrc",
+  "id_rsa",
+  "id_ed25519",
+  "id_ecdsa"
+];
+function isBlockedFilename(filePath) {
+  const basename = filePath.split("/").pop() || "";
+  return BLOCKED_FILENAMES.some(
+    (blocked) => basename === blocked || basename.startsWith(".env.")
+  );
+}
+function scanForSecrets(content) {
+  const matches = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(line)) {
+        const preview = line.length > 80 ? line.slice(0, 77) + "..." : line;
+        matches.push({
+          line: i + 1,
+          preview: preview.replace(/(['"])[A-Za-z0-9_\-/.+=]{20,}(['"])/g, "$1[REDACTED]$2"),
+          pattern: pattern.source.slice(0, 40)
+        });
+        break;
+      }
+    }
+  }
+  return matches;
+}
+function guardFile(filePath, content) {
+  if (isBlockedFilename(filePath)) {
+    return { blocked: true, reason: "filename", matches: [] };
+  }
+  const matches = scanForSecrets(content);
+  if (matches.length > 0) {
+    return { blocked: true, reason: "content", matches };
+  }
+  return { blocked: false, reason: null, matches: [] };
+}
+
+// src/commands/sync.ts
+async function syncCommand(options) {
+  if (options.install) {
+    await installFlow(options);
+  } else if (options.push) {
+    await pushFlow(options);
+  } else if (options.pull) {
+    await pullFlow(options);
+  } else if (options.watch) {
+    await watchFlow();
+  } else if (options.history) {
+    await historyFlow(options.history);
+  } else if (options.diff) {
+    await diffFlow(options.diff);
+  } else if (options.restore) {
+    await restoreFlow(options.restore);
+  } else if (options.installDaemon) {
+    await installDaemonFlow();
+  } else {
+    await statusFlow();
+  }
+}
+function guardAndFilter(files, options) {
+  const safe = [];
+  let blocked = 0;
+  for (const file of files) {
+    const content = fs8.readFileSync(file.absolutePath, "utf-8");
+    const result = guardFile(file.displayPath, content);
+    if (result.blocked) {
+      blocked++;
+      if (result.reason === "filename") {
+        console.log(chalk3.red(`  BLOCKED ${file.displayPath}`) + dim(" (sensitive filename)"));
+      } else {
+        console.log(chalk3.red(`  BLOCKED ${file.displayPath}`) + dim(" (contains secrets)"));
+        for (const match of result.matches.slice(0, 3)) {
+          console.log(dim(`    line ${match.line}: ${match.preview}`));
+        }
+        if (result.matches.length > 3) {
+          console.log(dim(`    ... and ${result.matches.length - 3} more`));
+        }
+      }
+    } else {
+      safe.push(file);
+    }
+  }
+  if (blocked > 0) {
+    console.log();
+    console.log(warning(`  ${blocked} file(s) blocked by sensitive file guard`));
+    console.log(dim("  These files will not be uploaded to protect your secrets."));
+    console.log();
+  }
+  return safe;
+}
+async function installFlow(options) {
+  banner();
+  console.log(brand.bold("  Cloud Backup Setup"));
+  console.log();
+  const config = readSyncConfig();
+  let apiKey = options.key || config.apiKey;
+  if (!apiKey) {
+    console.log(dim("  Enter your API key, or press Enter to get one at piut.com/dashboard"));
+    console.log();
+    apiKey = await password2({
+      message: "Enter your API key (or press Enter to get one)",
+      mask: "*",
+      validate: (v) => {
+        if (!v) return true;
+        return v.startsWith("pb_") || "Key must start with pb_";
+      }
+    });
+    if (!apiKey) {
+      console.log();
+      console.log(`  Get an API key at: ${brand("https://piut.com/dashboard")}`);
+      console.log(dim("  Then run: npx @piut/cli sync --install"));
+      console.log();
+      return;
+    }
+  }
+  console.log(dim("  Validating key..."));
+  let validationResult;
+  try {
+    validationResult = await validateKey(apiKey);
+  } catch (err) {
+    console.log(chalk3.red(`  \u2717 ${err.message}`));
+    console.log(dim("  Get a key at https://piut.com/dashboard"));
+    process.exit(1);
+  }
+  console.log(success(`  \u2713 Authenticated as ${validationResult.displayName}`));
+  console.log();
+  updateSyncConfig({ apiKey });
+  console.log(dim("  Scanning your AI tool environments..."));
+  const tools = detectInstalledTools();
+  if (tools.length === 0) {
+    console.log(warning("  No AI tools detected."));
+    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, Copilot, Amazon Q, Zed"));
+    console.log();
+    return;
+  }
+  console.log(success(`  \u2713 Found ${tools.length} product${tools.length === 1 ? "" : "s"} installed:`));
+  for (const tool of tools) {
+    console.log(`    - ${tool.name}`);
+  }
+  console.log();
+  if (!options.yes) {
+    const proceed = await confirm3({
+      message: `Continue with all ${tools.length}?`,
+      default: true
+    });
+    if (!proceed) {
+      console.log(dim("  Setup cancelled."));
+      return;
+    }
+  }
+  console.log();
+  console.log(dim("  Scanning for brain files..."));
+  console.log(dim("  (looking for: CLAUDE.md, MEMORY.md, SOUL.md, IDENTITY.md, .cursorrules, etc.)"));
+  console.log();
+  if (!options.yes) {
+    const scanPermission = await confirm3({
+      message: "Permission to scan your workspace?",
+      default: true
+    });
+    if (!scanPermission) {
+      console.log(dim("  Scan cancelled."));
+      return;
+    }
+  }
+  const scannedFiles = scanForFiles();
+  if (scannedFiles.length === 0) {
+    console.log(warning("  No agent config files found in the current workspace."));
+    console.log(dim("  Try running from a project directory with CLAUDE.md, .cursorrules, etc."));
+    console.log();
+    return;
+  }
+  const safeFiles = guardAndFilter(scannedFiles, options);
+  if (safeFiles.length === 0) {
+    console.log(warning("  All files were blocked by the sensitive file guard."));
+    console.log();
+    return;
+  }
+  console.log();
+  console.log(`  Found ${brand.bold(String(safeFiles.length))} safe files across your workspace:`);
+  console.log();
+  const grouped = groupByCategory(safeFiles);
+  const choices = [];
+  for (const [category, files] of Object.entries(grouped)) {
+    console.log(dim(`  \u{1F4C1} ${category}`));
+    for (const file of files) {
+      console.log(`    \u2611 ${file.displayPath}`);
+      choices.push({
+        name: `${file.displayPath} ${dim(`(${formatSize(file.sizeBytes)})`)}`,
+        value: file,
+        checked: true
+      });
+    }
+    console.log();
+  }
+  let selectedFiles;
+  if (options.yes) {
+    selectedFiles = safeFiles;
+  } else {
+    selectedFiles = await checkbox3({
+      message: `Back up all ${safeFiles.length} files?`,
+      choices
+    });
+    if (selectedFiles.length === 0) {
+      console.log(dim("  No files selected."));
+      return;
+    }
+  }
+  await uploadScannedFiles(apiKey, selectedFiles);
+  console.log();
+  console.log(`  View your backups: ${brand("https://piut.com/dashboard/backups")}`);
+  console.log();
+  if (!options.yes) {
+    const autoBackup = await confirm3({
+      message: "Configure auto-backup?",
+      default: false
+    });
+    if (autoBackup) {
+      updateSyncConfig({ autoDiscover: true });
+      console.log(success("  \u2713 Auto-backup enabled."));
+      console.log(dim("  New files in the same environments will be backed up automatically."));
+      console.log(dim("  Configure: piut sync config"));
+    }
+  }
+  console.log();
+}
+async function pushFlow(options) {
+  banner();
+  const config = readSyncConfig();
+  const apiKey = options.key || config.apiKey;
+  if (!apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  console.log(dim("  Scanning for changes..."));
+  const files = scanForFiles();
+  if (files.length === 0) {
+    console.log(dim("  No files found to push."));
+    return;
+  }
+  const safeFiles = guardAndFilter(files, options);
+  if (safeFiles.length === 0) {
+    console.log(dim("  No safe files to push."));
+    return;
+  }
+  if (!options.preferLocal && !options.preferCloud) {
+    try {
+      const cloudFiles = await listFiles(apiKey);
+      for (const localFile of safeFiles) {
+        const localContent = fs8.readFileSync(localFile.absolutePath, "utf-8");
+        const localHash = hashContent(localContent);
+        const cloudFile = cloudFiles.files.find(
+          (cf) => cf.file_path === localFile.displayPath && cf.project_name === localFile.projectName
+        );
+        if (cloudFile && cloudFile.content_hash !== localHash) {
+          console.log(warning(`  Conflict: ${localFile.displayPath}`));
+          console.log(dim(`    local hash:  ${localHash.slice(0, 12)}...`));
+          console.log(dim(`    cloud hash:  ${cloudFile.content_hash.slice(0, 12)}...`));
+          if (!options.yes) {
+            const resolution = await select({
+              message: `How to resolve ${localFile.displayPath}?`,
+              choices: [
+                { name: "Keep local (push local to cloud)", value: "keep-local" },
+                { name: "Keep cloud (skip this file)", value: "keep-cloud" }
+              ]
+            });
+            if (resolution === "keep-cloud") {
+              await resolveConflict(apiKey, cloudFile.id, "keep-cloud", void 0, config.deviceId, config.deviceName);
+              console.log(success(`  \u2713 Kept cloud version of ${localFile.displayPath}`));
+              const idx = safeFiles.indexOf(localFile);
+              if (idx >= 0) safeFiles.splice(idx, 1);
+              continue;
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await uploadScannedFiles(apiKey, safeFiles);
+  console.log();
+}
+async function pullFlow(options) {
+  banner();
+  const config = readSyncConfig();
+  const apiKey = options.key || config.apiKey;
+  if (!apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  console.log(dim("  Pulling latest versions from cloud..."));
+  try {
+    const result = await pullFiles(apiKey, void 0, config.deviceId);
+    if (result.files.length === 0) {
+      console.log(dim("  No files to pull. Everything is up to date."));
+      return;
+    }
+    for (const file of result.files) {
+      console.log(success(`  \u2713 ${file.file_path}`) + dim(` (v${file.current_version})`));
+    }
+    console.log();
+    console.log(success(`  Pulled ${result.files.length} file(s)`));
+  } catch (err) {
+    console.log(chalk3.red(`  \u2717 Pull failed: ${err.message}`));
+    process.exit(1);
+  }
+  console.log();
+}
+async function historyFlow(filePathOrId) {
+  banner();
+  console.log(brand.bold("  Version History"));
+  console.log();
+  const config = readSyncConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  const fileId = await resolveFileId(config.apiKey, filePathOrId);
+  if (!fileId) {
+    console.log(chalk3.red(`  \u2717 File not found: ${filePathOrId}`));
+    process.exit(1);
+  }
+  const result = await listFileVersions(config.apiKey, fileId);
+  console.log(`  ${brand.bold(result.filePath)} (${result.projectName})`);
+  console.log(`  Current version: v${result.currentVersion}`);
+  console.log();
+  for (const v of result.versions) {
+    const date = new Date(v.createdAt).toLocaleString();
+    const size = formatSize(v.contentSize);
+    const summary = v.changeSummary ? ` \u2014 ${v.changeSummary}` : "";
+    const marker = v.version === result.currentVersion ? chalk3.green(" (current)") : "";
+    console.log(`  v${v.version}  ${dim(date)}  ${dim(size)}${summary}${marker}`);
+  }
+  console.log();
+}
+async function diffFlow(filePathOrId) {
+  banner();
+  console.log(brand.bold("  Local vs Cloud Diff"));
+  console.log();
+  const config = readSyncConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  const fileId = await resolveFileId(config.apiKey, filePathOrId);
+  if (!fileId) {
+    console.log(chalk3.red(`  \u2717 File not found in cloud: ${filePathOrId}`));
+    process.exit(1);
+  }
+  const versions = await listFileVersions(config.apiKey, fileId);
+  const cloudVersion = await getFileVersion(config.apiKey, fileId, versions.currentVersion);
+  const cloudContent = cloudVersion.content;
+  const localPath = resolveLocalPath(filePathOrId, versions.filePath);
+  if (!localPath || !fs8.existsSync(localPath)) {
+    console.log(warning(`  Local file not found: ${filePathOrId}`));
+    console.log(dim("  Showing cloud content only:"));
+    console.log();
+    console.log(cloudContent);
+    return;
+  }
+  const localContent = fs8.readFileSync(localPath, "utf-8");
+  if (localContent === cloudContent) {
+    console.log(success("  \u2713 Local and cloud are identical"));
+    console.log();
+    return;
+  }
+  const localLines = localContent.split("\n");
+  const cloudLines = cloudContent.split("\n");
+  const maxLen = Math.max(localLines.length, cloudLines.length);
+  console.log(`  ${versions.filePath}`);
+  console.log(dim(`  local: ${localLines.length} lines | cloud v${versions.currentVersion}: ${cloudLines.length} lines`));
+  console.log();
+  let diffCount = 0;
+  for (let i = 0; i < maxLen; i++) {
+    const local = localLines[i];
+    const cloud = cloudLines[i];
+    if (local !== cloud) {
+      diffCount++;
+      if (diffCount > 50) {
+        console.log(dim(`  ... and more differences (${maxLen - i} lines remaining)`));
+        break;
+      }
+      if (cloud !== void 0 && local !== void 0) {
+        console.log(chalk3.red(`  - ${i + 1}: ${cloud}`));
+        console.log(chalk3.green(`  + ${i + 1}: ${local}`));
+      } else if (cloud === void 0) {
+        console.log(chalk3.green(`  + ${i + 1}: ${local}`));
+      } else {
+        console.log(chalk3.red(`  - ${i + 1}: ${cloud}`));
+      }
+    }
+  }
+  console.log();
+  console.log(dim(`  ${diffCount} line(s) differ`));
+  console.log();
+}
+async function restoreFlow(filePathOrId) {
+  banner();
+  console.log(brand.bold("  Restore from Cloud"));
+  console.log();
+  const config = readSyncConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  const fileId = await resolveFileId(config.apiKey, filePathOrId);
+  if (!fileId) {
+    console.log(chalk3.red(`  \u2717 File not found in cloud: ${filePathOrId}`));
+    process.exit(1);
+  }
+  const versionsResult = await listFileVersions(config.apiKey, fileId);
+  console.log(`  ${brand.bold(versionsResult.filePath)} (${versionsResult.projectName})`);
+  console.log();
+  if (versionsResult.versions.length <= 1) {
+    console.log(dim("  Only one version available. Nothing to restore."));
+    console.log();
+    return;
+  }
+  const versionChoice = await select({
+    message: "Which version to restore?",
+    choices: versionsResult.versions.map((v) => ({
+      name: `v${v.version} \u2014 ${new Date(v.createdAt).toLocaleString()} (${formatSize(v.contentSize)})${v.changeSummary ? ` \u2014 ${v.changeSummary}` : ""}`,
+      value: v.version
+    }))
+  });
+  const versionData = await getFileVersion(config.apiKey, fileId, versionChoice);
+  const localPath = resolveLocalPath(filePathOrId, versionsResult.filePath);
+  console.log();
+  console.log(dim(`  Restoring v${versionChoice} of ${versionsResult.filePath}...`));
+  const result = await uploadFiles(config.apiKey, [{
+    projectName: versionsResult.projectName,
+    filePath: versionsResult.filePath,
+    content: versionData.content,
+    category: "project",
+    deviceId: config.deviceId,
+    deviceName: config.deviceName
+  }]);
+  if (result.uploaded > 0) {
+    console.log(success(`  \u2713 Cloud restored to v${versionChoice} content (saved as new version)`));
+  }
+  if (localPath) {
+    const writeLocal = await confirm3({
+      message: `Also write to local file ${localPath}?`,
+      default: true
+    });
+    if (writeLocal) {
+      fs8.writeFileSync(localPath, versionData.content, "utf-8");
+      console.log(success(`  \u2713 Local file updated: ${localPath}`));
+    }
+  }
+  console.log();
+}
+async function watchFlow() {
+  banner();
+  console.log(brand.bold("  Live Sync (Watch Mode)"));
+  console.log();
+  const config = readSyncConfig();
+  if (!config.apiKey) {
+    console.log(chalk3.red("  \u2717 Not configured. Run: npx @piut/cli sync --install"));
+    process.exit(1);
+  }
+  let chokidar;
+  try {
+    chokidar = await import("chokidar");
+  } catch {
+    console.log(chalk3.red("  \u2717 chokidar is required for watch mode."));
+    console.log(dim("  Install it: npm install -g chokidar"));
+    console.log(dim("  Or use cron-based sync: piut sync --install-daemon"));
+    process.exit(1);
+  }
+  const files = scanForFiles();
+  const safeFiles = guardAndFilter(files, { yes: true });
+  if (safeFiles.length === 0) {
+    console.log(dim("  No files to watch."));
+    return;
+  }
+  const watchPaths = safeFiles.map((f) => f.absolutePath);
+  console.log(dim(`  Watching ${watchPaths.length} file(s) for changes...`));
+  for (const f of safeFiles) {
+    console.log(dim(`    ${f.displayPath}`));
+  }
+  console.log();
+  console.log(dim("  Press Ctrl+C to stop."));
+  console.log();
+  const debounceMap = /* @__PURE__ */ new Map();
+  const DEBOUNCE_MS = 2e3;
+  const watcher = chokidar.watch(watchPaths, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
+  });
+  watcher.on("change", (changedPath) => {
+    const existing = debounceMap.get(changedPath);
+    if (existing) clearTimeout(existing);
+    debounceMap.set(changedPath, setTimeout(async () => {
+      debounceMap.delete(changedPath);
+      const file = safeFiles.find((f) => f.absolutePath === changedPath);
+      if (!file) return;
+      const content = fs8.readFileSync(changedPath, "utf-8");
+      const guardResult = guardFile(file.displayPath, content);
+      if (guardResult.blocked) {
+        console.log(chalk3.red(`  BLOCKED ${file.displayPath}`) + dim(" (sensitive content detected)"));
+        return;
+      }
+      try {
+        const result = await uploadFiles(config.apiKey, [{
+          projectName: file.projectName,
+          filePath: file.displayPath,
+          content,
+          category: file.type,
+          deviceId: config.deviceId,
+          deviceName: config.deviceName
+        }]);
+        const uploaded = result.files.find((f) => f.status === "ok");
+        if (uploaded) {
+          const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+          console.log(success(`  \u2713 ${file.displayPath}`) + dim(` v${uploaded.version} (${time})`));
+        }
+      } catch (err) {
+        console.log(chalk3.red(`  \u2717 ${file.displayPath}: ${err.message}`));
+      }
+    }, DEBOUNCE_MS));
+  });
+  await new Promise(() => {
+  });
+}
+async function installDaemonFlow() {
+  banner();
+  console.log(brand.bold("  Auto-Sync Daemon Setup"));
+  console.log();
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    await installMacDaemon();
+  } else if (platform2 === "linux") {
+    installLinuxCron();
+  } else {
+    console.log(dim("  Auto-sync daemon setup is available for macOS and Linux."));
+    console.log();
+    console.log(dim("  Manual alternative: add this to your crontab (crontab -e):"));
+    console.log();
+    console.log(`    */30 * * * * cd ~ && npx @piut/cli sync --push --yes 2>&1 >> ~/.piut/sync.log`);
+    console.log();
+  }
+}
+async function installMacDaemon() {
+  const plistName = "com.piut.auto-sync";
+  const plistDir = `${process.env.HOME}/Library/LaunchAgents`;
+  const plistPath = `${plistDir}/${plistName}.plist`;
+  const logDir = `${process.env.HOME}/.piut/logs`;
+  const npxPath = await resolveNpxPath();
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${plistName}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${npxPath}</string>
+    <string>@piut/cli</string>
+    <string>sync</string>
+    <string>--push</string>
+    <string>--yes</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>1800</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>WorkingDirectory</key>
+  <string>${process.env.HOME}</string>
+  <key>StandardOutPath</key>
+  <string>${logDir}/sync.out.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/sync.err.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${process.env.HOME}/.local/bin:${process.env.HOME}/.npm-global/bin</string>
+  </dict>
+</dict>
+</plist>`;
+  console.log(dim("  This will create a macOS LaunchAgent that runs every 30 minutes."));
+  console.log();
+  console.log(dim(`  Plist: ${plistPath}`));
+  console.log(dim(`  Logs:  ${logDir}/sync.{out,err}.log`));
+  console.log();
+  const proceed = await confirm3({
+    message: "Install the auto-sync LaunchAgent?",
+    default: true
+  });
+  if (!proceed) {
+    console.log(dim("  Cancelled."));
+    return;
+  }
+  fs8.mkdirSync(logDir, { recursive: true });
+  fs8.mkdirSync(plistDir, { recursive: true });
+  fs8.writeFileSync(plistPath, plistContent, "utf-8");
+  console.log(success(`  \u2713 Plist written: ${plistPath}`));
+  const { execSync: execSync2 } = await import("child_process");
+  try {
+    try {
+      execSync2(`launchctl bootout gui/$(id -u) ${plistPath} 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    execSync2(`launchctl bootstrap gui/$(id -u) ${plistPath}`);
+    console.log(success("  \u2713 LaunchAgent loaded \u2014 auto-sync active!"));
+  } catch {
+    console.log(warning("  LaunchAgent written but could not be loaded automatically."));
+    console.log(dim(`  Load manually: launchctl bootstrap gui/$(id -u) ${plistPath}`));
+  }
+  console.log();
+  console.log(dim("  To stop: launchctl bootout gui/$(id -u) com.piut.auto-sync"));
+  console.log(dim("  To check: launchctl print gui/$(id -u)/com.piut.auto-sync"));
+  console.log();
+}
+function installLinuxCron() {
+  console.log(dim("  Add this line to your crontab (run: crontab -e):"));
+  console.log();
+  console.log(`    */30 * * * * cd ~ && npx @piut/cli sync --push --yes 2>&1 >> ~/.piut/sync.log`);
+  console.log();
+  console.log(dim("  This will push changes every 30 minutes."));
+  console.log();
+}
+async function statusFlow() {
+  banner();
+  console.log(brand.bold("  Cloud Backup Status"));
+  console.log();
+  const config = readSyncConfig();
+  if (!config.apiKey) {
+    console.log(dim("  Not configured."));
+    console.log();
+    console.log(`  Get started: ${brand("npx @piut/cli sync --install")}`);
+    console.log();
+    return;
+  }
+  try {
+    const result = await listFiles(config.apiKey);
+    console.log(`  Files: ${brand.bold(String(result.fileCount))} / ${result.fileLimit}`);
+    console.log(`  Storage: ${brand.bold(formatSize(result.storageUsed))} / ${formatSize(result.storageLimit)}`);
+    console.log(`  Devices: ${result.devices.length}`);
+    console.log();
+    if (result.files.length > 0) {
+      console.log(dim("  Backed-up files:"));
+      for (const file of result.files) {
+        console.log(`    ${file.file_path} ${dim(`v${file.current_version}`)}`);
+      }
+    }
+    console.log();
+    console.log(dim("  Configuration:"));
+    console.log(`    Auto-discover: ${config.autoDiscover ? success("ON") : dim("OFF")}`);
+    console.log(`    Brain sync:    ${config.keepBrainUpdated ? success("ON") : dim("OFF")}`);
+    console.log(`    Use brain:     ${config.useBrain ? success("ON") : dim("OFF")}`);
+    console.log();
+    console.log(`  Dashboard: ${brand("https://piut.com/dashboard/backups")}`);
+  } catch (err) {
+    console.log(chalk3.red(`  \u2717 ${err.message}`));
+  }
+  console.log();
+}
+function hashContent(content) {
+  return crypto2.createHash("sha256").update(content, "utf8").digest("hex");
+}
+async function uploadScannedFiles(apiKey, files) {
+  console.log();
+  console.log(dim("  Backing up files..."));
+  const syncConfig = readSyncConfig();
+  const payloads = files.map((file) => ({
+    projectName: file.projectName,
+    filePath: file.displayPath,
+    content: fs8.readFileSync(file.absolutePath, "utf-8"),
+    category: file.type,
+    deviceId: syncConfig.deviceId,
+    deviceName: syncConfig.deviceName
+  }));
+  try {
+    const result = await uploadFiles(apiKey, payloads);
+    let totalSize = 0;
+    for (const file of result.files) {
+      const scanned = files.find(
+        (s) => s.displayPath === file.filePath && s.projectName === file.projectName
+      );
+      const size = scanned ? scanned.sizeBytes : 0;
+      totalSize += size;
+      if (file.status === "ok") {
+        console.log(success(`  \u2713 ${file.filePath}`) + dim(` (${formatSize(size)})`));
+      } else {
+        console.log(chalk3.red(`  \u2717 ${file.filePath}: ${file.status}`));
+      }
+    }
+    console.log();
+    if (result.uploaded > 0) {
+      console.log(success(`  \u2713 All files backed up successfully!`));
+      console.log();
+      console.log(dim("  \u{1F4CA} Backup complete:"));
+      console.log(dim(`     ${result.uploaded} files | ${formatSize(totalSize)} total`));
+    }
+    if (result.errors > 0) {
+      console.log(warning(`  ${result.errors} file(s) failed to upload.`));
+    }
+    const backedUpPaths = result.files.filter((f) => f.status === "ok").map((f) => f.filePath);
+    updateSyncConfig({ backedUpFiles: backedUpPaths });
+  } catch (err) {
+    console.log(chalk3.red(`  \u2717 Upload failed: ${err.message}`));
+    process.exit(1);
+  }
+}
+async function resolveFileId(apiKey, pathOrId) {
+  if (/^[0-9a-f]{8}-/.test(pathOrId)) return pathOrId;
+  const result = await listFiles(apiKey);
+  const match = result.files.find(
+    (f) => f.file_path === pathOrId || f.file_path.endsWith(pathOrId) || f.file_path.includes(pathOrId)
+  );
+  return match?.id || null;
+}
+function resolveLocalPath(input, cloudPath) {
+  if (fs8.existsSync(input)) return input;
+  const home2 = process.env.HOME || "";
+  if (cloudPath.startsWith("~/")) {
+    const expanded = cloudPath.replace("~", home2);
+    if (fs8.existsSync(expanded)) return expanded;
+  }
+  const cwdPath = `${process.cwd()}/${cloudPath}`;
+  if (fs8.existsSync(cwdPath)) return cwdPath;
+  return null;
+}
+async function resolveNpxPath() {
+  const { execSync: execSync2 } = await import("child_process");
+  try {
+    return execSync2("which npx", { encoding: "utf-8" }).trim();
+  } catch {
+    return "/usr/local/bin/npx";
+  }
+}
+function groupByCategory(files) {
+  const groups = {};
+  for (const file of files) {
+    if (!groups[file.category]) groups[file.category] = [];
+    groups[file.category].push(file);
+  }
+  const sorted = {};
+  if (groups["Global"]) {
+    sorted["Global"] = groups["Global"];
+    delete groups["Global"];
+  }
+  for (const key of Object.keys(groups).sort()) {
+    sorted[key] = groups[key];
+  }
+  return sorted;
+}
+
+// src/commands/sync-config.ts
+import chalk4 from "chalk";
+async function syncConfigCommand(options) {
+  banner();
+  if (options.autoDiscover !== void 0) {
+    const value = parseBool(options.autoDiscover);
+    if (value === null) {
+      console.log(chalk4.red("  \u2717 Invalid value. Use: on, off, true, false"));
+      process.exit(1);
+    }
+    updateSyncConfig({ autoDiscover: value });
+    console.log(success(`  \u2713 Auto-discover: ${value ? "ON" : "OFF"}`));
+    console.log();
+    return;
+  }
+  if (options.keepBrainUpdated !== void 0) {
+    const value = parseBool(options.keepBrainUpdated);
+    if (value === null) {
+      console.log(chalk4.red("  \u2717 Invalid value. Use: on, off, true, false"));
+      process.exit(1);
+    }
+    updateSyncConfig({ keepBrainUpdated: value });
+    console.log(success(`  \u2713 Keep brain updated: ${value ? "ON" : "OFF"}`));
+    console.log();
+    return;
+  }
+  if (options.useBrain !== void 0) {
+    const value = parseBool(options.useBrain);
+    if (value === null) {
+      console.log(chalk4.red("  \u2717 Invalid value. Use: on, off, true, false"));
+      process.exit(1);
+    }
+    updateSyncConfig({ useBrain: value });
+    console.log(success(`  \u2713 Use brain: ${value ? "ON" : "OFF"}`));
+    console.log();
+    return;
+  }
+  if (options.show || options.files) {
+    showConfig();
+    return;
+  }
+  showConfigMenu();
+}
+function showConfig() {
+  const config = readSyncConfig();
+  console.log(brand.bold("  Current Configuration"));
+  console.log();
+  console.log(`  Config file: ${dim(getConfigFile())}`);
+  console.log(`  Device ID:   ${dim(config.deviceId)}`);
+  console.log(`  Device name: ${dim(config.deviceName)}`);
+  console.log(`  API key:     ${config.apiKey ? success("configured") : dim("not set")}`);
+  console.log();
+  console.log(dim("  Features:"));
+  console.log(`    Auto-discover:      ${config.autoDiscover ? success("ON") : dim("OFF")}`);
+  console.log(`    Keep brain updated: ${config.keepBrainUpdated ? success("ON") : dim("OFF")}`);
+  console.log(`    Use brain:          ${config.useBrain ? success("ON") : dim("OFF")}`);
+  console.log();
+  if (config.backedUpFiles.length > 0) {
+    console.log(dim("  Backed-up files:"));
+    for (const f of config.backedUpFiles) {
+      console.log(`    ${f}`);
+    }
+  } else {
+    console.log(dim("  No files backed up yet."));
+  }
+  console.log();
+}
+function showConfigMenu() {
+  const config = readSyncConfig();
+  console.log(brand.bold("  Configuration Options"));
+  console.log(dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log();
+  console.log(`  1. ${chalk4.white("Change which files are backed up")}`);
+  console.log(`     Current: ${config.backedUpFiles.length} files selected`);
+  console.log(dim(`     Command: piut sync config --files`));
+  console.log();
+  console.log(`  2. ${chalk4.white("Auto-backup new files in same environments")}`);
+  console.log(`     Current: ${config.autoDiscover ? success("ON") : dim("OFF")}`);
+  console.log(dim(`     Command: piut sync config --auto-discover [on|off]`));
+  console.log();
+  console.log(`  3. ${chalk4.white("Use skill to keep brain up to date")}`);
+  console.log(`     Current: ${config.keepBrainUpdated ? success("ON") : dim("OFF")}`);
+  console.log(dim(`     Command: piut sync config --keep-brain-updated [on|off]`));
+  console.log();
+  console.log(`  4. ${chalk4.white("Reference centralized brain")}`);
+  console.log(`     Current: ${config.useBrain ? success("ON") : dim("OFF")}`);
+  console.log(dim(`     Command: piut sync config --use-brain [on|off]`));
+  console.log();
+  console.log(`  5. ${chalk4.white("View current configuration")}`);
+  console.log(dim(`     Command: piut sync config --show`));
+  console.log();
+}
+function parseBool(value) {
+  const lower = value.toLowerCase();
+  if (["on", "true", "1", "yes"].includes(lower)) return true;
+  if (["off", "false", "0", "no"].includes(lower)) return false;
+  return null;
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("piut").description("Configure your AI tools to use p\u0131ut personal context").version("1.0.2");
+program.name("piut").description("Automatic backup + hosting of all your agent configs across every machine. Version history. Restore any time. One command to set up.").version("1.1.0");
 program.command("setup", { isDefault: true }).description("Auto-detect and configure AI tools").option("-k, --key <key>", "API key (prompts interactively if not provided)").option("-t, --tool <id>", "Configure a single tool (claude-code, cursor, windsurf, etc.)").option("-y, --yes", "Skip interactive prompts (auto-select all detected tools)").option("--project", "Prefer project-local config files").option("--skip-skill", "Skip skill.md file placement").action(setupCommand);
 program.command("status").description("Show which AI tools are configured with p\u0131ut").action(statusCommand);
 program.command("remove").description("Remove p\u0131ut configuration from AI tools").action(removeCommand);
+var sync = program.command("sync").description("Back up and sync your agent config files to the cloud").option("--install", "Run the guided backup setup flow").option("--push", "Push local changes to cloud").option("--pull", "Pull latest versions from cloud").option("--watch", "Watch files for changes and auto-push (live sync)").option("--history <file>", "Show version history for a file").option("--diff <file>", "Show diff between local and cloud version").option("--restore <file>", "Restore a file from a previous version").option("--prefer-local", "Resolve conflicts by keeping local version").option("--prefer-cloud", "Resolve conflicts by keeping cloud version").option("--install-daemon", "Set up auto-sync via cron/launchd").option("-k, --key <key>", "API key").option("-y, --yes", "Skip interactive prompts").action(syncCommand);
+sync.command("config").description("Configure cloud backup settings").option("--files", "Change which files are backed up").option("--auto-discover <value>", "Auto-backup new files (on/off)").option("--keep-brain-updated <value>", "Keep brain updated from backups (on/off)").option("--use-brain <value>", "Reference centralized brain (on/off)").option("--show", "View current configuration").action(syncConfigCommand);
 program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@piut/cli",
-  "version": "1.0.2",
-  "description": "Configure your AI tools to use pıut personal context",
+  "version": "1.1.0",
+  "description": "Automatic backup + hosting of all your agent configs across every machine. Version history. Restore any time. One command to set up.",
   "type": "module",
   "bin": {
     "piut": "dist/cli.js"
@@ -25,7 +25,11 @@
     "claude",
     "cursor",
     "copilot",
-    "windsurf"
+    "windsurf",
+    "backup",
+    "sync",
+    "cloud",
+    "agent-config"
   ],
   "author": "M-Flat Inc",
   "license": "MIT",
@@ -37,6 +41,7 @@
   "dependencies": {
     "@inquirer/prompts": "^7.0.0",
     "chalk": "^5.4.0",
+    "chokidar": "^4.0.3",
     "commander": "^13.0.0"
   },
   "devDependencies": {