devswitch-cli 1.0.1

package/bin/devswitch.cjs

@@ -0,0 +1,2440 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../core/paths.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var APP_DIR_NAME = "devswitch";
+function getDataDir() {
+  const override = process.env.DEVSWITCH_DATA_DIR;
+  if (override && override.trim()) {
+    return override.trim();
+  }
+  const platform2 = os.platform();
+  const home = os.homedir();
+  if (platform2 === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    return path.join(appData, APP_DIR_NAME);
+  }
+  if (platform2 === "darwin") {
+    return path.join(home, "Library", "Application Support", APP_DIR_NAME);
+  }
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && xdg.trim() ? xdg.trim() : path.join(home, ".config");
+  return path.join(base, APP_DIR_NAME);
+}
+function ensureDataDir() {
+  const dir = getDataDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  return dir;
+}
+function getProfilesFilePath() {
+  return path.join(getDataDir(), "profiles.json");
+}
+function getLogsFilePath() {
+  return path.join(getDataDir(), "logs.json");
+}
+function getLegacyStoreCandidates() {
+  const platform2 = os.platform();
+  const home = os.homedir();
+  let configBases = [];
+  if (platform2 === "win32") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+    configBases = [appData];
+  } else if (platform2 === "darwin") {
+    configBases = [path.join(home, "Library", "Application Support")];
+  } else {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.trim() ? xdg.trim() : path.join(home, ".config");
+    configBases = [base];
+  }
+  const legacyAppFolders = ["dev-switch", "DevSwitch", "Electron"];
+  const profiles = [];
+  const logs = [];
+  for (const cfg of configBases) {
+    for (const folder of legacyAppFolders) {
+      profiles.push(path.join(cfg, folder, "dev-switch-data.json"));
+      logs.push(path.join(cfg, folder, "dev-switch-logs.json"));
+    }
+  }
+  return { profiles, logs };
+}
+
+// ../core/jsonStore.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var JsonStore = class {
+  filePath;
+  defaults;
+  constructor(filePath, defaults) {
+    this.filePath = filePath;
+    this.defaults = defaults;
+  }
+  getFilePath() {
+    return this.filePath;
+  }
+  /** Read the entire document fresh from disk, falling back to defaults. */
+  read() {
+    try {
+      if (!fs2.existsSync(this.filePath)) {
+        return structuredClone(this.defaults);
+      }
+      const raw = fs2.readFileSync(this.filePath, "utf8");
+      if (!raw.trim()) {
+        return structuredClone(this.defaults);
+      }
+      const parsed = JSON.parse(raw);
+      return { ...structuredClone(this.defaults), ...parsed };
+    } catch {
+      return structuredClone(this.defaults);
+    }
+  }
+  /** Atomically write the entire document to disk. */
+  write(data) {
+    ensureDataDir();
+    const dir = path2.dirname(this.filePath);
+    const tmp = path2.join(
+      dir,
+      `.${path2.basename(this.filePath)}.${process.pid}.tmp`
+    );
+    const json = JSON.stringify(data, null, 2);
+    fs2.writeFileSync(tmp, json, { mode: 384 });
+    fs2.renameSync(tmp, this.filePath);
+  }
+  get(key, fallback) {
+    const data = this.read();
+    const value = data[key];
+    return value === void 0 ? fallback : value;
+  }
+  set(key, value) {
+    const data = this.read();
+    data[key] = value;
+    this.write(data);
+  }
+};
+
+// ../core/utils/encryption.ts
+var import_crypto = __toESM(require("crypto"), 1);
+var import_os = __toESM(require("os"), 1);
+function getMachineKey() {
+  const machineId = import_os.default.hostname() + import_os.default.platform() + import_os.default.arch();
+  return import_crypto.default.scryptSync(machineId, "dev-switch-salt", 32);
+}
+function encryptPassphrase(passphrase) {
+  if (!passphrase) return "";
+  const key = getMachineKey();
+  const iv = import_crypto.default.randomBytes(16);
+  const cipher = import_crypto.default.createCipheriv("aes-256-gcm", key, iv);
+  let encrypted = cipher.update(passphrase, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag();
+  return `${iv.toString("hex")}:${authTag.toString("hex")}:${encrypted}`;
+}
+
+// ../core/utils/environment.ts
+var import_os2 = __toESM(require("os"), 1);
+var isWindows = import_os2.default.platform() === "win32";
+var isMac = import_os2.default.platform() === "darwin";
+var isLinux = import_os2.default.platform() === "linux";
+var isDev = process.env.NODE_ENV === "development";
+
+// ../core/utils/providerUtils.ts
+var PROVIDER_SSH_CONFIGS = {
+  github: { sshHost: "github.com", sshUser: "git" },
+  gitlab: { sshHost: "gitlab.com", sshUser: "git" },
+  bitbucket: { sshHost: "bitbucket.org", sshUser: "git" },
+  azure: { sshHost: "ssh.dev.azure.com", sshUser: "git" },
+  other: { sshHost: "git.example.com", sshUser: "git" }
+};
+function getProviderSSHConfig(provider) {
+  return PROVIDER_SSH_CONFIGS[provider || "github"];
+}
+function isSSHAuthSuccess(output) {
+  const lower = output.toLowerCase();
+  return lower.includes("authenticated") || // GitHub: "You've successfully authenticated"
+  lower.includes("welcome to gitlab") || lower.includes("logged in as") || // Bitbucket
+  lower.includes("shell access is not permitted");
+}
+
+// ../core/services/storageService.ts
+var fs3 = __toESM(require("fs"), 1);
+var StorageService = class {
+  store;
+  constructor() {
+    this.store = new JsonStore(getProfilesFilePath(), {
+      profiles: []
+    });
+    this.migrateFromElectronStoreIfNeeded();
+  }
+  /**
+   * One-time import of profiles from the old electron-store JSON files.
+   * Runs only if the new store has never been migrated AND is empty, so it
+   * never clobbers data created directly in the new location.
+   */
+  migrateFromElectronStoreIfNeeded() {
+    try {
+      const current = this.store.read();
+      if (current._migratedFromElectronStore) return;
+      if (current.profiles && current.profiles.length > 0) {
+        current._migratedFromElectronStore = true;
+        this.store.write(current);
+        return;
+      }
+      const { profiles: candidates } = getLegacyStoreCandidates();
+      for (const candidate of candidates) {
+        if (!fs3.existsSync(candidate)) continue;
+        try {
+          const raw = fs3.readFileSync(candidate, "utf8");
+          if (!raw.trim()) continue;
+          const parsed = JSON.parse(raw);
+          if (parsed.profiles && parsed.profiles.length > 0) {
+            current.profiles = parsed.profiles;
+            current._migratedFromElectronStore = true;
+            this.store.write(current);
+            return;
+          }
+        } catch {
+        }
+      }
+      current._migratedFromElectronStore = true;
+      this.store.write(current);
+    } catch {
+    }
+  }
+  getAllProfiles() {
+    return this.store.get("profiles", []);
+  }
+  getProfile(id) {
+    return this.getAllProfiles().find((p) => p.id === id);
+  }
+  /**
+   * Look up a profile by a human-friendly identifier used on the CLI:
+   * matches (case-insensitively) against name, username, or email, and also
+   * accepts a full/lowercased id. Returns the first match.
+   */
+  findProfile(identifier) {
+    const profiles = this.getAllProfiles();
+    const needle = identifier.trim().toLowerCase();
+    const byId = profiles.find((p) => p.id.toLowerCase() === needle);
+    if (byId) return byId;
+    const exact = profiles.find(
+      (p) => p.name.toLowerCase() === needle || p.username.toLowerCase() === needle || p.email.toLowerCase() === needle
+    );
+    if (exact) return exact;
+    return profiles.find(
+      (p) => p.name.toLowerCase().includes(needle) || p.username.toLowerCase().includes(needle)
+    );
+  }
+  saveProfile(profile) {
+    const profiles = this.getAllProfiles();
+    const index = profiles.findIndex((p) => p.id === profile.id);
+    if (index >= 0) {
+      profiles[index] = profile;
+    } else {
+      profiles.push(profile);
+    }
+    this.store.set("profiles", profiles);
+  }
+  deleteProfile(id) {
+    const profiles = this.getAllProfiles();
+    const filtered = profiles.filter((p) => p.id !== id);
+    if (filtered.length < profiles.length) {
+      this.store.set("profiles", filtered);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.store.set("profiles", []);
+  }
+};
+var storageService = new StorageService();
+
+// ../core/services/logService.ts
+var fs4 = __toESM(require("fs"), 1);
+var import_crypto2 = require("crypto");
+var LogService = class {
+  store;
+  maxLogs = 500;
+  /** Default source tag for logs created in this process. */
+  defaultSource = "app";
+  constructor() {
+    this.store = new JsonStore(getLogsFilePath(), {
+      logs: []
+    });
+    this.migrateFromElectronStoreIfNeeded();
+  }
+  /** Set the origin tag (the CLI entrypoint calls this with 'cli'). */
+  setDefaultSource(source) {
+    this.defaultSource = source;
+  }
+  migrateFromElectronStoreIfNeeded() {
+    try {
+      const current = this.store.read();
+      if (current._migratedFromElectronStore) return;
+      if (current.logs && current.logs.length > 0) {
+        current._migratedFromElectronStore = true;
+        this.store.write(current);
+        return;
+      }
+      const { logs: candidates } = getLegacyStoreCandidates();
+      for (const candidate of candidates) {
+        if (!fs4.existsSync(candidate)) continue;
+        try {
+          const raw = fs4.readFileSync(candidate, "utf8");
+          if (!raw.trim()) continue;
+          const parsed = JSON.parse(raw);
+          if (parsed.logs && parsed.logs.length > 0) {
+            current.logs = parsed.logs;
+            current._migratedFromElectronStore = true;
+            this.store.write(current);
+            return;
+          }
+        } catch {
+        }
+      }
+      current._migratedFromElectronStore = true;
+      this.store.write(current);
+    } catch {
+    }
+  }
+  getAllLogs() {
+    return this.store.get("logs", []);
+  }
+  addLog(action, message, details, source) {
+    const log = {
+      id: (0, import_crypto2.randomUUID)(),
+      timestamp: Date.now(),
+      action,
+      message,
+      source: source ?? this.defaultSource,
+      details
+    };
+    const logs = this.getAllLogs();
+    logs.unshift(log);
+    if (logs.length > this.maxLogs) {
+      logs.length = this.maxLogs;
+    }
+    this.store.set("logs", logs);
+    return log;
+  }
+  clearLogs() {
+    this.store.set("logs", []);
+  }
+  clearLogsBefore(timestamp) {
+    if (typeof timestamp !== "number" || Number.isNaN(timestamp) || !Number.isFinite(timestamp)) {
+      return;
+    }
+    const logs = this.getAllLogs();
+    const filtered = logs.filter((log) => log.timestamp >= timestamp);
+    this.store.set("logs", filtered);
+  }
+};
+var logService = new LogService();
+
+// ../core/services/sshKeyService.ts
+var import_child_process = require("child_process");
+var import_util = require("util");
+var path3 = __toESM(require("path"), 1);
+var fs5 = __toESM(require("fs"), 1);
+var import_os3 = __toESM(require("os"), 1);
+var execAsync = (0, import_util.promisify)(import_child_process.exec);
+var SSHKeyService = class {
+  getSshDir() {
+    return path3.join(import_os3.default.homedir(), ".ssh");
+  }
+  async generateKey(params) {
+    try {
+      const sshDir = this.getSshDir();
+      if (!fs5.existsSync(sshDir)) {
+        fs5.mkdirSync(sshDir, { mode: 448 });
+      }
+      const keyPath = path3.join(sshDir, params.name);
+      if (fs5.existsSync(keyPath)) {
+        return {
+          success: false,
+          error: `SSH key '${params.name}' already exists`
+        };
+      }
+      let command;
+      if (params.algorithm === "ed25519") {
+        command = `ssh-keygen -t ed25519 -C "${params.email}" -f "${keyPath}" -N "${params.passphrase || ""}"`;
+      } else {
+        command = `ssh-keygen -t rsa -b 4096 -C "${params.email}" -f "${keyPath}" -N "${params.passphrase || ""}"`;
+      }
+      await execAsync(command);
+      if (fs5.existsSync(keyPath)) {
+        fs5.chmodSync(keyPath, 384);
+        if (fs5.existsSync(`${keyPath}.pub`)) {
+          fs5.chmodSync(`${keyPath}.pub`, 420);
+        }
+        logService.addLog(
+          "SSH_KEY_GENERATED",
+          `SSH key '${params.name}' generated`,
+          {
+            keyPath,
+            algorithm: params.algorithm
+          }
+        );
+        return { success: true, keyPath };
+      }
+      return {
+        success: false,
+        error: "Key generation failed - file not created"
+      };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Unknown error"
+      };
+    }
+  }
+  getDefaultKeyPath() {
+    return path3.join(this.getSshDir(), "id_rsa");
+  }
+  keyExists(keyPath) {
+    return fs5.existsSync(keyPath);
+  }
+  getPublicKeyContent(privateKeyPath) {
+    const publicKeyPath = `${privateKeyPath}.pub`;
+    if (fs5.existsSync(publicKeyPath)) {
+      return fs5.readFileSync(publicKeyPath, "utf8").trim();
+    }
+    return null;
+  }
+  deleteKey(keyPath) {
+    try {
+      if (fs5.existsSync(keyPath)) {
+        fs5.unlinkSync(keyPath);
+      }
+      const publicKeyPath = `${keyPath}.pub`;
+      if (fs5.existsSync(publicKeyPath)) {
+        fs5.unlinkSync(publicKeyPath);
+      }
+      return { success: true };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to delete key"
+      };
+    }
+  }
+  async checkDefaultKeys() {
+    const sshDir = this.getSshDir();
+    const defaultKeys = [];
+    const rsaPrivatePath = path3.join(sshDir, "id_rsa");
+    const rsaPublicPath = `${rsaPrivatePath}.pub`;
+    if (fs5.existsSync(rsaPrivatePath) && fs5.existsSync(rsaPublicPath)) {
+      defaultKeys.push({
+        algorithm: "rsa",
+        privatePath: rsaPrivatePath,
+        publicPath: rsaPublicPath
+      });
+    }
+    const ed25519PrivatePath = path3.join(sshDir, "id_ed25519");
+    const ed25519PublicPath = `${ed25519PrivatePath}.pub`;
+    if (fs5.existsSync(ed25519PrivatePath) && fs5.existsSync(ed25519PublicPath)) {
+      defaultKeys.push({
+        algorithm: "ed25519",
+        privatePath: ed25519PrivatePath,
+        publicPath: ed25519PublicPath
+      });
+    }
+    return defaultKeys;
+  }
+  /**
+   * Scan the .ssh directory and find all SSH key pairs.
+   */
+  async scanAllSSHKeys() {
+    const sshDir = this.getSshDir();
+    const keys = [];
+    try {
+      if (!fs5.existsSync(sshDir)) {
+        return keys;
+      }
+      const files = fs5.readdirSync(sshDir);
+      const pubFiles = files.filter((f) => f.endsWith(".pub"));
+      for (const pubFile of pubFiles) {
+        const publicPath = path3.join(sshDir, pubFile);
+        const privateFileName = pubFile.replace(".pub", "");
+        const privatePath = path3.join(sshDir, privateFileName);
+        if (!fs5.existsSync(privatePath)) {
+          continue;
+        }
+        const publicKeyContent = fs5.readFileSync(publicPath, "utf8").trim();
+        const email = this.extractEmailFromPublicKey(publicKeyContent);
+        let algorithm = "rsa";
+        if (publicKeyContent.startsWith("ssh-ed25519")) algorithm = "ed25519";
+        else if (publicKeyContent.startsWith("ssh-rsa")) algorithm = "rsa";
+        else if (publicKeyContent.startsWith("ecdsa-sha2")) algorithm = "ecdsa";
+        else if (publicKeyContent.startsWith("ssh-dss")) algorithm = "dsa";
+        keys.push({ privatePath, publicPath, email, algorithm });
+      }
+      return keys;
+    } catch (error2) {
+      console.error("Error scanning SSH keys:", error2);
+      return keys;
+    }
+  }
+  extractEmailFromPublicKey(publicKeyContent) {
+    try {
+      const parts = publicKeyContent.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const lastPart = parts[parts.length - 1];
+        if (lastPart.includes("@")) {
+          return lastPart;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+var sshKeyService = new SSHKeyService();
+
+// ../core/services/sshAgentService.ts
+var import_child_process2 = require("child_process");
+var import_util2 = require("util");
+var fs6 = __toESM(require("fs"), 1);
+var execAsync2 = (0, import_util2.promisify)(import_child_process2.exec);
+var SSHAgentService = class {
+  async addKeyToAgent(params) {
+    try {
+      if (!fs6.existsSync(params.keyPath)) {
+        return {
+          success: false,
+          error: `SSH key not found at ${params.keyPath}`
+        };
+      }
+      if (isWindows) {
+        return await this.addKeyToAgentWindows(params);
+      } else {
+        return await this.addKeyToAgentUnix(params);
+      }
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to add key to agent"
+      };
+    }
+  }
+  async addKeyToAgentUnix(params) {
+    try {
+      const agentCheck = await execAsync2("pgrep ssh-agent").catch(() => null);
+      if (!agentCheck) {
+        try {
+          await execAsync2('eval "$(ssh-agent -s)"');
+        } catch (error2) {
+          console.error("Failed to start ssh-agent:", error2);
+          return {
+            success: false,
+            error: "ssh-agent is not running and could not be started"
+          };
+        }
+      }
+      let command;
+      if (params.passphrase) {
+        command = `echo "${params.passphrase}" | ssh-add "${params.keyPath}"`;
+      } else {
+        command = `ssh-add "${params.keyPath}"`;
+      }
+      await execAsync2(command);
+      return { success: true };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to add key to agent"
+      };
+    }
+  }
+  async addKeyToAgentWindows(params) {
+    try {
+      const serviceCheck = await execAsync2("sc query ssh-agent").catch(
+        () => null
+      );
+      if (!serviceCheck || !serviceCheck.stdout.includes("RUNNING")) {
+        try {
+          await execAsync2("Start-Service ssh-agent", {
+            shell: "powershell.exe"
+          });
+        } catch (error2) {
+          console.error("Failed to start ssh-agent service:", error2);
+          return {
+            success: false,
+            error: "ssh-agent service is not running and could not be started"
+          };
+        }
+      }
+      const command = `ssh-add "${params.keyPath}"`;
+      await execAsync2(command);
+      return { success: true };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to add key to agent"
+      };
+    }
+  }
+  async listKeys() {
+    try {
+      const { stdout } = await execAsync2("ssh-add -l");
+      const keys = stdout.split("\n").filter((line) => line.trim()).map((line) => line.trim());
+      return { success: true, keys };
+    } catch {
+      return { success: true, keys: [] };
+    }
+  }
+};
+var sshAgentService = new SSHAgentService();
+
+// ../core/services/sshConfigService.ts
+var fs7 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_os4 = __toESM(require("os"), 1);
+var SSHConfigService = class {
+  getConfigPath() {
+    return path4.join(import_os4.default.homedir(), ".ssh", "config");
+  }
+  async readConfig() {
+    try {
+      const configPath = this.getConfigPath();
+      if (!fs7.existsSync(configPath)) {
+        return { content: "" };
+      }
+      const content = fs7.readFileSync(configPath, "utf8");
+      return { content };
+    } catch (error2) {
+      return {
+        content: "",
+        error: error2 instanceof Error ? error2.message : "Failed to read config"
+      };
+    }
+  }
+  async updateConfig(profile) {
+    try {
+      const configPath = this.getConfigPath();
+      const sshDir = path4.dirname(configPath);
+      if (!fs7.existsSync(sshDir)) {
+        fs7.mkdirSync(sshDir, { mode: 448 });
+      }
+      let content = "";
+      if (fs7.existsSync(configPath)) {
+        content = fs7.readFileSync(configPath, "utf8");
+      }
+      content = this.removeProfileEntry(content, profile.id);
+      if (profile.keyPath && profile.sshKeyType !== "default") {
+        const hostAlias = this.getHostAlias(profile);
+        const entry = this.generateConfigEntry(profile, hostAlias);
+        content = content.trim() + "\n\n" + entry + "\n";
+      }
+      fs7.writeFileSync(configPath, content, { mode: 384 });
+      logService.addLog(
+        "SSH_CONFIG_UPDATED",
+        `SSH config updated for profile "${profile.name}"`,
+        {
+          profileId: profile.id,
+          provider: profile.provider
+        }
+      );
+      return { success: true };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to update config"
+      };
+    }
+  }
+  async removeProfileConfig(profileId) {
+    try {
+      const configPath = this.getConfigPath();
+      if (!fs7.existsSync(configPath)) {
+        return { success: true };
+      }
+      let content = fs7.readFileSync(configPath, "utf8");
+      content = this.removeProfileEntry(content, profileId);
+      fs7.writeFileSync(configPath, content, { mode: 384 });
+      return { success: true };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to remove config"
+      };
+    }
+  }
+  getHostAlias(profile) {
+    const { sshHost } = getProviderSSHConfig(profile.provider);
+    return `${sshHost}-${profile.username}`;
+  }
+  generateConfigEntry(profile, hostAlias) {
+    const { sshHost, sshUser } = getProviderSSHConfig(profile.provider);
+    return `# DevSwitch Profile: ${profile.email} (${profile.id})
+Host ${hostAlias}
+  HostName ${sshHost}
+  User ${sshUser}
+  IdentityFile ${profile.keyPath}
+  IdentitiesOnly yes
+# DevSwitch Profile End: (${profile.id})`;
+  }
+  removeProfileEntry(content, profileId) {
+    const lines = content.split("\n");
+    const result = [];
+    let inProfileBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes("# DevSwitch Profile:") && line.includes(`(${profileId})`)) {
+        inProfileBlock = true;
+        continue;
+      }
+      if (inProfileBlock && line.includes("# DevSwitch Profile End:") && line.includes(`(${profileId})`)) {
+        inProfileBlock = false;
+        if (i + 1 < lines.length && lines[i + 1].trim() === "") {
+          i++;
+        }
+        continue;
+      }
+      if (inProfileBlock) {
+        continue;
+      }
+      result.push(line);
+    }
+    const cleaned = result.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return cleaned + "\n";
+  }
+  checkProfileConfigured(profile) {
+    try {
+      const configPath = this.getConfigPath();
+      if (!fs7.existsSync(configPath)) {
+        return false;
+      }
+      const content = fs7.readFileSync(configPath, "utf8");
+      return content.includes(`(${profile.id})`);
+    } catch {
+      return false;
+    }
+  }
+  getHostAliasForKeyPath(keyPath) {
+    try {
+      const configPath = this.getConfigPath();
+      if (!fs7.existsSync(configPath)) {
+        return null;
+      }
+      const content = fs7.readFileSync(configPath, "utf8");
+      const lines = content.split("\n");
+      let currentHost = null;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        const hostMatch = line.match(/^Host\s+(.+)$/i);
+        if (hostMatch) {
+          currentHost = hostMatch[1];
+          continue;
+        }
+        const identityMatch = line.match(/^IdentityFile\s+(.+)$/i);
+        if (identityMatch && currentHost) {
+          const configKeyPath = identityMatch[1].replace(/^~/, import_os4.default.homedir());
+          const normalizedConfigPath = path4.normalize(configKeyPath);
+          const normalizedKeyPath = path4.normalize(keyPath);
+          if (normalizedConfigPath === normalizedKeyPath) {
+            return currentHost;
+          }
+        }
+      }
+      return null;
+    } catch (error2) {
+      console.error("Error finding host alias:", error2);
+      return null;
+    }
+  }
+  async getGlobalGitConfig() {
+    try {
+      const { exec: exec4 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync4 = promisify4(exec4);
+      const { stdout } = await execAsync4("git config --global --list");
+      const config = {};
+      const lines = stdout.trim().split("\n");
+      for (const line of lines) {
+        const [key, ...valueParts] = line.split("=");
+        if (key && valueParts.length > 0) {
+          config[key] = valueParts.join("=");
+        }
+      }
+      return config;
+    } catch (error2) {
+      console.error("Error getting global git config:", error2);
+      return {};
+    }
+  }
+  getAllHostKeyMappings() {
+    try {
+      const configPath = this.getConfigPath();
+      if (!fs7.existsSync(configPath)) {
+        return [];
+      }
+      const content = fs7.readFileSync(configPath, "utf8");
+      const lines = content.split("\n");
+      const mappings = [];
+      let currentHost = null;
+      let currentHostname = null;
+      let currentIdentityFile = null;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("#") || !line) {
+          continue;
+        }
+        const hostMatch = line.match(/^Host\s+(.+)$/i);
+        if (hostMatch) {
+          if (currentHost && currentIdentityFile) {
+            mappings.push({
+              host: currentHost,
+              hostname: currentHostname || "",
+              identityFile: currentIdentityFile.replace(/^~/, import_os4.default.homedir()),
+              username: this.extractUsernameFromHost(currentHost)
+            });
+          }
+          currentHost = hostMatch[1];
+          currentHostname = null;
+          currentIdentityFile = null;
+          continue;
+        }
+        const hostnameMatch = line.match(/^HostName\s+(.+)$/i);
+        if (hostnameMatch && currentHost) {
+          currentHostname = hostnameMatch[1];
+          continue;
+        }
+        const identityMatch = line.match(/^IdentityFile\s+(.+)$/i);
+        if (identityMatch && currentHost) {
+          currentIdentityFile = identityMatch[1];
+          continue;
+        }
+      }
+      if (currentHost && currentIdentityFile) {
+        mappings.push({
+          host: currentHost,
+          hostname: currentHostname || "",
+          identityFile: currentIdentityFile.replace(/^~/, import_os4.default.homedir()),
+          username: this.extractUsernameFromHost(currentHost)
+        });
+      }
+      return mappings;
+    } catch (error2) {
+      console.error("Error parsing SSH config:", error2);
+      return [];
+    }
+  }
+  extractUsernameFromHost(host) {
+    try {
+      const separators = ["-", "_"];
+      for (const separator of separators) {
+        if (host.includes(separator)) {
+          const parts = host.split(separator);
+          if (parts.length > 1) {
+            const username = parts.slice(1).join(separator);
+            return username || null;
+          }
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+var sshConfigService = new SSHConfigService();
+
+// ../core/services/gitService.ts
+var import_child_process3 = require("child_process");
+var fs8 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var GitService = class {
+  async cloneRepository(params) {
+    try {
+      const { repoUrl, destinationFolder, username, email, hostAlias } = params;
+      if (!fs8.existsSync(destinationFolder)) {
+        return { success: false, error: "Destination folder does not exist" };
+      }
+      const sshUrl = this.convertToSSHUrl(repoUrl, hostAlias);
+      if (!sshUrl) {
+        return { success: false, error: "Invalid repository URL format" };
+      }
+      const repoName = this.extractRepoName(sshUrl);
+      const clonePath = path5.join(destinationFolder, repoName);
+      if (fs8.existsSync(clonePath)) {
+        return {
+          success: false,
+          error: `Directory ${repoName} already exists in the destination folder`
+        };
+      }
+      try {
+        (0, import_child_process3.execSync)(`git clone ${sshUrl}`, {
+          cwd: destinationFolder,
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+      } catch (error2) {
+        return {
+          success: false,
+          error: `Failed to clone repository: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+        };
+      }
+      try {
+        (0, import_child_process3.execSync)(`git config user.name "${username}"`, {
+          cwd: clonePath,
+          stdio: "pipe"
+        });
+        (0, import_child_process3.execSync)(`git config user.email "${email}"`, {
+          cwd: clonePath,
+          stdio: "pipe"
+        });
+      } catch (error2) {
+        return {
+          success: false,
+          error: `Repository cloned but failed to configure git settings: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+        };
+      }
+      return { success: true, clonedPath: clonePath };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to clone repository"
+      };
+    }
+  }
+  async updateProjectConfig(params) {
+    try {
+      const {
+        projectPath,
+        username,
+        email,
+        repoUrl,
+        remoteName = "origin",
+        hostAlias
+      } = params;
+      if (!fs8.existsSync(projectPath)) {
+        return { success: false, error: "Project path does not exist" };
+      }
+      const gitDir = path5.join(projectPath, ".git");
+      if (!fs8.existsSync(gitDir)) {
+        return { success: false, error: "Not a git repository" };
+      }
+      let oldOrigin = "";
+      if (repoUrl && repoUrl.trim()) {
+        try {
+          oldOrigin = (0, import_child_process3.execSync)(`git remote get-url ${remoteName}`, {
+            cwd: projectPath,
+            encoding: "utf-8"
+          }).trim();
+        } catch {
+          oldOrigin = "none";
+        }
+        const sshUrl = this.convertToSSHUrl(repoUrl, hostAlias);
+        if (!sshUrl) {
+          return { success: false, error: "Invalid repository URL format" };
+        }
+        try {
+          if (oldOrigin === "none") {
+            (0, import_child_process3.execSync)(`git remote add ${remoteName} ${sshUrl}`, {
+              cwd: projectPath,
+              stdio: "pipe"
+            });
+          } else {
+            (0, import_child_process3.execSync)(`git remote set-url ${remoteName} ${sshUrl}`, {
+              cwd: projectPath,
+              stdio: "pipe"
+            });
+          }
+        } catch (error2) {
+          return {
+            success: false,
+            error: `Failed to update remote ${remoteName}: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+          };
+        }
+      }
+      try {
+        (0, import_child_process3.execSync)(`git config user.name "${username}"`, {
+          cwd: projectPath,
+          stdio: "pipe"
+        });
+        (0, import_child_process3.execSync)(`git config user.email "${email}"`, {
+          cwd: projectPath,
+          stdio: "pipe"
+        });
+      } catch (error2) {
+        return {
+          success: false,
+          error: `${repoUrl ? "Remote updated but " : ""}Failed to configure git settings: ${error2 instanceof Error ? error2.message : "Unknown error"}`
+        };
+      }
+      return { success: true, oldOrigin };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to update project configuration"
+      };
+    }
+  }
+  async getProjectRemotes(projectPath) {
+    try {
+      if (!fs8.existsSync(projectPath)) {
+        return { success: false, error: "Project path does not exist" };
+      }
+      const gitDir = path5.join(projectPath, ".git");
+      if (!fs8.existsSync(gitDir)) {
+        return { success: false, error: "Not a git repository" };
+      }
+      let remoteOutput = "";
+      try {
+        remoteOutput = (0, import_child_process3.execSync)("git remote -v", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim();
+      } catch {
+        return { success: true, remotes: [] };
+      }
+      if (!remoteOutput) {
+        return { success: true, remotes: [] };
+      }
+      const remotes = [];
+      const lines = remoteOutput.split("\n");
+      for (const line of lines) {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+        if (match) {
+          const [, name, url, type] = match;
+          remotes.push({ name, url, type });
+        }
+      }
+      return { success: true, remotes };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to get project remotes"
+      };
+    }
+  }
+  async getProjectConfig(projectPath) {
+    try {
+      if (!fs8.existsSync(projectPath)) {
+        return { success: false, error: "Project path does not exist" };
+      }
+      const gitDir = path5.join(projectPath, ".git");
+      if (!fs8.existsSync(gitDir)) {
+        return { success: false, error: "Not a git repository" };
+      }
+      const config = {};
+      try {
+        config.username = (0, import_child_process3.execSync)("git config user.name", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim();
+      } catch {
+      }
+      try {
+        config.email = (0, import_child_process3.execSync)("git config user.email", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim();
+      } catch {
+      }
+      try {
+        config.origin = (0, import_child_process3.execSync)("git remote get-url origin", {
+          cwd: projectPath,
+          encoding: "utf-8"
+        }).trim();
+      } catch {
+      }
+      return { success: true, config };
+    } catch (error2) {
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "Failed to get project configuration"
+      };
+    }
+  }
+  convertToSSHUrl(url, hostAlias) {
+    const sshMatch = url.match(/git@[^:]+:([^/]+)\/(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+      const [, username, repo] = sshMatch;
+      return `git@${hostAlias}:${username}/${repo}.git`;
+    }
+    const httpsMatch = url.match(/https?:\/\/[^/]+\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+      const [, username, repo] = httpsMatch;
+      return `git@${hostAlias}:${username}/${repo}.git`;
+    }
+    return null;
+  }
+  extractRepoName(sshUrl) {
+    const match = sshUrl.match(/\/([^/]+?)(?:\.git)?$/);
+    return match ? match[1] : "repository";
+  }
+};
+var gitService = new GitService();
+
+// ../core/services/sshTestService.ts
+var import_child_process4 = require("child_process");
+var import_util3 = require("util");
+var execAsync3 = (0, import_util3.promisify)(import_child_process4.exec);
+async function testSSHConnection(params) {
+  try {
+    const keyFlag = params.keyPath ? ` -i "${params.keyPath}"` : "";
+    const command = `ssh -T${keyFlag} -o BatchMode=yes -o ConnectTimeout=10 -o StrictHostKeyChecking=accept-new ${params.sshUser}@${params.hostAlias}`;
+    try {
+      const { stdout, stderr } = await execAsync3(command);
+      const output = (stdout + "\n" + stderr).trim();
+      return { success: true, output };
+    } catch (err) {
+      const execErr = err;
+      const output = ((execErr.stdout || "") + "\n" + (execErr.stderr || "")).trim();
+      if (isSSHAuthSuccess(output)) {
+        return { success: true, output };
+      }
+      return {
+        success: false,
+        output,
+        error: execErr.message || "SSH connection failed"
+      };
+    }
+  } catch (error2) {
+    return {
+      success: false,
+      output: "",
+      error: error2 instanceof Error ? error2.message : "Failed to run SSH test"
+    };
+  }
+}
+
+// ../core/services/profileManager.ts
+var profileManager_exports = {};
+__export(profileManager_exports, {
+  createProfile: () => createProfile,
+  deleteProfile: () => deleteProfile,
+  getAllProfiles: () => getAllProfiles,
+  getProfileById: () => getProfileById,
+  scanAndSync: () => scanAndSync,
+  switchProfile: () => switchProfile,
+  updateProfile: () => updateProfile
+});
+var import_crypto3 = require("crypto");
+var path6 = __toESM(require("path"), 1);
+var SYNC_COLORS = [
+  "#3b82f6",
+  "#10b981",
+  "#f59e0b",
+  "#ef4444",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#84cc16"
+];
+var SYNC_EMOJIS = ["\u{1F464}", "\u{1F4BB}", "\u{1F680}", "\u{1F511}", "\u{1F4BC}", "\u{1F3AF}", "\u{1F31F}", "\u{1F4A1}"];
+async function createProfile(input, source = "app") {
+  const profile = {
+    id: (0, import_crypto3.randomUUID)(),
+    name: input.name,
+    email: input.email,
+    username: input.username,
+    sshKeyType: input.sshKeyType,
+    keyPath: null,
+    keyAlgorithm: null,
+    hasPassphrase: false,
+    passphraseEncrypted: null,
+    hostConfigured: false,
+    provider: input.provider,
+    avatar: input.avatar,
+    color: input.color,
+    tags: input.tags,
+    createdAt: Date.now(),
+    updatedAt: Date.now()
+  };
+  if (input.sshKeyType === "default") {
+    profile.keyPath = sshKeyService.getDefaultKeyPath();
+  } else if (input.sshKeyType === "generated" && input.keyAlgorithm && input.keyName) {
+    const result = await sshKeyService.generateKey({
+      algorithm: input.keyAlgorithm,
+      name: input.keyName,
+      passphrase: input.passphrase,
+      email: input.email
+    });
+    if (result.success && result.keyPath) {
+      profile.keyPath = result.keyPath;
+      profile.keyAlgorithm = input.keyAlgorithm;
+      if (input.passphrase) {
+        profile.hasPassphrase = true;
+        profile.passphraseEncrypted = encryptPassphrase(input.passphrase);
+      }
+      await sshAgentService.addKeyToAgent({
+        keyPath: result.keyPath,
+        passphrase: input.passphrase
+      });
+    } else {
+      throw new Error(result.error || "Failed to generate SSH key");
+    }
+  } else if (input.sshKeyType === "existing" && input.existingKeyPath) {
+    profile.keyPath = input.existingKeyPath;
+  }
+  if (profile.keyPath) {
+    const configResult = await sshConfigService.updateConfig(profile);
+    profile.hostConfigured = configResult.success;
+  }
+  storageService.saveProfile(profile);
+  logService.addLog(
+    "PROFILE_CREATED",
+    `Profile "${profile.name}" created`,
+    {
+      profileId: profile.id,
+      provider: profile.provider,
+      sshKeyType: profile.sshKeyType
+    },
+    source
+  );
+  return profile;
+}
+async function updateProfile(input, source = "app") {
+  const existingProfile = storageService.getProfile(input.id);
+  if (!existingProfile) {
+    throw new Error("Profile not found");
+  }
+  const updatedProfile = {
+    ...existingProfile,
+    name: input.name ?? existingProfile.name,
+    email: input.email ?? existingProfile.email,
+    username: input.username ?? existingProfile.username,
+    avatar: input.avatar ?? existingProfile.avatar,
+    color: input.color ?? existingProfile.color,
+    tags: input.tags ?? existingProfile.tags,
+    provider: input.provider ?? existingProfile.provider,
+    updatedAt: Date.now()
+  };
+  if (input.sshKeyType) {
+    updatedProfile.sshKeyType = input.sshKeyType;
+    if (input.sshKeyType === "default") {
+      updatedProfile.keyPath = sshKeyService.getDefaultKeyPath();
+      updatedProfile.keyAlgorithm = null;
+      updatedProfile.hasPassphrase = false;
+      updatedProfile.passphraseEncrypted = null;
+    } else if (input.sshKeyType === "generated" && input.keyAlgorithm && input.keyName) {
+      const result = await sshKeyService.generateKey({
+        algorithm: input.keyAlgorithm,
+        name: input.keyName,
+        passphrase: input.passphrase,
+        email: updatedProfile.email
+      });
+      if (result.success && result.keyPath) {
+        updatedProfile.keyPath = result.keyPath;
+        updatedProfile.keyAlgorithm = input.keyAlgorithm;
+        if (input.passphrase) {
+          updatedProfile.hasPassphrase = true;
+          updatedProfile.passphraseEncrypted = encryptPassphrase(
+            input.passphrase
+          );
+        }
+        await sshAgentService.addKeyToAgent({
+          keyPath: result.keyPath,
+          passphrase: input.passphrase
+        });
+      }
+    } else if (input.sshKeyType === "existing" && input.existingKeyPath) {
+      updatedProfile.keyPath = input.existingKeyPath;
+      updatedProfile.keyAlgorithm = null;
+      updatedProfile.hasPassphrase = false;
+      updatedProfile.passphraseEncrypted = null;
+    }
+  }
+  if (updatedProfile.keyPath) {
+    const configResult = await sshConfigService.updateConfig(updatedProfile);
+    updatedProfile.hostConfigured = configResult.success;
+  }
+  storageService.saveProfile(updatedProfile);
+  logService.addLog(
+    "PROFILE_UPDATED",
+    `Profile "${updatedProfile.name}" updated`,
+    {
+      profileId: updatedProfile.id,
+      provider: updatedProfile.provider
+    },
+    source
+  );
+  return updatedProfile;
+}
+async function deleteProfile(id, source = "app") {
+  const profile = storageService.getProfile(id);
+  if (profile) {
+    await sshConfigService.removeProfileConfig(id);
+    if (profile.sshKeyType === "generated" && profile.keyPath) {
+      sshKeyService.deleteKey(profile.keyPath);
+    }
+    logService.addLog(
+      "PROFILE_DELETED",
+      `Profile "${profile.name}" deleted`,
+      {
+        profileId: profile.id,
+        provider: profile.provider
+      },
+      source
+    );
+  }
+  return storageService.deleteProfile(id);
+}
+function getAllProfiles() {
+  return storageService.getAllProfiles();
+}
+function getProfileById(id) {
+  return storageService.getProfile(id) || null;
+}
+async function switchProfile(id, options = {}, source = "app") {
+  const { setGlobalGit = true } = options;
+  const profile = storageService.getProfile(id);
+  if (!profile) {
+    return { success: false, error: "Profile not found" };
+  }
+  if (profile.keyPath) {
+    const configResult = await sshConfigService.updateConfig(profile);
+    if (configResult.success && !profile.hostConfigured) {
+      profile.hostConfigured = true;
+      storageService.saveProfile(profile);
+    }
+  }
+  let agentLoaded = false;
+  if (profile.keyPath) {
+    const agentResult = await sshAgentService.addKeyToAgent({
+      keyPath: profile.keyPath,
+      passphrase: options.passphrase
+    });
+    agentLoaded = agentResult.success;
+  }
+  let globalGitSet = false;
+  if (setGlobalGit) {
+    try {
+      const { execSync: execSync3 } = await import("child_process");
+      execSync3(`git config --global user.name "${profile.username}"`, {
+        stdio: "pipe"
+      });
+      execSync3(`git config --global user.email "${profile.email}"`, {
+        stdio: "pipe"
+      });
+      globalGitSet = true;
+    } catch {
+      globalGitSet = false;
+    }
+  }
+  const { sshHost } = getProviderSSHConfig(profile.provider);
+  const hostAlias = `${sshHost}-${profile.username}`;
+  const cloneUrlExample = `git@${hostAlias}:<owner>/<repo>.git`;
+  logService.addLog(
+    "PROFILE_SWITCHED",
+    `Switched to profile "${profile.name}"`,
+    {
+      profileId: profile.id,
+      provider: profile.provider,
+      globalGitSet,
+      agentLoaded
+    },
+    source
+  );
+  return {
+    success: true,
+    profile,
+    hostAlias,
+    cloneUrlExample,
+    agentLoaded,
+    globalGitSet
+  };
+}
+async function scanAndSync(source = "app") {
+  try {
+    const allKeys = await sshKeyService.scanAllSSHKeys();
+    const hostMappings = sshConfigService.getAllHostKeyMappings();
+    const existingProfiles = storageService.getAllProfiles();
+    const syncedProfiles = [];
+    const skippedKeys = [];
+    for (const keyInfo of allKeys) {
+      const existingProfile = existingProfiles.find(
+        (p) => p.keyPath === keyInfo.privatePath
+      );
+      if (existingProfile) {
+        skippedKeys.push(keyInfo.privatePath);
+        continue;
+      }
+      const hostMapping = hostMappings.find(
+        (m) => path6.normalize(m.identityFile) === path6.normalize(keyInfo.privatePath)
+      );
+      let username = hostMapping?.username || null;
+      if (!username && keyInfo.email) {
+        username = keyInfo.email.split("@")[0];
+      }
+      if (!username) {
+        username = path6.basename(keyInfo.privatePath);
+      }
+      const email = keyInfo.email || `${username}@local`;
+      const profileName = `${username} (Synced)`;
+      const color = SYNC_COLORS[syncedProfiles.length % SYNC_COLORS.length];
+      const avatar = SYNC_EMOJIS[syncedProfiles.length % SYNC_EMOJIS.length];
+      const profile = {
+        id: (0, import_crypto3.randomUUID)(),
+        name: profileName,
+        email,
+        username,
+        sshKeyType: "existing",
+        keyPath: keyInfo.privatePath,
+        keyAlgorithm: keyInfo.algorithm === "rsa" || keyInfo.algorithm === "ed25519" ? keyInfo.algorithm : null,
+        hasPassphrase: false,
+        passphraseEncrypted: null,
+        hostConfigured: hostMapping ? true : false,
+        avatar,
+        color,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      if (!hostMapping) {
+        await sshConfigService.updateConfig(profile);
+        profile.hostConfigured = true;
+      }
+      storageService.saveProfile(profile);
+      syncedProfiles.push(profile);
+    }
+    if (syncedProfiles.length > 0) {
+      logService.addLog(
+        "PROFILE_CREATED",
+        `Synced ${syncedProfiles.length} profile(s) from SSH keys`,
+        {
+          syncedCount: syncedProfiles.length
+        },
+        source
+      );
+    }
+    return {
+      success: true,
+      syncedCount: syncedProfiles.length,
+      skippedCount: skippedKeys.length,
+      profiles: syncedProfiles
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      syncedCount: 0,
+      skippedCount: 0,
+      profiles: [],
+      error: error2 instanceof Error ? error2.message : "Failed to sync profiles"
+    };
+  }
+}
+
+// src/args.ts
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const body = arg.slice(2);
+      const eq = body.indexOf("=");
+      if (eq >= 0) {
+        flags[body.slice(0, eq)] = body.slice(eq + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          flags[body] = next;
+          i++;
+        } else {
+          flags[body] = true;
+        }
+      }
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const short = arg.slice(1);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        flags[short] = next;
+        i++;
+      } else {
+        flags[short] = true;
+      }
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { positionals, flags };
+}
+function flagStr(flags, ...names) {
+  for (const name of names) {
+    const v = flags[name];
+    if (typeof v === "string") return v;
+  }
+  return void 0;
+}
+function flagBool(flags, ...names) {
+  for (const name of names) {
+    if (flags[name] === true || flags[name] === "true") return true;
+  }
+  return false;
+}
+
+// src/ui.ts
+var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+function wrap(code, str) {
+  return useColor ? `\x1B[${code}m${str}\x1B[0m` : str;
+}
+var c = {
+  bold: (s) => wrap("1", s),
+  dim: (s) => wrap("2", s),
+  red: (s) => wrap("31", s),
+  green: (s) => wrap("32", s),
+  yellow: (s) => wrap("33", s),
+  blue: (s) => wrap("34", s),
+  magenta: (s) => wrap("35", s),
+  cyan: (s) => wrap("36", s),
+  gray: (s) => wrap("90", s)
+};
+var sym = {
+  ok: useColor ? c.green("\u2713") : "[ok]",
+  err: useColor ? c.red("\u2717") : "[x]",
+  warn: useColor ? c.yellow("!") : "[!]",
+  info: useColor ? c.blue("i") : "[i]",
+  arrow: useColor ? c.cyan("\u2192") : "->",
+  dot: c.gray("\u2022")
+};
+function success(msg) {
+  console.log(`${sym.ok} ${msg}`);
+}
+function error(msg) {
+  console.error(`${sym.err} ${c.red(msg)}`);
+}
+function warn(msg) {
+  console.log(`${sym.warn} ${c.yellow(msg)}`);
+}
+function info(msg) {
+  console.log(`${sym.info} ${msg}`);
+}
+function heading(msg) {
+  console.log("\n" + c.bold(msg));
+}
+function table(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(stripLen(h), ...rows.map((r) => stripLen(r[i] ?? "")))
+  );
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - stripLen(s)));
+  const headerLine = headers.map((h, i) => c.bold(pad(h, widths[i]))).join("  ");
+  console.log(headerLine);
+  console.log(c.gray(widths.map((w) => "\u2500".repeat(w)).join("  ")));
+  for (const row of rows) {
+    console.log(row.map((cell, i) => pad(cell ?? "", widths[i])).join("  "));
+  }
+}
+function stripLen(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+
+// src/version.ts
+var import_meta = {};
+function resolveVersion() {
+  if ("1.0.1") {
+    return "1.0.1";
+  }
+  try {
+    const { readFileSync: readFileSync6 } = require("fs");
+    const path8 = new URL("../package.json", import_meta.url);
+    const pkg = JSON.parse(readFileSync6(path8, "utf8"));
+    return pkg.version || "0.0.0-dev";
+  } catch {
+    return "0.0.0-dev";
+  }
+}
+var CLI_VERSION = resolveVersion();
+
+// src/commands/help.ts
+var GENERAL_HELP = `
+${c.bold("devswitch")} ${c.gray("v" + CLI_VERSION)} \u2014 manage multiple Git profiles & SSH keys
+
+${c.bold("USAGE")}
+  devswitch <command> [options]
+
+${c.bold("COMMANDS")}
+  ${c.cyan("list")}                     List all saved profiles            ${c.gray("(alias: ls)")}
+  ${c.cyan("use")} <profile>            Switch to a profile                ${c.gray("(alias: switch)")}
+  ${c.cyan("current")}                  Show the currently active profile  ${c.gray("(alias: whoami)")}
+  ${c.cyan("add")}                      Create a new profile               ${c.gray("(alias: create)")}
+  ${c.cyan("remove")} <profile>         Delete a profile                   ${c.gray("(alias: rm, delete)")}
+  ${c.cyan("show")} <profile>           Show full details of a profile     ${c.gray("(alias: view, info)")}
+  ${c.cyan("sync")}                     Import unmanaged SSH keys as profiles
+  ${c.cyan("test")} <profile>           Test the SSH connection for a profile
+  ${c.cyan("pubkey")} <profile>         Print a profile's public key
+  ${c.cyan("clone")} <url> [dir]        Clone a repo using a profile's identity
+  ${c.cyan("logs")}                     Show recent activity log
+  ${c.cyan("path")}                     Show the shared data directory path
+  ${c.cyan("doctor")}                   Diagnose environment & data store
+  ${c.cyan("help")} [command]           Show help (this screen)
+  ${c.cyan("version")}                  Print the CLI version              ${c.gray("(alias: -v)")}
+
+${c.bold("GLOBAL OPTIONS")}
+  -h, --help               Show help for a command
+  -v, --version            Print version
+  --json                   Output machine-readable JSON where supported
+  --no-color               Disable colored output (or set NO_COLOR=1)
+
+${c.bold("EXAMPLES")}
+  devswitch list
+  devswitch use work
+  devswitch add --name "Work" --email me@work.com --username me --provider github --generate
+  devswitch sync
+  devswitch clone git@github.com:acme/app.git ~/code --profile work
+
+${c.gray("Profiles are shared with the DevSwitch desktop app \u2014 changes here appear there and vice versa.")}
+${c.gray("Run 'devswitch help <command>' for details on a specific command.")}
+`;
+var COMMAND_HELP = {
+  list: `${c.bold("devswitch list")} \u2014 list all saved profiles
+
+USAGE
+  devswitch list [--json]
+
+OPTIONS
+  --json     Print profiles as JSON
+
+Shows each profile's name, username, email, provider, SSH key type, and whether
+its SSH host alias is configured.`,
+  use: `${c.bold("devswitch use")} <profile> \u2014 switch to a profile
+
+USAGE
+  devswitch use <profile> [options]
+
+ARGUMENTS
+  <profile>            Profile name, username, email, or id (partial match ok)
+
+OPTIONS
+  --no-global-git      Do NOT change the global git user.name / user.email
+  --json               Print result as JSON
+
+WHAT IT DOES
+  \u2022 Ensures the profile's Host alias exists in ~/.ssh/config
+  \u2022 Loads the profile's key into ssh-agent
+  \u2022 Sets global git user.name / user.email (unless --no-global-git)
+  \u2022 Prints the clone URL format to use for this profile`,
+  add: `${c.bold("devswitch add")} \u2014 create a new profile
+
+USAGE
+  devswitch add [options]
+
+OPTIONS
+  --name <name>             Friendly profile name
+  --email <email>           Git email
+  --username <username>     Provider username
+  --provider <provider>     github | gitlab | bitbucket | azure | other  (default: github)
+  --default                 Use the default key (~/.ssh/id_ed25519 or id_rsa)
+  --generate                Generate a new SSH key
+  --algorithm <algo>        ed25519 | rsa   (with --generate, default: ed25519)
+  --key-name <name>         Filename for the generated key (with --generate)
+  --passphrase <pass>       Passphrase for the generated key (optional)
+  --existing <path>         Use an existing private key at <path>
+  --avatar <emoji>          Avatar emoji (default \u{1F464})
+  --color <hex>             Accent color (default #3b82f6)
+
+If required values are missing, you'll be prompted interactively.`,
+  remove: `${c.bold("devswitch remove")} <profile> \u2014 delete a profile
+
+USAGE
+  devswitch remove <profile> [--yes] [--json]
+
+ARGUMENTS
+  <profile>     Profile name, username, email, or id
+
+OPTIONS
+  -y, --yes     Skip the confirmation prompt
+
+Removes the profile's ~/.ssh/config entry. Keys generated by DevSwitch are also
+deleted from disk; imported/default keys are left untouched.`,
+  show: `${c.bold("devswitch show")} <profile> \u2014 show full profile details
+
+USAGE
+  devswitch show <profile> [--json]`,
+  sync: `${c.bold("devswitch sync")} \u2014 import unmanaged SSH keys as profiles
+
+USAGE
+  devswitch sync [--json]
+
+Scans ~/.ssh and ~/.ssh/config, then creates profiles for any keys not already
+managed by DevSwitch. Existing profiles are never duplicated.`,
+  test: `${c.bold("devswitch test")} <profile> \u2014 test the SSH connection
+
+USAGE
+  devswitch test <profile> [--json]
+
+Runs 'ssh -T' against the profile's provider host alias using its key.`,
+  clone: `${c.bold("devswitch clone")} <url> [dir] \u2014 clone a repo with a profile's identity
+
+USAGE
+  devswitch clone <repo-url> [destination-dir] --profile <profile>
+
+ARGUMENTS
+  <repo-url>            HTTPS or SSH repository URL
+  [destination-dir]    Folder to clone into (default: current directory)
+
+OPTIONS
+  --profile <profile>  Profile to use (required)
+
+Rewrites the URL to use the profile's SSH host alias and sets the repo's local
+git user.name / user.email.`,
+  pubkey: `${c.bold("devswitch pubkey")} <profile> \u2014 print a profile's SSH public key`,
+  logs: `${c.bold("devswitch logs")} \u2014 show recent activity
+
+USAGE
+  devswitch logs [--limit <n>] [--json]`,
+  path: `${c.bold("devswitch path")} \u2014 print the shared data directory path`,
+  doctor: `${c.bold("devswitch doctor")} \u2014 diagnose environment and data store`,
+  current: `${c.bold("devswitch current")} \u2014 show the active profile (based on global git config)`
+};
+function printHelp(command) {
+  if (command && COMMAND_HELP[command]) {
+    console.log("\n" + COMMAND_HELP[command] + "\n");
+    return;
+  }
+  console.log(GENERAL_HELP);
+}
+
+// src/commands/list.ts
+async function listCommand(args) {
+  const profiles = profileManager_exports.getAllProfiles();
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(profiles, null, 2));
+    return 0;
+  }
+  if (profiles.length === 0) {
+    info(
+      "No profiles yet. Create one with 'devswitch add' or import with 'devswitch sync'."
+    );
+    return 0;
+  }
+  const rows = profiles.map((p) => [
+    p.avatar ? `${p.avatar} ${p.name}` : p.name,
+    p.username,
+    p.email,
+    p.provider || "github",
+    p.keyAlgorithm || p.sshKeyType,
+    p.hostConfigured ? c.green("yes") : c.gray("no")
+  ]);
+  table(["NAME", "USERNAME", "EMAIL", "PROVIDER", "KEY", "SSH CFG"], rows);
+  console.log("");
+  info(
+    `${profiles.length} profile${profiles.length === 1 ? "" : "s"}. Use ${c.cyan("devswitch use <name>")} to switch.`
+  );
+  return 0;
+}
+
+// src/commands/use.ts
+async function useCommand(args) {
+  const identifier = args.positionals[0];
+  if (!identifier) {
+    error("Usage: devswitch use <profile>");
+    return 1;
+  }
+  const profile = storageService.findProfile(identifier);
+  if (!profile) {
+    error(`No profile found matching "${identifier}".`);
+    info("Run 'devswitch list' to see available profiles.");
+    return 1;
+  }
+  const setGlobalGit = !flagBool(args.flags, "no-global-git");
+  const result = await profileManager_exports.switchProfile(
+    profile.id,
+    { setGlobalGit },
+    "cli"
+  );
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.success ? 0 : 1;
+  }
+  if (!result.success) {
+    error(result.error || "Failed to switch profile.");
+    return 1;
+  }
+  success(
+    `Switched to ${c.bold(profile.name)} ${c.gray(`(${profile.username})`)}`
+  );
+  if (result.globalGitSet) {
+    info(`Global git identity set to ${profile.username} <${profile.email}>`);
+  } else if (setGlobalGit) {
+    warn("Could not set global git identity (is git installed?).");
+  }
+  if (result.agentLoaded) {
+    info("SSH key loaded into ssh-agent.");
+  } else {
+    warn(
+      "SSH key was not loaded into ssh-agent (it may be passphrase-protected)."
+    );
+  }
+  console.log("");
+  console.log(`  ${c.gray("Clone repos with:")} ${result.cloneUrlExample}`);
+  return 0;
+}
+
+// src/commands/add.ts
+var fs9 = __toESM(require("fs"), 1);
+
+// src/prompt.ts
+var readline = __toESM(require("readline"), 1);
+var import_stream = require("stream");
+function createInterface2(muted = false) {
+  let muteValue = false;
+  const mutableStdout = new import_stream.Writable({
+    write(chunk, encoding, callback) {
+      if (!muteValue) {
+        process.stdout.write(chunk, encoding);
+      }
+      callback();
+    }
+  });
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: mutableStdout,
+    terminal: true
+  });
+  return {
+    rl,
+    setMuted: (v) => {
+      muteValue = muted ? v : false;
+    }
+  };
+}
+function ask(question, defaultValue) {
+  return new Promise((resolve2) => {
+    const { rl } = createInterface2();
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      resolve2(trimmed || defaultValue || "");
+    });
+  });
+}
+function askSecret(question) {
+  return new Promise((resolve2) => {
+    const { rl, setMuted } = createInterface2(true);
+    rl.question(`${question}: `, (answer) => {
+      rl.close();
+      process.stdout.write("\n");
+      resolve2(answer.trim());
+    });
+    setMuted(true);
+  });
+}
+async function confirm(question, defaultYes = false) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  const answer = (await ask(`${question} [${hint}]`)).toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === "y" || answer === "yes";
+}
+async function select(question, options) {
+  console.log(question);
+  options.forEach((opt, i) => console.log(`  ${i + 1}) ${opt}`));
+  const answer = await ask("Enter choice number");
+  const idx = parseInt(answer, 10) - 1;
+  if (Number.isNaN(idx) || idx < 0 || idx >= options.length) return -1;
+  return idx;
+}
+
+// src/commands/add.ts
+var PROVIDERS = [
+  "github",
+  "gitlab",
+  "bitbucket",
+  "azure",
+  "other"
+];
+async function addCommand(args) {
+  const { flags } = args;
+  const jsonOut = flagBool(flags, "json");
+  const interactive = process.stdin.isTTY && !jsonOut;
+  let name = flagStr(flags, "name");
+  let email = flagStr(flags, "email");
+  let username = flagStr(flags, "username");
+  let provider = flagStr(flags, "provider");
+  if (provider && !PROVIDERS.includes(provider)) {
+    error(
+      `Invalid provider "${provider}". Choose one of: ${PROVIDERS.join(", ")}`
+    );
+    return 1;
+  }
+  if (interactive) {
+    if (!name) name = await ask("Profile name");
+    if (!email) email = await ask("Email");
+    if (!username) username = await ask("Username");
+    if (!provider) {
+      const idx = await select("Git provider:", PROVIDERS);
+      provider = idx >= 0 ? PROVIDERS[idx] : "github";
+    }
+  }
+  provider = provider || "github";
+  if (!name || !email || !username) {
+    error(
+      "Missing required fields. Provide --name, --email and --username (or run interactively)."
+    );
+    return 1;
+  }
+  let sshKeyType = "default";
+  let keyAlgorithm;
+  let keyName;
+  let passphrase;
+  let existingKeyPath;
+  const wantsDefault = flagBool(flags, "default");
+  const wantsGenerate = flagBool(flags, "generate");
+  const existingFlag = flagStr(flags, "existing");
+  if (existingFlag) {
+    sshKeyType = "existing";
+    existingKeyPath = existingFlag;
+  } else if (wantsGenerate) {
+    sshKeyType = "generated";
+  } else if (wantsDefault) {
+    sshKeyType = "default";
+  } else if (interactive) {
+    const idx = await select("SSH key:", [
+      "Use default key (~/.ssh/id_ed25519 or id_rsa)",
+      "Generate a new key",
+      "Use an existing key file"
+    ]);
+    sshKeyType = idx === 1 ? "generated" : idx === 2 ? "existing" : "default";
+  }
+  if (sshKeyType === "generated") {
+    keyAlgorithm = flagStr(flags, "algorithm") || "ed25519";
+    if (keyAlgorithm !== "ed25519" && keyAlgorithm !== "rsa") {
+      error('Invalid --algorithm. Use "ed25519" or "rsa".');
+      return 1;
+    }
+    keyName = flagStr(flags, "key-name");
+    if (!keyName && interactive) {
+      keyName = await ask("Key filename", `id_${username}`);
+    }
+    if (!keyName) {
+      error("Generating a key requires --key-name.");
+      return 1;
+    }
+    passphrase = flagStr(flags, "passphrase");
+    if (passphrase === void 0 && interactive) {
+      const usePass = await confirm(
+        "Protect the key with a passphrase?",
+        false
+      );
+      if (usePass) passphrase = await askSecret("Passphrase");
+    }
+  }
+  if (sshKeyType === "existing") {
+    if (!existingKeyPath && interactive) {
+      existingKeyPath = await ask("Path to existing private key");
+    }
+    if (!existingKeyPath) {
+      error("Using an existing key requires --existing <path>.");
+      return 1;
+    }
+    if (!fs9.existsSync(existingKeyPath)) {
+      error(`Key file not found: ${existingKeyPath}`);
+      return 1;
+    }
+  }
+  const input = {
+    name,
+    email,
+    username,
+    provider,
+    sshKeyType,
+    keyAlgorithm,
+    keyName,
+    passphrase: passphrase || void 0,
+    existingKeyPath,
+    avatar: flagStr(flags, "avatar") || "\u{1F464}",
+    color: flagStr(flags, "color") || "#3b82f6"
+  };
+  try {
+    const profile = await profileManager_exports.createProfile(input, "cli");
+    if (jsonOut) {
+      console.log(JSON.stringify(profile, null, 2));
+      return 0;
+    }
+    success(
+      `Created profile ${c.bold(profile.name)} ${c.gray(`(${profile.username})`)}`
+    );
+    if (profile.keyPath) info(`SSH key: ${profile.keyPath}`);
+    if (profile.hostConfigured) info("SSH config entry added.");
+    console.log("");
+    info(`Activate it with: ${c.cyan(`devswitch use ${profile.username}`)}`);
+    return 0;
+  } catch (err) {
+    error(err instanceof Error ? err.message : "Failed to create profile.");
+    return 1;
+  }
+}
+
+// src/commands/remove.ts
+async function removeCommand(args) {
+  const identifier = args.positionals[0];
+  if (!identifier) {
+    error("Usage: devswitch remove <profile>");
+    return 1;
+  }
+  const profile = storageService.findProfile(identifier);
+  if (!profile) {
+    error(`No profile found matching "${identifier}".`);
+    return 1;
+  }
+  const jsonOut = flagBool(args.flags, "json");
+  const skipConfirm = flagBool(args.flags, "yes", "y");
+  const interactive = process.stdin.isTTY && !jsonOut;
+  if (!skipConfirm && interactive) {
+    const willDeleteKey = profile.sshKeyType === "generated";
+    const extra = willDeleteKey ? ` This will also delete the generated SSH key at ${profile.keyPath}.` : "";
+    const ok = await confirm(
+      `Delete profile "${profile.name}"?${extra}`,
+      false
+    );
+    if (!ok) {
+      info("Cancelled.");
+      return 0;
+    }
+  } else if (!skipConfirm && !interactive) {
+    error("Refusing to delete without confirmation. Re-run with --yes.");
+    return 1;
+  }
+  const deleted = await profileManager_exports.deleteProfile(profile.id, "cli");
+  if (jsonOut) {
+    console.log(JSON.stringify({ success: deleted, id: profile.id }, null, 2));
+    return deleted ? 0 : 1;
+  }
+  if (deleted) {
+    success(`Removed profile ${c.bold(profile.name)}.`);
+    return 0;
+  }
+  error("Failed to remove profile.");
+  return 1;
+}
+
+// src/commands/show.ts
+async function showCommand(args) {
+  const identifier = args.positionals[0];
+  if (!identifier) {
+    error("Usage: devswitch show <profile>");
+    return 1;
+  }
+  const profile = storageService.findProfile(identifier);
+  if (!profile) {
+    error(`No profile found matching "${identifier}".`);
+    return 1;
+  }
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(profile, null, 2));
+    return 0;
+  }
+  const { sshHost } = getProviderSSHConfig(profile.provider);
+  const hostAlias = `${sshHost}-${profile.username}`;
+  const configured = sshConfigService.checkProfileConfigured(profile);
+  heading(`${profile.avatar ? profile.avatar + " " : ""}${profile.name}`);
+  const line = (label, value) => console.log(`  ${c.gray(label.padEnd(14))} ${value}`);
+  line("Username", profile.username);
+  line("Email", profile.email);
+  line("Provider", profile.provider || "github");
+  line("SSH key type", profile.sshKeyType);
+  line("Algorithm", profile.keyAlgorithm || "\u2014");
+  line("Key path", profile.keyPath || "\u2014");
+  line("Passphrase", profile.hasPassphrase ? "yes (encrypted)" : "no");
+  line("Host alias", hostAlias);
+  line(
+    "SSH config",
+    configured ? c.green("configured") : c.yellow("not configured")
+  );
+  if (profile.providerMeta?.connected || profile.githubConnected) {
+    line(
+      "OAuth",
+      c.green(
+        `connected (${profile.providerMeta?.username || profile.githubUsername || "?"})`
+      )
+    );
+  }
+  line("Created", new Date(profile.createdAt).toLocaleString());
+  line("Updated", new Date(profile.updatedAt).toLocaleString());
+  console.log("");
+  console.log(
+    `  ${c.gray("Clone with:")} git clone git@${hostAlias}:<owner>/<repo>.git`
+  );
+  return 0;
+}
+
+// src/commands/sync.ts
+async function syncCommand(args) {
+  const result = await profileManager_exports.scanAndSync("cli");
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.success ? 0 : 1;
+  }
+  if (!result.success) {
+    error(result.error || "Sync failed.");
+    return 1;
+  }
+  if (result.syncedCount > 0) {
+    success(
+      `Synced ${c.bold(String(result.syncedCount))} new profile${result.syncedCount === 1 ? "" : "s"}.`
+    );
+    for (const p of result.profiles) {
+      console.log(`  ${c.gray("\u2022")} ${p.name} ${c.gray(`(${p.keyPath})`)}`);
+    }
+  } else {
+    info("No new profiles to sync. All SSH keys are already managed.");
+  }
+  if (result.skippedCount > 0) {
+    info(
+      `Skipped ${result.skippedCount} already-managed key${result.skippedCount === 1 ? "" : "s"}.`
+    );
+  }
+  return 0;
+}
+
+// src/commands/test.ts
+async function testCommand(args) {
+  const identifier = args.positionals[0];
+  if (!identifier) {
+    error("Usage: devswitch test <profile>");
+    return 1;
+  }
+  const profile = storageService.findProfile(identifier);
+  if (!profile) {
+    error(`No profile found matching "${identifier}".`);
+    return 1;
+  }
+  const { sshHost, sshUser } = getProviderSSHConfig(profile.provider);
+  const hostAlias = `${sshHost}-${profile.username}`;
+  if (profile.keyPath) {
+    await sshConfigService.updateConfig(profile);
+  }
+  const jsonOut = flagBool(args.flags, "json");
+  if (!jsonOut)
+    info(
+      `Testing SSH connection for ${c.bold(profile.name)} via ${hostAlias}...`
+    );
+  const result = await testSSHConnection({
+    hostAlias,
+    sshUser,
+    keyPath: profile.keyPath || void 0
+  });
+  if (jsonOut) {
+    console.log(
+      JSON.stringify({ profile: profile.name, hostAlias, ...result }, null, 2)
+    );
+    return result.success ? 0 : 1;
+  }
+  if (result.success) {
+    success("Authentication succeeded.");
+    if (result.output) console.log(c.gray(result.output));
+    return 0;
+  }
+  error("Authentication failed.");
+  if (result.output) console.log(c.gray(result.output));
+  if (result.error) console.log(c.gray(result.error));
+  return 1;
+}
+
+// src/commands/pubkey.ts
+async function pubkeyCommand(args) {
+  const identifier = args.positionals[0];
+  if (!identifier) {
+    error("Usage: devswitch pubkey <profile>");
+    return 1;
+  }
+  const profile = storageService.findProfile(identifier);
+  if (!profile) {
+    error(`No profile found matching "${identifier}".`);
+    return 1;
+  }
+  if (!profile.keyPath) {
+    error("This profile has no associated SSH key.");
+    return 1;
+  }
+  const content = sshKeyService.getPublicKeyContent(profile.keyPath);
+  if (!content) {
+    error(`Public key not found for ${profile.keyPath}.pub`);
+    return 1;
+  }
+  console.log(content);
+  return 0;
+}
+
+// src/commands/clone.ts
+var path7 = __toESM(require("path"), 1);
+async function cloneCommand(args) {
+  const repoUrl = args.positionals[0];
+  const destination = args.positionals[1] || process.cwd();
+  if (!repoUrl) {
+    error(
+      "Usage: devswitch clone <repo-url> [destination-dir] --profile <profile>"
+    );
+    return 1;
+  }
+  const profileId = flagStr(args.flags, "profile", "p");
+  if (!profileId) {
+    error("A profile is required. Pass --profile <name>.");
+    return 1;
+  }
+  const profile = storageService.findProfile(profileId);
+  if (!profile) {
+    error(`No profile found matching "${profileId}".`);
+    return 1;
+  }
+  const { sshHost } = getProviderSSHConfig(profile.provider);
+  const hostAlias = `${sshHost}-${profile.username}`;
+  const jsonOut = flagBool(args.flags, "json");
+  if (!jsonOut) {
+    info(
+      `Cloning ${repoUrl} into ${path7.resolve(destination)} as ${c.bold(profile.name)}...`
+    );
+  }
+  const result = await gitService.cloneRepository({
+    repoUrl,
+    destinationFolder: destination,
+    username: profile.username,
+    email: profile.email,
+    hostAlias
+  });
+  if (jsonOut) {
+    console.log(JSON.stringify(result, null, 2));
+    return result.success ? 0 : 1;
+  }
+  if (result.success) {
+    success(`Cloned to ${result.clonedPath}`);
+    info(`Local git identity set to ${profile.username} <${profile.email}>`);
+    return 0;
+  }
+  error(result.error || "Clone failed.");
+  return 1;
+}
+
+// src/commands/logs.ts
+async function logsCommand(args) {
+  const limitStr = flagStr(args.flags, "limit", "n");
+  const limit = limitStr ? parseInt(limitStr, 10) : 20;
+  const logs = logService.getAllLogs().slice(0, Number.isNaN(limit) ? 20 : limit);
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(logs, null, 2));
+    return 0;
+  }
+  if (logs.length === 0) {
+    info("No activity logged yet.");
+    return 0;
+  }
+  for (const log of logs) {
+    const time = new Date(log.timestamp).toLocaleString();
+    const src = log.source === "cli" ? c.magenta("[cli]") : c.blue("[app]");
+    console.log(`${c.gray(time)} ${src} ${c.cyan(log.action)}  ${log.message}`);
+  }
+  return 0;
+}
+
+// src/commands/path.ts
+async function pathCommand(args) {
+  const data = {
+    dataDir: getDataDir(),
+    profiles: getProfilesFilePath(),
+    logs: getLogsFilePath()
+  };
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(data, null, 2));
+    return 0;
+  }
+  console.log(`${c.gray("Data dir:")} ${data.dataDir}`);
+  console.log(`${c.gray("Profiles:")} ${data.profiles}`);
+  console.log(`${c.gray("Logs:    ")} ${data.logs}`);
+  return 0;
+}
+
+// src/commands/doctor.ts
+var fs10 = __toESM(require("fs"), 1);
+var import_child_process5 = require("child_process");
+function checkCmd(cmd) {
+  try {
+    return (0, import_child_process5.execSync)(cmd, {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8"
+    }).trim().split("\n")[0];
+  } catch {
+    return null;
+  }
+}
+async function doctorCommand(args) {
+  const dataDir = getDataDir();
+  const profilesPath = getProfilesFilePath();
+  const profiles = storageService.getAllProfiles();
+  const git = checkCmd("git --version");
+  const sshKeygen = checkCmd("ssh-keygen --help 2>&1 | head -1") || checkCmd("which ssh-keygen");
+  const sshAdd = checkCmd("ssh-add -l");
+  const checks = {
+    cliVersion: CLI_VERSION,
+    node: process.version,
+    dataDir,
+    dataDirExists: fs10.existsSync(dataDir),
+    profilesFile: profilesPath,
+    profilesFileExists: fs10.existsSync(profilesPath),
+    profileCount: profiles.length,
+    git: git || null,
+    sshKeygenAvailable: !!sshKeygen,
+    sshAgentRunning: sshAdd !== null
+  };
+  if (flagBool(args.flags, "json")) {
+    console.log(JSON.stringify(checks, null, 2));
+    return 0;
+  }
+  heading("DevSwitch CLI \u2014 doctor");
+  const row = (ok, label, detail) => console.log(
+    `  ${ok ? sym.ok : sym.warn} ${label.padEnd(22)} ${c.gray(detail)}`
+  );
+  row(true, "CLI version", CLI_VERSION);
+  row(true, "Node", process.version);
+  row(
+    checks.dataDirExists,
+    "Shared data dir",
+    dataDir + (checks.dataDirExists ? "" : " (will be created)")
+  );
+  row(
+    checks.profilesFileExists,
+    "Profiles file",
+    checks.profilesFileExists ? profilesPath : "not created yet"
+  );
+  row(true, "Profiles stored", String(checks.profileCount));
+  row(!!git, "git", git || "not found in PATH");
+  row(!!sshKeygen, "ssh-keygen", sshKeygen ? "available" : "not found");
+  row(
+    checks.sshAgentRunning,
+    "ssh-agent",
+    checks.sshAgentRunning ? "reachable" : "not running / unreachable"
+  );
+  const notConfigured = profiles.filter(
+    (p) => p.keyPath && !sshConfigService.checkProfileConfigured(p) && p.sshKeyType !== "default"
+  );
+  if (notConfigured.length > 0) {
+    console.log("");
+    console.log(
+      `  ${sym.warn} ${notConfigured.length} profile(s) missing SSH config entries:`
+    );
+    for (const p of notConfigured)
+      console.log(
+        `      ${c.gray("\u2022")} ${p.name} \u2014 run 'devswitch use ${p.username}'`
+      );
+  }
+  console.log("");
+  return 0;
+}
+
+// src/commands/current.ts
+async function currentCommand(args) {
+  const gitConfig = await sshConfigService.getGlobalGitConfig();
+  const email = gitConfig["user.email"];
+  const name = gitConfig["user.name"];
+  const profiles = storageService.getAllProfiles();
+  const match = profiles.find(
+    (p) => email && p.email.toLowerCase() === email.toLowerCase()
+  ) || profiles.find(
+    (p) => name && p.username.toLowerCase() === name.toLowerCase()
+  );
+  if (flagBool(args.flags, "json")) {
+    console.log(
+      JSON.stringify(
+        {
+          globalGit: { name: name || null, email: email || null },
+          activeProfile: match || null
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  console.log(
+    `${c.gray("Global git user:")} ${name || c.gray("unset")} <${email || c.gray("unset")}>`
+  );
+  if (match) {
+    console.log(
+      `${c.gray("Active profile: ")} ${match.avatar ? match.avatar + " " : ""}${c.bold(match.name)} ${c.gray(`(${match.provider || "github"})`)}`
+    );
+  } else {
+    info(
+      "No DevSwitch profile matches the current global git identity. Use 'devswitch use <profile>' to switch."
+    );
+  }
+  return 0;
+}
+
+// src/index.ts
+logService.setDefaultSource("cli");
+var COMMANDS = {
+  list: listCommand,
+  ls: listCommand,
+  use: useCommand,
+  switch: useCommand,
+  add: addCommand,
+  create: addCommand,
+  new: addCommand,
+  remove: removeCommand,
+  rm: removeCommand,
+  delete: removeCommand,
+  show: showCommand,
+  view: showCommand,
+  info: showCommand,
+  sync: syncCommand,
+  test: testCommand,
+  pubkey: pubkeyCommand,
+  clone: cloneCommand,
+  logs: logsCommand,
+  log: logsCommand,
+  path: pathCommand,
+  doctor: doctorCommand,
+  current: currentCommand,
+  whoami: currentCommand
+};
+async function main() {
+  const argv = process.argv.slice(2);
+  const [command, ...rest] = argv;
+  if (!command || command === "help") {
+    printHelp(rest[0]);
+    return 0;
+  }
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(CLI_VERSION);
+    return 0;
+  }
+  const parsed = parseArgs(rest);
+  if (flagBool(parsed.flags, "help", "h")) {
+    printHelp(command);
+    return 0;
+  }
+  const handler = COMMANDS[command];
+  if (!handler) {
+    error(`Unknown command: "${command}"`);
+    printHelp();
+    return 1;
+  }
+  return handler(parsed);
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  error(err instanceof Error ? err.message : String(err));
+  if (process.env.DEVSWITCH_DEBUG) console.error(err);
+  process.exit(1);
+});