cc-hub-cli 1.0.10 → 1.1.1

package/README.md

@@ -2,6 +2,8 @@
 
 Manage Claude CLI profiles, hooks, and sessions — one tool, all in one place.
 
+> **Note:** macOS, Linux, and Windows supported.
+
 ## Install
 
 ```bash
@@ -98,9 +100,12 @@ cc-hub hook disable -i <index> [-i <index>]                   # Disable active h
 **Examples:**
 
 ```bash
-# Desktop notification when Claude finishes
+# Desktop notification when Claude finishes (macOS)
 cc-hub hook add -e Stop -c 'osascript -e "display notification \"Done\""'
 
+# Desktop notification when Claude finishes (Windows PowerShell)
+cc-hub hook add -e Stop -c 'powershell -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.MessageBox]::Show(\"Claude Done\")"'
+
 # Hook only for Bash tool usage
 cc-hub hook add -e PreToolUse -m Bash -c 'echo "Running bash..."'
 
@@ -147,6 +152,9 @@ eval "$(cc-hub complete zsh)"
 
 # bash — add to ~/.bashrc
 eval "$(cc-hub complete bash)"
+
+# PowerShell — add to $PROFILE
+Invoke-Expression (& cc-hub complete powershell | Out-String)
 ```
 
 Completes subcommands, profile names, and event types.

package/dist/index.js

@@ -4,31 +4,315 @@
 import { Command as Command6 } from "commander";
 import { createRequire } from "module";
 
-// src/profiles.ts
+// src/profiles/commands.ts
 import { Command as Command2 } from "commander";
-import { spawnSync, spawn } from "child_process";
 
 // src/config.ts
+import fs3 from "fs";
+import path3 from "path";
+import os2 from "os";
+
+// src/platform/desktop-app.ts
 import fs from "fs";
 import path from "path";
 import os from "os";
-var CLAUDE_DIR = process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude");
-var PROFILES_FILE = process.env.CLAUDE_PROFILES_FILE || path.join(CLAUDE_DIR, "profiles.json");
-var SETTINGS_FILE = process.env.CLAUDE_SETTINGS_FILE || path.join(CLAUDE_DIR, "settings.json");
-var CLAUDE_JSON = path.join(os.homedir(), ".claude.json");
-var PROJECTS_DIR = path.join(CLAUDE_DIR, "projects");
-var SESSIONS_DIR = path.join(CLAUDE_DIR, "sessions");
+function sortSemverDesc(a, b) {
+  const parse = (v) => v.split(".").map((n) => parseInt(n, 10));
+  const av = parse(a);
+  const bv = parse(b);
+  for (let i = 0; i < Math.max(av.length, bv.length); i++) {
+    const an = av[i] || 0;
+    const bn = bv[i] || 0;
+    if (an !== bn) return bn - an;
+  }
+  return 0;
+}
+var MacOSDesktopApp = class {
+  supportDir = path.join(os.homedir(), "Library/Application Support/Claude-3p");
+  isInstalled() {
+    return fs.existsSync(this.supportDir);
+  }
+  getSupportDir() {
+    return this.isInstalled() ? this.supportDir : void 0;
+  }
+  getSessionsDir() {
+    return this.isInstalled() ? path.join(this.supportDir, "local-agent-mode-sessions") : void 0;
+  }
+  getConfigLibrary() {
+    return this.isInstalled() ? path.join(this.supportDir, "configLibrary") : void 0;
+  }
+  findBinary() {
+    const claudeCodeDir = path.join(this.supportDir, "claude-code");
+    if (!fs.existsSync(claudeCodeDir)) return void 0;
+    let versions;
+    try {
+      versions = fs.readdirSync(claudeCodeDir).filter(
+        (d) => fs.existsSync(path.join(claudeCodeDir, d, "claude.app", "Contents", "MacOS", "claude"))
+      );
+    } catch {
+      return void 0;
+    }
+    if (versions.length === 0) return void 0;
+    versions.sort(sortSemverDesc);
+    return path.join(claudeCodeDir, versions[0], "claude.app", "Contents", "MacOS", "claude");
+  }
+};
+var WindowsDesktopApp = class {
+  candidates = [
+    path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "Claude"),
+    path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "Claude-3p"),
+    path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "Claude"),
+    path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "Claude-3p"),
+    path.join(
+      process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"),
+      "Packages",
+      "Claude_pzs8sxrjxfjjc",
+      "LocalCache",
+      "Roaming",
+      "Claude"
+    )
+  ];
+  _findSupportDir() {
+    for (const dir of this.candidates) {
+      if (fs.existsSync(dir)) return dir;
+    }
+    return void 0;
+  }
+  isInstalled() {
+    return this._findSupportDir() !== void 0;
+  }
+  getSupportDir() {
+    return this._findSupportDir();
+  }
+  getSessionsDir() {
+    const dir = this._findSupportDir();
+    return dir ? path.join(dir, "local-agent-mode-sessions") : void 0;
+  }
+  getConfigLibrary() {
+    const dir = this._findSupportDir();
+    return dir ? path.join(dir, "configLibrary") : void 0;
+  }
+  findBinary() {
+    const win32Binary = path.join(process.env.LOCALAPPDATA || "", "Programs", "Claude", "Claude.exe");
+    if (fs.existsSync(win32Binary)) return win32Binary;
+    return void 0;
+  }
+};
+var NoOpDesktopApp = class {
+  isInstalled() {
+    return false;
+  }
+  getSupportDir() {
+    return void 0;
+  }
+  getSessionsDir() {
+    return void 0;
+  }
+  getConfigLibrary() {
+    return void 0;
+  }
+  findBinary() {
+    return void 0;
+  }
+};
+
+// src/platform/profile-syncer.ts
+import fs2 from "fs";
+import path2 from "path";
+import { randomUUID } from "crypto";
+function toDesktopProfile(p) {
+  const models = p.models || (p.model ? [p.model] : []);
+  const isAnthropic = p.provider === "anthropic" || !p.provider && !p.url;
+  if (isAnthropic && !p.url) {
+    return {
+      inferenceProvider: "1p",
+      inferenceModels: models.map((m) => ({ name: m, supports1m: true }))
+    };
+  }
+  return {
+    inferenceProvider: "gateway",
+    inferenceGatewayBaseUrl: p.url || void 0,
+    inferenceGatewayApiKey: p.token || void 0,
+    inferenceGatewayAuthScheme: "bearer",
+    inferenceModels: models.map((m) => ({ name: m, supports1m: true }))
+  };
+}
+var DesktopProfileSyncer = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  isSupported() {
+    return this.app.isInstalled();
+  }
+  sync(name, p) {
+    const configLib = this.app.getConfigLibrary();
+    if (!configLib) return;
+    if (!fs2.existsSync(configLib)) {
+      fs2.mkdirSync(configLib, { recursive: true });
+    }
+    const meta = this.readMeta();
+    const entries = meta.entries || [];
+    let id = p.desktopId;
+    if (!id) {
+      const existingByName = entries.find((e) => e.name === name);
+      if (existingByName) {
+        id = existingByName.id;
+      } else {
+        id = randomUUID();
+      }
+      p.desktopId = id;
+    }
+    const existingIndex = entries.findIndex((e) => e.id === id);
+    if (existingIndex !== -1) {
+      entries[existingIndex].name = name;
+    } else {
+      entries.push({ id, name });
+    }
+    meta.entries = entries;
+    this.writeMeta(meta);
+    this.writeProfile(id, configLib, toDesktopProfile(p));
+  }
+  remove(name, p) {
+    const configLib = this.app.getConfigLibrary();
+    if (!configLib || !p.desktopId) return;
+    const meta = this.readMeta();
+    if (meta.entries) {
+      meta.entries = meta.entries.filter((e) => e.id !== p.desktopId);
+    }
+    if (meta.appliedId === p.desktopId) {
+      delete meta.appliedId;
+    }
+    this.writeMeta(meta);
+    const filePath = path2.join(configLib, `${p.desktopId}.json`);
+    if (fs2.existsSync(filePath)) {
+      fs2.unlinkSync(filePath);
+    }
+  }
+  setActive(p) {
+    const configLib = this.app.getConfigLibrary();
+    if (!configLib || !p.desktopId) return;
+    const meta = this.readMeta();
+    meta.appliedId = p.desktopId;
+    const entries = meta.entries || [];
+    if (!entries.some((e) => e.id === p.desktopId)) {
+      entries.push({ id: p.desktopId, name: "unknown" });
+      meta.entries = entries;
+    }
+    this.writeMeta(meta);
+  }
+  metaFile() {
+    const configLib = this.app.getConfigLibrary();
+    return configLib ? path2.join(configLib, "_meta.json") : void 0;
+  }
+  readMeta() {
+    const file = this.metaFile();
+    if (!file || !fs2.existsSync(file)) return {};
+    try {
+      return readJson(file);
+    } catch {
+      return {};
+    }
+  }
+  writeMeta(meta) {
+    const file = this.metaFile();
+    if (file) writeJson(file, meta);
+  }
+  writeProfile(id, configLib, data) {
+    writeJson(path2.join(configLib, `${id}.json`), data);
+  }
+};
+
+// src/platform/binary-resolver.ts
+import { spawnSync } from "child_process";
+var SystemBinaryResolver = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  resolve() {
+    try {
+      const result = spawnSync("claude", ["--version"], {
+        shell: process.platform === "win32",
+        encoding: "utf-8"
+      });
+      if (result.status === 0) {
+        return "claude";
+      }
+    } catch {
+    }
+    const desktopBinary = this.app.findBinary();
+    if (desktopBinary) return desktopBinary;
+    console.error("Error: Could not find Claude Code CLI.");
+    console.error("Install it globally or install the Claude Code desktop app.");
+    process.exit(1);
+  }
+};
+
+// src/platform/path-codec.ts
+var UnixPathCodec = class {
+  encode(p) {
+    return p.replace(/[\\/]/g, "-").replace(/\./g, "-").replace(/:/g, "");
+  }
+  decode(encoded) {
+    return encoded.replace(/--/g, "/.").replace(/-/g, "/");
+  }
+};
+var WindowsPathCodec = class {
+  encode(p) {
+    return p.replace(/[\\/]/g, "-").replace(/\./g, "-").replace(/:/g, "");
+  }
+  decode(encoded) {
+    const decoded = encoded.replace(/--/g, "\\.").replace(/-/g, "\\");
+    if (/^[A-Za-z]\\/.test(decoded)) {
+      return decoded[0] + ":" + decoded.slice(1);
+    }
+    return decoded;
+  }
+};
+
+// src/platform/index.ts
+function createDesktopApp() {
+  if (process.platform === "darwin") return new MacOSDesktopApp();
+  if (process.platform === "win32") return new WindowsDesktopApp();
+  return new NoOpDesktopApp();
+}
+function createProfileSyncer() {
+  return new DesktopProfileSyncer(createDesktopApp());
+}
+function createBinaryResolver() {
+  return new SystemBinaryResolver(createDesktopApp());
+}
+function createPathCodec() {
+  if (process.platform === "win32") return new WindowsPathCodec();
+  return new UnixPathCodec();
+}
+
+// src/config.ts
+var CLAUDE_DIR = process.env.CLAUDE_DIR || path3.join(os2.homedir(), ".claude");
+var PROFILES_FILE = process.env.CLAUDE_PROFILES_FILE || path3.join(CLAUDE_DIR, "profiles.json");
+var SETTINGS_FILE = process.env.CLAUDE_SETTINGS_FILE || path3.join(CLAUDE_DIR, "settings.json");
+var CLAUDE_JSON = path3.join(os2.homedir(), ".claude.json");
+var PROJECTS_DIR = path3.join(CLAUDE_DIR, "projects");
+var SESSIONS_DIR = path3.join(CLAUDE_DIR, "sessions");
+var desktopApp = createDesktopApp();
+var DESKTOP_CONFIG_LIBRARY = desktopApp.getConfigLibrary() || "";
+var DESKTOP_META_FILE = DESKTOP_CONFIG_LIBRARY ? path3.join(DESKTOP_CONFIG_LIBRARY, "_meta.json") : "";
+var DESKTOP_SESSIONS_DIR = desktopApp.getSessionsDir() || "";
+function isDesktopAppInstalled() {
+  return desktopApp.isInstalled();
+}
 function ensureFile(filePath, defaultContent) {
-  if (!fs.existsSync(filePath)) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, defaultContent, "utf-8");
+  if (!fs3.existsSync(filePath)) {
+    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs3.writeFileSync(filePath, defaultContent, "utf-8");
   }
 }
 function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
 }
 function writeJson(filePath, data) {
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function ensureProfilesFile() {
   ensureFile(PROFILES_FILE, '{"profiles":{}}\n');
@@ -37,12 +321,12 @@ function ensureSettingsFile() {
   ensureFile(SETTINGS_FILE, "{}\n");
 }
 function fixJsonFile(filePath, fallback = {}) {
-  if (!fs.existsSync(filePath)) return;
-  const backupPath = path.join(CLAUDE_DIR, path.basename(filePath) + ".backup");
-  const raw = fs.readFileSync(filePath, "utf-8");
+  if (!fs3.existsSync(filePath)) return;
+  const backupPath = path3.join(CLAUDE_DIR, path3.basename(filePath) + ".backup");
+  const raw = fs3.readFileSync(filePath, "utf-8");
   try {
     JSON.parse(raw);
-    fs.copyFileSync(filePath, backupPath);
+    fs3.copyFileSync(filePath, backupPath);
     return;
   } catch {
   }
@@ -67,22 +351,26 @@ function fixJsonFile(filePath, fallback = {}) {
   if (openCurly > 0) text += "}".repeat(openCurly);
   try {
     JSON.parse(text);
-    fs.writeFileSync(filePath, text + "\n", "utf-8");
-    console.error(`Fixed invalid JSON in ${path.basename(filePath)}.`);
+    fs3.writeFileSync(filePath, text + "\n", "utf-8");
+    console.error(`Fixed invalid JSON in ${path3.basename(filePath)}.`);
   } catch {
-    if (fs.existsSync(backupPath)) {
-      fs.copyFileSync(backupPath, filePath);
-      console.error(`Restored ${path.basename(filePath)} from backup.`);
+    if (fs3.existsSync(backupPath)) {
+      fs3.copyFileSync(backupPath, filePath);
+      console.error(`Restored ${path3.basename(filePath)} from backup.`);
     } else {
       writeJson(filePath, fallback);
-      console.error(`Could not fix ${path.basename(filePath)}, no backup found, reset to default.`);
+      console.error(`Could not fix ${path3.basename(filePath)}, no backup found, reset to default.`);
     }
   }
 }
 
-// src/provider.ts
-import http from "http";
+// src/profiles/runner.ts
+import { spawnSync as spawnSync2, spawn } from "child_process";
+
+// src/provider/index.ts
 import { Command } from "commander";
+
+// src/provider/transform.ts
 function sanitizeToolId(id) {
   let sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
   if (!/^[a-zA-Z]/.test(sanitized)) {
@@ -293,6 +581,9 @@ data: ${JSON.stringify(data)}
   });
   yield sse("message_stop", { type: "message_stop" });
 }
+
+// src/provider/server.ts
+import http from "http";
 async function startOpenAIProxy(targetUrl, apiKey, model, models = []) {
   const base = targetUrl.replace(/\/+$/, "");
   const server = http.createServer(async (req, res) => {
@@ -404,6 +695,8 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
+
+// src/provider/index.ts
 var PROVIDERS = [
   {
     name: "anthropic",
@@ -427,7 +720,100 @@ function providerCommand() {
   return cmd;
 }
 
-// src/profiles.ts
+// src/profiles/runner.ts
+function resolveClaudeBinary() {
+  return createBinaryResolver().resolve();
+}
+function updateSettingsForProfile(p) {
+  ensureSettingsFile();
+  const settings = readJson(SETTINGS_FILE);
+  const models = p.models || (p.model ? [p.model] : []);
+  delete settings.model;
+  delete settings.availableModels;
+  const envVarsToClean = [
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION",
+    "ANTHROPIC_CUSTOM_MODEL_OPTION"
+  ];
+  if (settings.env) {
+    const env = settings.env;
+    for (const key of envVarsToClean) {
+      delete env[key];
+    }
+  }
+  writeJson(SETTINGS_FILE, settings);
+}
+function execClaude(profileName, p, extraArgs) {
+  updateSettingsForProfile(p);
+  const models = p.models || (p.model ? [p.model] : []);
+  const firstModel = models[0];
+  const binary = resolveClaudeBinary();
+  const cmd = [binary];
+  if (firstModel) cmd.push("--model", firstModel);
+  cmd.push(...extraArgs);
+  const env = {
+    ...process.env,
+    ANTHROPIC_AUTH_TOKEN: p.token || void 0,
+    ANTHROPIC_BASE_URL: p.url || void 0,
+    CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
+    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1"
+  };
+  if (models.length > 0) {
+    if (models[0]) {
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL = models[0];
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME = models[0];
+      env.ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION = `Custom: ${models[0]}`;
+    }
+    if (models[1]) {
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL = models[1];
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL_NAME = models[1];
+      env.ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION = `Custom: ${models[1]}`;
+    }
+    if (models[2]) {
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL = models[2];
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME = models[2];
+      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION = `Custom: ${models[2]}`;
+    }
+    env.ANTHROPIC_CUSTOM_MODEL_OPTION = models[0];
+  }
+  delete env.ANTHROPIC_API_KEY;
+  console.error(`Using profile '${profileName}': model=${firstModel || "(default)"} url=${p.url || "(default)"} provider=${p.provider || "anthropic"}`);
+  if (p.provider === "openai") {
+    const allModels = p.models || (p.model ? [p.model] : []);
+    startOpenAIProxy(
+      p.url || "https://api.openai.com",
+      p.token || "",
+      firstModel || "gpt-4o",
+      allModels
+    ).then(({ baseUrl, stop }) => {
+      env.ANTHROPIC_BASE_URL = baseUrl;
+      const child = spawn(cmd[0], cmd.slice(1), { stdio: "inherit", env, shell: process.platform === "win32" });
+      child.on("close", (code) => {
+        stop();
+        process.exit(code ?? 1);
+      });
+    }).catch((err) => {
+      console.error("Failed to start OpenAI proxy:", err);
+      process.exit(1);
+    });
+  } else {
+    const result = spawnSync2(cmd[0], cmd.slice(1), {
+      stdio: "inherit",
+      env,
+      shell: process.platform === "win32"
+    });
+    process.exit(result.status ?? 1);
+  }
+}
+
+// src/profiles/commands.ts
 function maskToken(token) {
   if (!token) return "(unset)";
   if (token.length <= 12) return token;
@@ -463,47 +849,21 @@ function isAnthropicModel(model) {
   if (lower.startsWith("claude-")) return true;
   return false;
 }
-function updateSettingsForProfile(p) {
-  ensureSettingsFile();
-  const settings = readJson(SETTINGS_FILE);
-  const models = p.models || (p.model ? [p.model] : []);
-  if (models.length > 0) {
-    const aliases = [];
-    if (models[0]) aliases.push("sonnet");
-    if (models[1]) aliases.push("opus");
-    if (models[2]) aliases.push("haiku");
-    settings.model = aliases[0];
-    settings.availableModels = aliases;
-  } else {
-    delete settings.model;
-    delete settings.availableModels;
-  }
-  const envVarsToClean = [
-    "ANTHROPIC_DEFAULT_OPUS_MODEL",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION",
-    "ANTHROPIC_CUSTOM_MODEL_OPTION"
-  ];
-  if (settings.env) {
-    for (const key of envVarsToClean) {
-      delete settings.env[key];
-    }
-  }
-  writeJson(SETTINGS_FILE, settings);
+function collect(value, previous) {
+  return previous.concat([value]);
 }
 function profileCommand() {
   const profile = new Command2("profile").description("Manage Claude CLI profiles");
-  profile.command("add").description("Add or update a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID (e.g. claude-opus-4-6) - can be used multiple times", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL (e.g. https://api.anthropic.com)").option("-p, --provider <provider>", "Provider type: anthropic (default) or openai").action((name, opts) => {
+  const syncer = createProfileSyncer();
+  profile.command("add").description("Add or update a profile").argument("<name>", "Profile name").option("-m, --model <model>", "Model ID - can be used multiple times (max 3)", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").option("-p, --provider <provider>", "Provider type: anthropic (default) or openai").action((name, opts) => {
+    const models = opts.model && opts.model.length > 0 ? opts.model : void 0;
+    if (models && models.length > 3) {
+      console.error("Error: A profile can have at most 3 models.");
+      process.exit(1);
+    }
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     const profile2 = data.profiles[name] || {};
-    const models = opts.model && opts.model.length > 0 ? opts.model : void 0;
     if (models) {
       profile2.models = models;
       profile2.model = models[0];
@@ -512,10 +872,11 @@ function profileCommand() {
     if (opts.url) profile2.url = opts.url;
     if (opts.provider) profile2.provider = opts.provider;
     data.profiles[name] = profile2;
+    syncer.sync(name, profile2);
     writeJson(PROFILES_FILE, data);
     console.log(`Profile '${name}' saved.`);
   });
-  profile.command("update").description("Update fields of an existing profile").argument("<name>", "Profile name (must already exist)").option("-m, --model <model>", "Model ID - can be used multiple times to set multiple models", collect, []).option("-d, --delete-model <model>", "Remove model ID - can be used multiple times", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").option("-p, --provider <provider>", "Provider type: anthropic (default) or openai").action((name, opts) => {
+  profile.command("update").description("Update fields of an existing profile").argument("<name>", "Profile name (must already exist)").option("-m, --model <model>", "Model ID - can be used multiple times", collect, []).option("-d, --delete-model <model>", "Remove model ID - can be used multiple times", collect, []).option("-t, --token <token>", "API key / token").option("-u, --url <url>", "Base URL").option("-p, --provider <provider>", "Provider type").action((name, opts) => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
     if (!data.profiles[name]) {
@@ -564,9 +925,15 @@ function profileCommand() {
         p.model = providedModels[0];
       }
     }
+    const finalModels = p.models || (p.model ? [p.model] : []);
+    if (finalModels.length > 3) {
+      console.error("Error: A profile can have at most 3 models.");
+      process.exit(1);
+    }
     if (opts.token) p.token = opts.token;
     if (opts.url) p.url = opts.url;
     if (opts.provider) p.provider = opts.provider;
+    syncer.sync(name, p);
     writeJson(PROFILES_FILE, data);
     console.log(`Profile '${name}' updated.`);
   });
@@ -586,9 +953,11 @@ function profileCommand() {
     for (const name of names) {
       const p = profiles[name];
       const marker = name === def ? "* " : "  ";
+      const desktopMarker = p.desktopId ? " [desktop]" : "";
+      const displayName = (name + desktopMarker).padEnd(20);
       console.log(fmt(
         marker,
-        name,
+        displayName,
         formatModels(p),
         maskToken(p.token || ""),
         p.provider || "anthropic",
@@ -605,7 +974,8 @@ function profileCommand() {
       process.exit(1);
     }
     if (opts.json) {
-      console.log(JSON.stringify({ name, ...p }, null, 2));
+      const { desktopId, ...rest } = p;
+      console.log(JSON.stringify({ name, ...rest }, null, 2));
     } else {
       console.log(`Name:     ${name}`);
       console.log(`Model:    ${p.model || "(unset)"}`);
@@ -637,6 +1007,7 @@ function profileCommand() {
       console.error(`Profile '${name}' not found.`);
       process.exit(1);
     }
+    syncer.remove(name, data.profiles[name]);
     delete data.profiles[name];
     writeJson(PROFILES_FILE, data);
     console.log(`Profile '${name}' removed.`);
@@ -668,75 +1039,33 @@ function profileCommand() {
       process.exit(1);
     }
     data.default = name;
+    syncer.setActive(data.profiles[name]);
     writeJson(PROFILES_FILE, data);
     console.log(`Default profile set to '${name}'.`);
   });
-  return profile;
-}
-function collect(value, previous) {
-  return previous.concat([value]);
-}
-function execClaude(profileName, p, extraArgs) {
-  updateSettingsForProfile(p);
-  const models = p.models || (p.model ? [p.model] : []);
-  const firstModel = models[0];
-  const cmd = ["claude"];
-  if (firstModel) cmd.push("--model", firstModel);
-  cmd.push(...extraArgs);
-  const env = {
-    ...process.env,
-    ANTHROPIC_AUTH_TOKEN: p.token || void 0,
-    ANTHROPIC_BASE_URL: p.url || void 0,
-    CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
-    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1"
-  };
-  if (models.length > 0) {
-    if (models[0]) {
-      env.ANTHROPIC_DEFAULT_SONNET_MODEL = models[0];
-      env.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME = models[0];
-      env.ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION = `Custom: ${models[0]}`;
+  profile.command("sync").description("Synchronize all CLI profiles to the Claude desktop app").action(() => {
+    if (!syncer.isSupported()) {
+      console.error("Claude desktop app is not installed.");
+      process.exit(1);
     }
-    if (models[1]) {
-      env.ANTHROPIC_DEFAULT_OPUS_MODEL = models[1];
-      env.ANTHROPIC_DEFAULT_OPUS_MODEL_NAME = models[1];
-      env.ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION = `Custom: ${models[1]}`;
+    ensureProfilesFile();
+    const data = readJson(PROFILES_FILE);
+    const names = Object.keys(data.profiles);
+    if (names.length === 0) {
+      console.log("No profiles to sync.");
+      return;
     }
-    if (models[2]) {
-      env.ANTHROPIC_DEFAULT_HAIKU_MODEL = models[2];
-      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME = models[2];
-      env.ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION = `Custom: ${models[2]}`;
+    for (const name of names) {
+      const p = data.profiles[name];
+      syncer.sync(name, p);
     }
-    env.ANTHROPIC_CUSTOM_MODEL_OPTION = models[0];
-  }
-  delete env.ANTHROPIC_API_KEY;
-  console.error(`Using profile '${profileName}': model=${firstModel || "(default)"} url=${p.url || "(default)"} provider=${p.provider || "anthropic"}`);
-  if (p.provider === "openai") {
-    const allModels = p.models || (p.model ? [p.model] : []);
-    startOpenAIProxy(
-      p.url || "https://api.openai.com",
-      p.token || "",
-      firstModel || "gpt-4o",
-      allModels
-    ).then(({ baseUrl, stop }) => {
-      env.ANTHROPIC_BASE_URL = baseUrl;
-      const child = spawn(cmd[0], cmd.slice(1), { stdio: "inherit", env });
-      child.on("close", (code) => {
-        stop();
-        process.exit(code ?? 1);
-      });
-    }).catch((err) => {
-      console.error("Failed to start OpenAI proxy:", err);
-      process.exit(1);
-    });
-  } else {
-    const result = spawnSync(cmd[0], cmd.slice(1), {
-      stdio: "inherit",
-      env
-    });
-    process.exit(result.status ?? 1);
-  }
+    writeJson(PROFILES_FILE, data);
+    console.log(`Synced ${names.length} profile(s) to the desktop app.`);
+  });
+  return profile;
 }
 function useCommand() {
+  const syncer = createProfileSyncer();
   return new Command2("use").description("Set a profile as the default").argument("<name>", "Profile name").action((name) => {
     ensureProfilesFile();
     const data = readJson(PROFILES_FILE);
@@ -745,6 +1074,7 @@ function useCommand() {
       process.exit(1);
     }
     data.default = name;
+    syncer.setActive(data.profiles[name]);
     writeJson(PROFILES_FILE, data);
     console.log(`Default profile set to '${name}'.`);
   });
@@ -772,7 +1102,7 @@ function runCommand() {
   });
 }
 
-// src/hooks.ts
+// src/hooks/commands.ts
 import { Command as Command3 } from "commander";
 function buildFlat(data) {
   const rows = [];
@@ -812,26 +1142,29 @@ function buildFlat(data) {
   rows.sort((a, b) => a.seq - b.seq);
   return rows;
 }
+function displayHookList(data) {
+  const rows = buildFlat(data);
+  if (rows.length === 0) {
+    console.log("No hooks defined.");
+    return;
+  }
+  const fmt = (idx, active, event, matcher, cmd) => `${String(idx).padEnd(4)}  ${active.padEnd(2)}  ${event.padEnd(22)}  ${matcher.padEnd(25)}  ${cmd}`;
+  console.log(fmt(0, "", "EVENT", "MATCHER", "COMMAND").replace(/^IDX/, "IDX").replace(/^0/, "IDX"));
+  console.log(fmt(0, "", "-----", "-------", "-------").replace(/^0/, "---"));
+  for (let idx = 0; idx < rows.length; idx++) {
+    const r = rows[idx];
+    const marker = r.active ? " " : "\u2717";
+    const matcher = r.matcher || "(any)";
+    const cmd = r.command.length > 60 ? r.command.slice(0, 60) + "\u2026" : r.command;
+    console.log(fmt(idx, marker, r.event, matcher, cmd));
+  }
+}
 function hooksCommand() {
   const hooks = new Command3("hook").description("Manage Claude Code hooks in settings.json");
   hooks.command("list").description("List all hooks").action(() => {
     ensureSettingsFile();
     const data = readJson(SETTINGS_FILE);
-    const rows = buildFlat(data);
-    if (rows.length === 0) {
-      console.log("No hooks defined.");
-      return;
-    }
-    const fmt = (idx, active, event, matcher, cmd) => `${String(idx).padEnd(4)}  ${active.padEnd(2)}  ${event.padEnd(22)}  ${matcher.padEnd(25)}  ${cmd}`;
-    console.log(fmt(0, "", "EVENT", "MATCHER", "COMMAND").replace(/^IDX/, "IDX").replace(/^0/, "IDX"));
-    console.log(fmt(0, "", "-----", "-------", "-------").replace(/^0/, "---"));
-    for (let idx = 0; idx < rows.length; idx++) {
-      const r = rows[idx];
-      const marker = r.active ? " " : "\u2717";
-      const matcher = r.matcher || "(any)";
-      const cmd = r.command.length > 60 ? r.command.slice(0, 60) + "\u2026" : r.command;
-      console.log(fmt(idx, marker, r.event, matcher, cmd));
-    }
+    displayHookList(data);
   });
   hooks.command("add").description("Add a hook to settings.json").requiredOption("-e, --event <event>", "Hook event (PreToolUse|PostToolUse|Notification|Stop|UserPromptSubmit|PermissionRequest)").option("-m, --matcher <matcher>", "Tool name matcher (omit for catch-all)").requiredOption("-c, --command <command>", "Shell command to run").option("-a, --async", "Run the hook asynchronously").action((opts) => {
     ensureSettingsFile();
@@ -924,6 +1257,8 @@ function hooksCommand() {
     data._cc_hub_disabled = remaining;
     if (remaining.length === 0) delete data._cc_hub_disabled;
     writeJson(SETTINGS_FILE, data);
+    console.log("");
+    displayHookList(data);
   });
   hooks.command("disable").description("Disable one or more hooks (removes from active)").requiredOption("-i, --index <indexes...>", "Global index from 'hooks list' (repeatable)", (v, prev) => {
     prev = prev || [];
@@ -960,21 +1295,52 @@ function hooksCommand() {
       console.log(`Hook ${t} (${r.event}) disabled.`);
     }
     writeJson(SETTINGS_FILE, data);
+    console.log("");
+    displayHookList(data);
   });
   return hooks;
 }
 
-// src/sessions.ts
-import { Command as Command4 } from "commander";
-import fs2 from "fs";
-import path2 from "path";
-import { execSync } from "child_process";
+// src/sessions/codec.ts
 function encodePath(p) {
-  return p.replace(/\./g, "DOTMARK").replace(/\//g, "-").replace(/DOTMARK/g, "-");
+  return createPathCodec().encode(p);
 }
 function decodePath(encoded) {
-  return encoded.replace(/--/g, "/.").replace(/-/g, "/");
+  return createPathCodec().decode(encoded);
 }
+
+// src/sessions/stats.ts
+import fs4 from "fs";
+import path4 from "path";
+function getDirSize(dir) {
+  let total = 0;
+  try {
+    for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path4.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += getDirSize(fullPath);
+      } else {
+        total += fs4.statSync(fullPath).size;
+      }
+    }
+  } catch {
+  }
+  return total;
+}
+function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${Math.round(size * 10) / 10}${units[unitIndex]}`;
+}
+
+// src/sessions/utils.ts
+import fs5 from "fs";
+import path5 from "path";
 function formatTimestamp(ms) {
   const d = new Date(ms);
   const pad = (n) => String(n).padStart(2, "0");
@@ -982,9 +1348,9 @@ function formatTimestamp(ms) {
 }
 function findProjectDir(query) {
   const encoded = encodePath(query);
-  if (fs2.existsSync(path2.join(PROJECTS_DIR, encoded))) return encoded;
+  if (fs5.existsSync(path5.join(PROJECTS_DIR, encoded))) return encoded;
   try {
-    const dirs = fs2.readdirSync(PROJECTS_DIR);
+    const dirs = fs5.readdirSync(PROJECTS_DIR);
     const match = dirs.find((d) => d.toLowerCase().includes(query.toLowerCase()));
     return match || null;
   } catch {
@@ -996,7 +1362,7 @@ function parseSessionMeta(filePath) {
   let slug = "";
   let customTitle = "";
   try {
-    const lines = fs2.readFileSync(filePath, "utf-8").split("\n");
+    const lines = fs5.readFileSync(filePath, "utf-8").split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
@@ -1048,32 +1414,39 @@ function snippet(text, query, width = 150) {
   const suffix = end < text.length ? "..." : "";
   return prefix + text.slice(start, end) + suffix;
 }
+
+// src/sessions/commands.ts
+import { Command as Command4 } from "commander";
+import fs6 from "fs";
+import path6 from "path";
 function sessionCommand() {
   const session = new Command4("session").description("Manage Claude Code sessions");
+  const desktopApp2 = createDesktopApp();
+  const DESKTOP_SESSIONS_DIR2 = desktopApp2.getSessionsDir() || "";
   session.command("list").description("List all Claude Code project sessions").option("-n, --limit <n>", "Max number of projects to show", "30").option("-s, --short", "Show encoded names only (no decoding)").option("-j, --json", "Output as JSON lines").action((opts) => {
     const limit = parseInt(opts.limit, 10);
     let dirs;
     try {
-      dirs = fs2.readdirSync(PROJECTS_DIR);
+      dirs = fs6.readdirSync(PROJECTS_DIR);
     } catch {
       console.log("No projects directory found.");
       return;
     }
     dirs.sort((a, b) => {
-      const statA = fs2.statSync(path2.join(PROJECTS_DIR, a));
-      const statB = fs2.statSync(path2.join(PROJECTS_DIR, b));
+      const statA = fs6.statSync(path6.join(PROJECTS_DIR, a));
+      const statB = fs6.statSync(path6.join(PROJECTS_DIR, b));
       return statB.mtimeMs - statA.mtimeMs;
     });
     let count = 0;
     for (const projDir of dirs) {
       if (count >= limit) break;
-      const fullPath = path2.join(PROJECTS_DIR, projDir);
+      const fullPath = path6.join(PROJECTS_DIR, projDir);
       let nSessions = 0;
       try {
-        nSessions = fs2.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl")).length;
+        nSessions = fs6.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl")).length;
       } catch {
       }
-      const stat = fs2.statSync(fullPath);
+      const stat = fs6.statSync(fullPath);
       const decoded = decodePath(projDir);
       if (opts.json) {
         console.log(JSON.stringify({ project: decoded, sessions: nSessions, modified: Math.floor(stat.mtimeMs) }));
@@ -1091,7 +1464,7 @@ function sessionCommand() {
       console.error(`No project matched: ${project}`);
       process.exit(1);
     }
-    const fullPath = path2.join(PROJECTS_DIR, projDir);
+    const fullPath = path6.join(PROJECTS_DIR, projDir);
     console.log(`Project: ${decodePath(projDir)}`);
     console.log(`Dir:     ${fullPath}`);
     console.log("");
@@ -1100,16 +1473,16 @@ function sessionCommand() {
     console.log(fmt("----------", "----", "-------", "--------"));
     let files;
     try {
-      files = fs2.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl"));
+      files = fs6.readdirSync(fullPath).filter((f) => f.endsWith(".jsonl"));
     } catch {
       return;
     }
     for (const file of files) {
-      const filePath = path2.join(fullPath, file);
+      const filePath = path6.join(fullPath, file);
       const sessionId = file.replace(/\.jsonl$/, "");
       let msgCount = 0;
       try {
-        const content = fs2.readFileSync(filePath, "utf-8");
+        const content = fs6.readFileSync(filePath, "utf-8");
         msgCount = content ? content.split("\n").filter((l) => l.trim()).length : 0;
       } catch {
       }
@@ -1117,7 +1490,7 @@ function sessionCommand() {
       console.log(fmt(sessionId, slug || "-", started, String(msgCount)));
       if (opts.verbose) {
         try {
-          const lines = fs2.readFileSync(filePath, "utf-8").split("\n");
+          const lines = fs6.readFileSync(filePath, "utf-8").split("\n");
           for (const line of lines) {
             if (!line.trim()) continue;
             try {
@@ -1145,33 +1518,36 @@ function sessionCommand() {
     }
   });
   session.command("search").description("Search conversation history across all projects").argument("<query>", "Text to search for").option("-p, --project <project>", "Filter to a specific project (partial match)").option("-n, --limit <n>", "Max number of matching files to show", "20").option("-i, --ignore-case", "Case-insensitive search").action((query, opts) => {
-    let searchRoot = PROJECTS_DIR;
+    let searchRoots = [{ root: PROJECTS_DIR, label: "" }];
+    if (isDesktopAppInstalled()) {
+      searchRoots.push({ root: DESKTOP_SESSIONS_DIR2, label: "[desktop] " });
+    }
     if (opts.project) {
       const projDir = findProjectDir(opts.project);
       if (!projDir) {
         console.error(`No project matched: ${opts.project}`);
         process.exit(1);
       }
-      searchRoot = path2.join(PROJECTS_DIR, projDir);
+      searchRoots = [{ root: path6.join(PROJECTS_DIR, projDir), label: "" }];
     }
     const limit = parseInt(opts.limit, 10);
     let count = 0;
-    function searchDir(dir) {
+    function searchDir(dir, label, baseDir) {
       if (count >= limit) return;
       let entries;
       try {
-        entries = fs2.readdirSync(dir, { withFileTypes: true });
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
         if (count >= limit) break;
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
-          searchDir(fullPath);
+          searchDir(fullPath, label, baseDir);
         } else if (entry.name.endsWith(".jsonl")) {
           try {
-            const content = fs2.readFileSync(fullPath, "utf-8");
+            const content = fs6.readFileSync(fullPath, "utf-8");
             const lines = content.split("\n");
             let found = false;
             for (let lineno = 0; lineno < lines.length; lineno++) {
@@ -1180,10 +1556,11 @@ function sessionCommand() {
               const match = opts.ignoreCase ? line.toLowerCase().includes(query.toLowerCase()) : line.includes(query);
               if (match) {
                 if (!found) {
-                  const relPath = path2.relative(PROJECTS_DIR, fullPath);
-                  const projEnc = relPath.split("/")[0];
-                  const sessionId = path2.basename(fullPath, ".jsonl");
-                  console.log(`[${decodePath(projEnc)}  \u2192  ${sessionId}]`);
+                  const relPath = path6.relative(baseDir, fullPath);
+                  const projEnc = relPath.split(path6.sep)[0];
+                  const sessionId = path6.basename(fullPath, ".jsonl");
+                  const projName = label ? projEnc : decodePath(projEnc);
+                  console.log(`${label}[${projName}  \u2192  ${sessionId}]`);
                   found = true;
                   count++;
                 }
@@ -1211,12 +1588,14 @@ function sessionCommand() {
         }
       }
     }
-    searchDir(searchRoot);
+    for (const { root, label } of searchRoots) {
+      searchDir(root, label, root);
+    }
   });
   session.command("ps").description("Show active Claude Code processes").action(() => {
     let files;
     try {
-      files = fs2.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+      files = fs6.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
     } catch {
       console.log("(no session files found)");
       return;
@@ -1230,7 +1609,7 @@ function sessionCommand() {
     console.log(fmt("---", "----------", "-------", "---", ""));
     for (const file of files) {
       try {
-        const data = JSON.parse(fs2.readFileSync(path2.join(SESSIONS_DIR, file), "utf-8"));
+        const data = JSON.parse(fs6.readFileSync(path6.join(SESSIONS_DIR, file), "utf-8"));
         const pid = String(data.pid || "?");
         const sessionId = data.sessionId || "?";
         const cwd = data.cwd || "?";
@@ -1251,50 +1630,73 @@ function sessionCommand() {
     let nSessions = 0;
     let totalMsgs = 0;
     let nActive = 0;
+    let nDesktopSessions = 0;
+    let nDesktopMsgs = 0;
+    const walk = (dir) => {
+      const results = [];
+      try {
+        for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+          const fullPath = path6.join(dir, entry.name);
+          if (entry.isDirectory()) results.push(...walk(fullPath));
+          else if (entry.name.endsWith(".jsonl")) results.push(fullPath);
+        }
+      } catch {
+      }
+      return results;
+    };
     try {
-      nProjects = fs2.readdirSync(PROJECTS_DIR).length;
+      nProjects = fs6.readdirSync(PROJECTS_DIR).length;
     } catch {
     }
     try {
-      const walk = (dir) => {
-        const results = [];
-        try {
-          for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-            const fullPath = path2.join(dir, entry.name);
-            if (entry.isDirectory()) results.push(...walk(fullPath));
-            else if (entry.name.endsWith(".jsonl")) results.push(fullPath);
-          }
-        } catch {
-        }
-        return results;
-      };
       const sessionFiles = walk(PROJECTS_DIR);
       nSessions = sessionFiles.length;
       for (const f of sessionFiles) {
         try {
-          const content = fs2.readFileSync(f, "utf-8");
+          const content = fs6.readFileSync(f, "utf-8");
           totalMsgs += content ? content.split("\n").filter((l) => l.trim()).length : 0;
         } catch {
         }
       }
     } catch {
     }
+    if (isDesktopAppInstalled()) {
+      try {
+        const desktopFiles = walk(DESKTOP_SESSIONS_DIR2);
+        nDesktopSessions = desktopFiles.length;
+        for (const f of desktopFiles) {
+          try {
+            const content = fs6.readFileSync(f, "utf-8");
+            nDesktopMsgs += content ? content.split("\n").filter((l) => l.trim()).length : 0;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
     try {
-      nActive = fs2.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json")).length;
+      nActive = fs6.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json")).length;
     } catch {
     }
     console.log(`Projects:        ${nProjects}`);
-    console.log(`Sessions:        ${nSessions}`);
-    console.log(`Total messages:  ${totalMsgs}`);
+    console.log(`Sessions:        ${nSessions}  (CLI)`);
+    if (isDesktopAppInstalled()) {
+      console.log(`                 ${nDesktopSessions}  (desktop)`);
+    }
+    console.log(`Total messages:  ${totalMsgs}  (CLI)`);
+    if (isDesktopAppInstalled()) {
+      console.log(`                 ${nDesktopMsgs}  (desktop)`);
+    }
     console.log(`Active procs:    ${nActive}  (in ${SESSIONS_DIR})`);
     console.log("");
-    try {
-      const totalSize = execSync(`du -sh "${path2.join(process.env.CLAUDE_DIR || path2.join(process.env.HOME || "", ".claude"))}" 2>/dev/null`, { encoding: "utf-8" }).trim().split(/\s+/)[0];
-      const projSize = execSync(`du -sh "${PROJECTS_DIR}" 2>/dev/null`, { encoding: "utf-8" }).trim().split(/\s+/)[0];
-      console.log("Storage:");
-      console.log(`  Total:         ${totalSize}`);
-      console.log(`  Projects:      ${projSize}`);
-    } catch {
+    const totalSize = formatSize(getDirSize(CLAUDE_DIR));
+    const projSize = formatSize(getDirSize(PROJECTS_DIR));
+    const desktopSize = isDesktopAppInstalled() ? formatSize(getDirSize(DESKTOP_SESSIONS_DIR2)) : null;
+    console.log("Storage:");
+    console.log(`  Total:         ${totalSize}`);
+    console.log(`  Projects:      ${projSize}`);
+    if (desktopSize) {
+      console.log(`  Desktop:       ${desktopSize}`);
     }
   });
   session.command("clean").description("Delete session JSONL files older than N days").option("-d, --days <n>", "Delete files older than this many days", "30").option("--dry-run", "Show what would be deleted without deleting").action((opts) => {
@@ -1305,23 +1707,23 @@ function sessionCommand() {
     const walk = (dir) => {
       let entries;
       try {
-        entries = fs2.readdirSync(dir, { withFileTypes: true });
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
           walk(fullPath);
         } else if (entry.name.endsWith(".jsonl")) {
           try {
-            const stat = fs2.statSync(fullPath);
+            const stat = fs6.statSync(fullPath);
             if (stat.mtimeMs < cutoffMs) {
               const size = stat.size;
               if (opts.dryRun) {
                 console.log(`[dry-run] would delete: ${fullPath}  (${Math.floor(size / 1024)}KB)`);
               } else {
-                fs2.unlinkSync(fullPath);
+                fs6.unlinkSync(fullPath);
                 console.log(`Deleted: ${fullPath}`);
               }
               deleted++;
@@ -1333,6 +1735,9 @@ function sessionCommand() {
       }
     };
     walk(PROJECTS_DIR);
+    if (isDesktopAppInstalled()) {
+      walk(DESKTOP_SESSIONS_DIR2);
+    }
     console.log("");
     const verb = opts.dryRun ? "Would delete" : "Deleted";
     console.log(`${verb} ${deleted} file(s) (~${Math.floor(freed / 1024)}KB freed)`);
@@ -1340,8 +1745,10 @@ function sessionCommand() {
   return session;
 }
 
-// src/complete.ts
+// src/complete/index.ts
 import { Command as Command5 } from "commander";
+
+// src/complete/zsh.ts
 var ZSH_COMPLETION = `#compdef cc-hub
 
 _cc-hub() {
@@ -1372,6 +1779,7 @@ _cc-hub() {
     'remove:Remove a profile'
     'rename:Rename a profile'
     'default:Set the default profile'
+    'sync:Synchronize all CLI profiles to the desktop app'
   )
 
   local -a hooks_subcmds
@@ -1437,7 +1845,13 @@ _cc-hub() {
             else
               words=("stub" $words[3,-1])
               (( CURRENT-- ))
-              _arguments -C -S                 '1:profile:_cc_hub_profiles'                 '(-m --model)*'{-m,--model}'[Model ID]:model:->profileModel'                 '(-d --delete-model)*'{-d,--delete-model}'[Remove model ID]:model:->profileModel'                 '(-t --token)'{-t,--token}'[API key / token]:token:'                 '(-u --url)'{-u,--url}'[Base URL]:url:'                 '(-p --provider)'{-p,--provider}'[Provider type]:provider:(anthropic openai)'
+              _arguments -C -S \\
+                '1:profile:_cc_hub_profiles' \\
+                '(-m --model)*'{-m,--model}'[Model ID]:model:->profileModel' \\
+                '(-d --delete-model)*'{-d,--delete-model}'[Remove model ID]:model:->profileModel' \\
+                '(-t --token)'{-t,--token}'[API key / token]:token:' \\
+                '(-u --url)'{-u,--url}'[Base URL]:url:' \\
+                '(-p --provider)'{-p,--provider}'[Provider type]:provider:(anthropic openai)'
               case $state in
                 profileModel)
                   _cc_hub_models_for_profile $line[1]
@@ -1471,6 +1885,8 @@ _cc-hub() {
 
 compdef _cc-hub cc-hub
 `;
+
+// src/complete/bash.ts
 var BASH_COMPLETION = `_cc-hub_profiles() {
   local profiles_file="\${CLAUDE_PROFILES_FILE:-$HOME/.claude/profiles.json}"
   if [[ -f "$profiles_file" ]]; then
@@ -1515,7 +1931,7 @@ _cc-hub() {
   prev="\${COMP_WORDS[COMP_CWORD-1]}"
   commands="profile use run hook session provider complete help"
 
-  local profile_subcmds="add update list view remove rename default"
+  local profile_subcmds="add update list view remove rename default sync"
   local provider_subcmds="list"
   local provider_types="anthropic openai"
   local hooks_subcmds="list add remove enable disable"
@@ -1579,8 +1995,67 @@ _cc-hub() {
 
 complete -F _cc-hub cc-hub
 `;
+
+// src/complete/powershell.ts
+var POWERSHELL_COMPLETION = `Register-ArgumentCompleter -Native -CommandName cc-hub -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+
+  $commands = @(
+    'profile:Manage Claude CLI profiles'
+    'use:Set a profile as the default'
+    'run:Launch Claude Code using the default or a specified profile'
+    'hook:Manage Claude Code hooks in settings.json'
+    'session:Manage Claude Code sessions'
+    'provider:Manage provider types'
+    'complete:Print shell completion functions'
+    'help:Display help for a command'
+  )
+
+  $profileSubcmds = @('add', 'update', 'list', 'view', 'remove', 'rename', 'default', 'sync')
+  $hookSubcmds = @('list', 'add', 'remove', 'enable', 'disable')
+  $sessionSubcmds = @('list', 'show', 'search', 'ps', 'stats', 'clean')
+  $providerSubcmds = @('list')
+
+  $tokens = $commandAst.CommandElements | ForEach-Object { $_.ToString() }
+
+  if ($tokens.Count -eq 1 -or ($tokens.Count -eq 2 -and $wordToComplete -ne '')) {
+    $commands | ForEach-Object { if ($_ -like "$wordToComplete*") { $_ } }
+    return
+  }
+
+  $cmd = $tokens[1]
+
+  switch ($cmd) {
+    'profile' {
+      if ($tokens.Count -eq 2 -or ($tokens.Count -eq 3 -and $wordToComplete -ne '')) {
+        $profileSubcmds | ForEach-Object { if ($_ -like "$wordToComplete*") { $_ } }
+        return
+      }
+    }
+    'hook' {
+      if ($tokens.Count -eq 2 -or ($tokens.Count -eq 3 -and $wordToComplete -ne '')) {
+        $hookSubcmds | ForEach-Object { if ($_ -like "$wordToComplete*") { $_ } }
+        return
+      }
+    }
+    'session' {
+      if ($tokens.Count -eq 2 -or ($tokens.Count -eq 3 -and $wordToComplete -ne '')) {
+        $sessionSubcmds | ForEach-Object { if ($_ -like "$wordToComplete*") { $_ } }
+        return
+      }
+    }
+    'provider' {
+      if ($tokens.Count -eq 2 -or ($tokens.Count -eq 3 -and $wordToComplete -ne '')) {
+        $providerSubcmds | ForEach-Object { if ($_ -like "$wordToComplete*") { $_ } }
+        return
+      }
+    }
+  }
+}`;
+
+// src/complete/index.ts
 function completeCommand() {
-  return new Command5("complete").description("Print shell completion script").argument("<shell>", "Shell type: bash or zsh").action((shell) => {
+  return new Command5("complete").description("Print shell completion script").argument("<shell>", "Shell type: bash, zsh, or powershell").action((shell) => {
     switch (shell) {
       case "zsh":
         process.stdout.write(ZSH_COMPLETION);
@@ -1588,8 +2063,11 @@ function completeCommand() {
       case "bash":
         process.stdout.write(BASH_COMPLETION);
         break;
+      case "powershell":
+        process.stdout.write(POWERSHELL_COMPLETION);
+        break;
       default:
-        console.error(`Unsupported shell: ${shell}. Use 'bash' or 'zsh'.`);
+        console.error(`Unsupported shell: ${shell}. Use 'bash', 'zsh', or 'powershell'.`);
         process.exit(1);
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-hub-cli",
-  "version": "1.0.10",
+  "version": "1.1.1",
   "description": "Manage Claude CLI profiles, hooks, and sessions",
   "type": "module",
   "bin": {
@@ -32,10 +32,11 @@
     "commander": "^13.1.0"
   },
   "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@vitest/coverage-v8": "^3.0.0",
     "tsup": "^8.4.0",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0",
-    "@vitest/coverage-v8": "^3.0.0"
+    "vitest": "^3.0.0"
   },
   "engines": {
     "node": ">=18"