@siamriaz/octomux 1.0.0

package/dist/chunk-3NCQOE6V.js

@@ -0,0 +1,1957 @@
+// src/index.ts
+import { Command } from "commander";
+import * as p5 from "@clack/prompts";
+import pc8 from "picocolors";
+
+// src/commands/account/add.ts
+import ora from "ora";
+
+// src/core/account-manager.ts
+import fs4 from "fs";
+
+// src/core/config-store.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/platform/paths.ts
+import os from "os";
+import path from "path";
+function getHomeDir() {
+  return os.homedir();
+}
+function getOctomuxDir() {
+  return path.join(getHomeDir(), ".octomux");
+}
+function getConfigFilePath() {
+  return path.join(getOctomuxDir(), "config.json");
+}
+function getSshDir() {
+  return path.join(getHomeDir(), ".ssh");
+}
+function getSshConfigPath() {
+  return path.join(getSshDir(), "config");
+}
+function getDefaultKeyPath(alias, keyType = "ed25519") {
+  const filename = `id_${keyType}_octomux_${alias}`;
+  return path.join(getSshDir(), filename);
+}
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+// src/types/config.ts
+import { z as z2 } from "zod";
+
+// src/types/account.ts
+import { z } from "zod";
+var SshKeyTypeSchema = z.enum(["ed25519", "rsa"]);
+var SshKeyDetailsSchema = z.object({
+  keyPath: z.string().min(1, "Private key path is required"),
+  publicKeyPath: z.string().min(1, "Public key path is required"),
+  hostAlias: z.string().min(1, "SSH Host alias is required"),
+  keyType: SshKeyTypeSchema.default("ed25519")
+});
+var AccountProfileSchema = z.object({
+  id: z.string().min(1, "Account alias ID is required").regex(/^[a-z0-9-_]+$/i, "Alias must contain only alphanumeric characters, dashes, or underscores"),
+  name: z.string().min(1, "Display name is required"),
+  username: z.string().min(1, "GitHub username is required"),
+  email: z.string().email("Invalid email address"),
+  gitUserName: z.string().min(1, "Git author name is required"),
+  ssh: SshKeyDetailsSchema,
+  signingKey: z.string().optional(),
+  token: z.string().optional(),
+  isDefaultGlobal: z.boolean().default(false),
+  createdAt: z.string().datetime().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  updatedAt: z.string().datetime().default(() => (/* @__PURE__ */ new Date()).toISOString())
+});
+var CreateAccountInputSchema = z.object({
+  id: z.string().min(1, "Alias is required").regex(/^[a-z0-9-_]+$/i, "Alias must contain only letters, numbers, dashes, or underscores"),
+  name: z.string().optional(),
+  username: z.string().min(1, "GitHub username is required"),
+  email: z.string().email("Valid email is required"),
+  gitUserName: z.string().optional(),
+  sshKeyPath: z.string().optional(),
+  generateKey: z.boolean().default(true),
+  keyType: SshKeyTypeSchema.default("ed25519"),
+  hostAlias: z.string().optional(),
+  token: z.string().optional(),
+  setAsGlobal: z.boolean().default(false)
+});
+var UpdateAccountInputSchema = z.object({
+  name: z.string().optional(),
+  username: z.string().optional(),
+  email: z.string().email().optional(),
+  gitUserName: z.string().optional(),
+  sshKeyPath: z.string().optional(),
+  hostAlias: z.string().optional(),
+  token: z.string().optional()
+});
+
+// src/types/config.ts
+var OctomuxConfigSchema = z2.object({
+  version: z2.string().default("1.0.0"),
+  activeGlobalAccount: z2.string().optional(),
+  defaultCloneProtocol: z2.enum(["ssh", "https"]).default("ssh"),
+  accounts: z2.record(z2.string(), AccountProfileSchema).default({})
+});
+var DEFAULT_CONFIG = {
+  version: "1.0.0",
+  defaultCloneProtocol: "ssh",
+  accounts: {}
+};
+
+// src/core/config-store.ts
+var ConfigStore = class {
+  configPath;
+  constructor(customConfigPath) {
+    this.configPath = customConfigPath ?? getConfigFilePath();
+  }
+  /**
+   * Returns the config file path being managed.
+   */
+  getPath() {
+    return this.configPath;
+  }
+  /**
+   * Loads and validates the octomux configuration.
+   * If file does not exist, creates it with DEFAULT_CONFIG.
+   */
+  load() {
+    if (!fs.existsSync(this.configPath)) {
+      this.save(DEFAULT_CONFIG);
+      return { ...DEFAULT_CONFIG };
+    }
+    try {
+      const raw = fs.readFileSync(this.configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const validated = OctomuxConfigSchema.parse(parsed);
+      return validated;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Corrupted config file at ${this.configPath}: Invalid JSON format.`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Atomically saves the configuration with backup creation.
+   */
+  save(config) {
+    const validated = OctomuxConfigSchema.parse(config);
+    const dir = path2.dirname(this.configPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (fs.existsSync(this.configPath)) {
+      const backupPath = `${this.configPath}.bak`;
+      try {
+        fs.copyFileSync(this.configPath, backupPath);
+      } catch {
+      }
+    }
+    const tempPath = `${this.configPath}.${Date.now()}.tmp`;
+    const serialized = JSON.stringify(validated, null, 2);
+    fs.writeFileSync(tempPath, serialized, "utf-8");
+    fs.renameSync(tempPath, this.configPath);
+  }
+  /**
+   * Retrieves all configured account profiles.
+   */
+  getAccounts() {
+    const config = this.load();
+    return config.accounts;
+  }
+  /**
+   * Retrieves a single account profile by its alias.
+   */
+  getAccount(alias) {
+    const accounts = this.getAccounts();
+    return accounts[alias];
+  }
+  /**
+   * Saves or updates an account profile.
+   */
+  setAccount(account) {
+    const config = this.load();
+    config.accounts[account.id] = account;
+    if (account.isDefaultGlobal) {
+      config.activeGlobalAccount = account.id;
+      for (const [id, acc] of Object.entries(config.accounts)) {
+        if (id !== account.id) {
+          acc.isDefaultGlobal = false;
+        }
+      }
+    }
+    this.save(config);
+  }
+  /**
+   * Removes an account profile by alias.
+   */
+  removeAccount(alias) {
+    const config = this.load();
+    if (!config.accounts[alias]) {
+      return false;
+    }
+    delete config.accounts[alias];
+    if (config.activeGlobalAccount === alias) {
+      delete config.activeGlobalAccount;
+    }
+    this.save(config);
+    return true;
+  }
+  /**
+   * Sets the active global account alias.
+   */
+  setActiveGlobal(alias) {
+    const config = this.load();
+    if (!config.accounts[alias]) {
+      throw new Error(`Cannot set active global account: Profile '${alias}' does not exist.`);
+    }
+    config.activeGlobalAccount = alias;
+    for (const [id, acc] of Object.entries(config.accounts)) {
+      acc.isDefaultGlobal = id === alias;
+    }
+    this.save(config);
+  }
+  /**
+   * Gets the active global account profile if one is set.
+   */
+  getActiveGlobal() {
+    const config = this.load();
+    if (!config.activeGlobalAccount) {
+      return void 0;
+    }
+    return config.accounts[config.activeGlobalAccount];
+  }
+};
+
+// src/core/ssh-service.ts
+import fs3 from "fs";
+import path3 from "path";
+import { execa } from "execa";
+
+// src/platform/permissions.ts
+import fs2 from "fs";
+import os2 from "os";
+function setPrivateKeyPermissions(filePath) {
+  if (os2.platform() === "win32") {
+    return;
+  }
+  try {
+    if (fs2.existsSync(filePath)) {
+      fs2.chmodSync(filePath, 384);
+    }
+  } catch {
+  }
+}
+function setSshDirPermissions(dirPath) {
+  if (os2.platform() === "win32") {
+    return;
+  }
+  try {
+    if (fs2.existsSync(dirPath)) {
+      fs2.chmodSync(dirPath, 448);
+    }
+  } catch {
+  }
+}
+
+// src/core/ssh-service.ts
+var OCTOMUX_BLOCK_START = "# === OCTOMUX MANAGED HOSTS: START ===";
+var OCTOMUX_BLOCK_END = "# === OCTOMUX MANAGED HOSTS: END ===";
+var SshService = class {
+  sshConfigPath;
+  sshDir;
+  constructor(customSshConfigPath, customSshDir) {
+    this.sshConfigPath = customSshConfigPath ?? getSshConfigPath();
+    this.sshDir = customSshDir ?? getSshDir();
+  }
+  getSshConfigPath() {
+    return this.sshConfigPath;
+  }
+  getSshDir() {
+    return this.sshDir;
+  }
+  /**
+   * Scans ~/.ssh directory for existing private SSH keys created by the user or system.
+   */
+  scanExistingSshKeys() {
+    if (!fs3.existsSync(this.sshDir)) {
+      return [];
+    }
+    const ignoredFiles = /* @__PURE__ */ new Set([
+      "config",
+      "config.bak",
+      "known_hosts",
+      "known_hosts.old",
+      "authorized_keys"
+    ]);
+    const discovered = [];
+    const entries = fs3.readdirSync(this.sshDir);
+    for (const filename of entries) {
+      if (filename.endsWith(".pub") || filename.endsWith(".tmp") || filename.endsWith(".bak")) {
+        continue;
+      }
+      if (ignoredFiles.has(filename.toLowerCase())) {
+        continue;
+      }
+      const privatePath = path3.join(this.sshDir, filename);
+      const stat = fs3.statSync(privatePath);
+      if (!stat.isFile()) {
+        continue;
+      }
+      const pubPath = `${privatePath}.pub`;
+      const hasPub = fs3.existsSync(pubPath);
+      let keyType = "unknown";
+      let comment;
+      if (hasPub) {
+        try {
+          const pubContent = fs3.readFileSync(pubPath, "utf-8").trim();
+          const parts = pubContent.split(/\s+/);
+          if (parts.length >= 1 && parts[0]) {
+            if (parts[0].includes("ed25519")) keyType = "ed25519";
+            else if (parts[0].includes("rsa")) keyType = "rsa";
+            else if (parts[0].includes("ecdsa")) keyType = "ecdsa";
+          }
+          if (parts.length >= 3) {
+            comment = parts.slice(2).join(" ");
+          }
+        } catch {
+        }
+      } else {
+        if (filename.includes("ed25519")) keyType = "ed25519";
+        else if (filename.includes("rsa")) keyType = "rsa";
+        else if (filename.includes("ecdsa")) keyType = "ecdsa";
+      }
+      discovered.push({
+        name: filename,
+        privateKeyPath: privatePath,
+        publicKeyPath: hasPub ? pubPath : void 0,
+        keyType,
+        comment,
+        isOctomuxManaged: filename.includes("_octomux_")
+      });
+    }
+    return discovered;
+  }
+  /**
+   * Generates a new SSH key pair using ssh-keygen.
+   */
+  async generateKeyPair(email, targetKeyPath, keyType = "ed25519", comment) {
+    const parentDir = path3.dirname(targetKeyPath);
+    if (!fs3.existsSync(parentDir)) {
+      fs3.mkdirSync(parentDir, { recursive: true });
+      setSshDirPermissions(parentDir);
+    }
+    if (fs3.existsSync(targetKeyPath)) {
+      throw new Error(`SSH Key already exists at: ${targetKeyPath}`);
+    }
+    const keyComment = comment || `octomux-${email}`;
+    const args = ["-t", keyType, "-C", keyComment, "-f", targetKeyPath, "-N", ""];
+    if (keyType === "rsa") {
+      args.push("-b", "4096");
+    }
+    try {
+      await execa("ssh-keygen", args);
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to generate SSH key with ssh-keygen: ${errorMsg}`);
+    }
+    setPrivateKeyPermissions(targetKeyPath);
+    const publicKeyPath = `${targetKeyPath}.pub`;
+    let publicKeyContent = "";
+    if (fs3.existsSync(publicKeyPath)) {
+      publicKeyContent = fs3.readFileSync(publicKeyPath, "utf-8").trim();
+    }
+    return {
+      privateKeyPath: targetKeyPath,
+      publicKeyPath,
+      publicKeyContent
+    };
+  }
+  /**
+   * Reads an existing public key associated with a private key.
+   */
+  getPublicKey(privateKeyPath) {
+    const pubPath = `${privateKeyPath}.pub`;
+    if (fs3.existsSync(pubPath)) {
+      return fs3.readFileSync(pubPath, "utf-8").trim();
+    }
+    return void 0;
+  }
+  /**
+   * Generates formatted SSH config block content for an array of host entries.
+   */
+  formatHostEntries(hosts) {
+    const lines = [
+      OCTOMUX_BLOCK_START,
+      "# This block is automatically managed by octomux (omx).",
+      "# Manual changes inside this block will be overwritten.",
+      ""
+    ];
+    for (const host of hosts) {
+      const posixKeyPath = toPosixPath(host.identityFile);
+      lines.push(`Host ${host.host}`);
+      lines.push(`    HostName ${host.hostName}`);
+      lines.push(`    User ${host.user}`);
+      lines.push(`    IdentityFile "${posixKeyPath}"`);
+      lines.push(`    IdentitiesOnly ${host.identitiesOnly !== false ? "yes" : "no"}`);
+      if (host.extraOptions) {
+        for (const [key, val] of Object.entries(host.extraOptions)) {
+          lines.push(`    ${key} ${val}`);
+        }
+      }
+      lines.push("");
+    }
+    lines.push(OCTOMUX_BLOCK_END);
+    return lines.join("\n");
+  }
+  /**
+   * Safely synchronizes octomux host entries into ~/.ssh/config.
+   * Preserves all user configurations outside of the octomux delimiters.
+   */
+  syncSshConfig(hosts) {
+    const dir = path3.dirname(this.sshConfigPath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+      setSshDirPermissions(dir);
+    }
+    let existingContent = "";
+    if (fs3.existsSync(this.sshConfigPath)) {
+      existingContent = fs3.readFileSync(this.sshConfigPath, "utf-8");
+      try {
+        fs3.copyFileSync(this.sshConfigPath, `${this.sshConfigPath}.bak`);
+      } catch {
+      }
+    }
+    const newBlock = this.formatHostEntries(hosts);
+    let updatedContent = "";
+    const startIndex = existingContent.indexOf(OCTOMUX_BLOCK_START);
+    const endIndex = existingContent.indexOf(OCTOMUX_BLOCK_END);
+    if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+      const before = existingContent.slice(0, startIndex).trimEnd();
+      const after = existingContent.slice(endIndex + OCTOMUX_BLOCK_END.length).trimStart();
+      const parts = [];
+      if (before.length > 0) parts.push(before);
+      parts.push(newBlock);
+      if (after.length > 0) parts.push(after);
+      updatedContent = parts.join("\n\n") + "\n";
+    } else {
+      const trimmed = existingContent.trim();
+      updatedContent = trimmed ? `${trimmed}
+
+${newBlock}
+` : `${newBlock}
+`;
+    }
+    const tempFile = `${this.sshConfigPath}.${Date.now()}.tmp`;
+    fs3.writeFileSync(tempFile, updatedContent, "utf-8");
+    setPrivateKeyPermissions(tempFile);
+    fs3.renameSync(tempFile, this.sshConfigPath);
+    setPrivateKeyPermissions(this.sshConfigPath);
+  }
+  /**
+   * Tests SSH connection to a GitHub host alias.
+   * Note: GitHub returns exit code 1 with success greeting on SSH -T.
+   */
+  async testConnection(hostAlias, username = "User") {
+    try {
+      const { stdout, stderr } = await execa(
+        "ssh",
+        [
+          "-T",
+          "-o",
+          "BatchMode=yes",
+          "-o",
+          "StrictHostKeyChecking=accept-new",
+          "-o",
+          "ConnectTimeout=8",
+          `git@${hostAlias}`
+        ],
+        { reject: false }
+      );
+      const output = `${stdout}
+${stderr}`.trim();
+      const isAuthenticated = output.includes("successfully authenticated") || output.toLowerCase().includes(`hi ${username.toLowerCase()}`);
+      return {
+        accountAlias: hostAlias.replace(/^github\.com-/, ""),
+        hostAlias,
+        username,
+        authenticated: isAuthenticated,
+        rawOutput: output,
+        error: isAuthenticated ? void 0 : output
+      };
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      return {
+        accountAlias: hostAlias.replace(/^github\.com-/, ""),
+        hostAlias,
+        username,
+        authenticated: false,
+        rawOutput: "",
+        error: errorMsg
+      };
+    }
+  }
+};
+
+// src/core/git-service.ts
+import { execa as execa2 } from "execa";
+var GitService = class {
+  /**
+   * Checks if git is installed and available in PATH.
+   */
+  async isGitInstalled() {
+    try {
+      const { exitCode } = await execa2("git", ["--version"]);
+      return exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Checks if the given directory (or current working directory) is inside a Git repository.
+   */
+  async isInsideGitRepo(cwd) {
+    try {
+      const { stdout } = await execa2("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
+      return stdout.trim() === "true";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gets the root directory of the current Git repository.
+   */
+  async getRepoRoot(cwd) {
+    try {
+      const { stdout } = await execa2("git", ["rev-parse", "--show-toplevel"], { cwd });
+      return stdout.trim();
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Reads Git identity (user.name, user.email, core.sshCommand) for a given scope.
+   */
+  async getIdentity(scope, cwd) {
+    const flag = scope === "global" ? "--global" : "--local";
+    const identity = {};
+    try {
+      const { stdout: name } = await execa2("git", ["config", flag, "--get", "user.name"], { cwd, reject: false });
+      if (name.trim()) identity.name = name.trim();
+    } catch {
+    }
+    try {
+      const { stdout: email } = await execa2("git", ["config", flag, "--get", "user.email"], { cwd, reject: false });
+      if (email.trim()) identity.email = email.trim();
+    } catch {
+    }
+    try {
+      const { stdout: sshCmd } = await execa2("git", ["config", flag, "--get", "core.sshCommand"], { cwd, reject: false });
+      if (sshCmd.trim()) identity.sshCommand = sshCmd.trim();
+    } catch {
+    }
+    return identity;
+  }
+  /**
+   * Sets global Git identity.
+   */
+  async setGlobalIdentity(name, email) {
+    await execa2("git", ["config", "--global", "user.name", name]);
+    await execa2("git", ["config", "--global", "user.email", email]);
+  }
+  /**
+   * Sets local Git identity and dedicated SSH command in a repository.
+   */
+  async setLocalIdentity(name, email, sshKeyPath, cwd) {
+    const isRepo = await this.isInsideGitRepo(cwd);
+    if (!isRepo) {
+      throw new Error(`Current directory is not inside a Git repository.`);
+    }
+    await execa2("git", ["config", "--local", "user.name", name], { cwd });
+    await execa2("git", ["config", "--local", "user.email", email], { cwd });
+    if (sshKeyPath) {
+      const posixKey = toPosixPath(sshKeyPath);
+      const sshCommand = `ssh -i "${posixKey}" -o IdentitiesOnly=yes`;
+      await execa2("git", ["config", "--local", "core.sshCommand", sshCommand], { cwd });
+    }
+  }
+  /**
+   * Parses GitHub URLs, SSH strings, or owner/repo shorthand slugs.
+   */
+  parseRepoInput(input) {
+    const trimmed = input.trim();
+    const slugMatch = /^([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)$/.exec(trimmed);
+    if (slugMatch && slugMatch[1] && slugMatch[2]) {
+      const repo = slugMatch[2].replace(/\.git$/, "");
+      return { owner: slugMatch[1], repo, originalUrl: trimmed };
+    }
+    const httpsMatch = /^https?:\/\/github\.com\/([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(\.git)?(?:\/)?$/.exec(trimmed);
+    if (httpsMatch && httpsMatch[1] && httpsMatch[2]) {
+      return { owner: httpsMatch[1], repo: httpsMatch[2], originalUrl: trimmed };
+    }
+    const sshMatch = /^git@([a-zA-Z0-9_.-]+):([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+?)(\.git)?$/.exec(trimmed);
+    if (sshMatch && sshMatch[2] && sshMatch[3]) {
+      return { owner: sshMatch[2], repo: sshMatch[3], originalUrl: trimmed };
+    }
+    return null;
+  }
+  /**
+   * Constructs an SSH clone URL using a specific SSH host alias.
+   */
+  formatSshCloneUrl(hostAlias, owner, repo) {
+    return `git@${hostAlias}:${owner}/${repo}.git`;
+  }
+  /**
+   * Executes git clone with real-time output streaming or promise resolution.
+   */
+  async clone(cloneUrl, targetDir, extraArgs = []) {
+    const args = ["clone", cloneUrl];
+    if (targetDir) {
+      args.push(targetDir);
+    }
+    args.push(...extraArgs);
+    await execa2("git", args, { stdio: "inherit" });
+    if (targetDir) {
+      return targetDir;
+    }
+    const match = /\/([^/]+?)(\.git)?$/.exec(cloneUrl);
+    return match && match[1] ? match[1] : "repository";
+  }
+  /**
+   * Gets the current remote URL for a repository (origin by default).
+   */
+  async getRemoteUrl(remote = "origin", cwd) {
+    try {
+      const { stdout } = await execa2("git", ["remote", "get-url", remote], { cwd });
+      return stdout.trim();
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Sets the remote URL for a repository (or adds it if not existing).
+   */
+  async setRemoteUrl(remote, url, cwd) {
+    await execa2("git", ["remote", "set-url", remote, url], { cwd });
+  }
+  /**
+   * Adds a new remote to the repository.
+   */
+  async addRemoteUrl(remote, url, cwd) {
+    await execa2("git", ["remote", "add", remote, url], { cwd });
+  }
+  /**
+   * Initializes a new Git repository if not already initialized.
+   */
+  async initRepo(cwd) {
+    await execa2("git", ["init"], { cwd });
+  }
+};
+
+// src/core/account-manager.ts
+var AccountManager = class {
+  configStore;
+  sshService;
+  gitService;
+  constructor(configStore, sshService, gitService) {
+    this.configStore = configStore ?? new ConfigStore();
+    this.sshService = sshService ?? new SshService();
+    this.gitService = gitService ?? new GitService();
+  }
+  /**
+   * Adds a new GitHub account profile, sets up SSH key and configures SSH hosts.
+   */
+  async addAccount(input) {
+    const validatedInput = CreateAccountInputSchema.parse(input);
+    const existing = this.configStore.getAccount(validatedInput.id);
+    if (existing) {
+      throw new Error(`An account with alias '${validatedInput.id}' already exists.`);
+    }
+    const hostAlias = validatedInput.hostAlias || `github.com-${validatedInput.id}`;
+    let privateKeyPath = validatedInput.sshKeyPath;
+    let publicKeyPath = "";
+    if (validatedInput.generateKey || !privateKeyPath) {
+      const defaultKeyPath = getDefaultKeyPath(validatedInput.id, validatedInput.keyType);
+      const keyGenResult = await this.sshService.generateKeyPair(
+        validatedInput.email,
+        defaultKeyPath,
+        validatedInput.keyType,
+        `octomux-${validatedInput.id}`
+      );
+      privateKeyPath = keyGenResult.privateKeyPath;
+      publicKeyPath = keyGenResult.publicKeyPath;
+    } else {
+      if (!fs4.existsSync(privateKeyPath)) {
+        throw new Error(`Specified private SSH key does not exist at: ${privateKeyPath}`);
+      }
+      publicKeyPath = `${privateKeyPath}.pub`;
+      if (!fs4.existsSync(publicKeyPath)) {
+        publicKeyPath = privateKeyPath;
+      }
+    }
+    const profile = AccountProfileSchema.parse({
+      id: validatedInput.id,
+      name: validatedInput.name || validatedInput.username,
+      username: validatedInput.username,
+      email: validatedInput.email,
+      gitUserName: validatedInput.gitUserName || validatedInput.username,
+      ssh: {
+        keyPath: privateKeyPath,
+        publicKeyPath,
+        hostAlias,
+        keyType: validatedInput.keyType
+      },
+      token: validatedInput.token,
+      isDefaultGlobal: validatedInput.setAsGlobal,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.configStore.setAccount(profile);
+    this.syncAllSshHosts();
+    if (validatedInput.setAsGlobal) {
+      await this.gitService.setGlobalIdentity(profile.gitUserName, profile.email);
+    }
+    return profile;
+  }
+  /**
+   * Updates an existing account profile.
+   */
+  async updateAccount(alias, input) {
+    const validatedInput = UpdateAccountInputSchema.parse(input);
+    const existing = this.configStore.getAccount(alias);
+    if (!existing) {
+      throw new Error(`Account profile '${alias}' does not exist.`);
+    }
+    let privateKeyPath = existing.ssh.keyPath;
+    let publicKeyPath = existing.ssh.publicKeyPath;
+    if (validatedInput.sshKeyPath && validatedInput.sshKeyPath !== existing.ssh.keyPath) {
+      if (!fs4.existsSync(validatedInput.sshKeyPath)) {
+        throw new Error(`Specified SSH key does not exist at: ${validatedInput.sshKeyPath}`);
+      }
+      privateKeyPath = validatedInput.sshKeyPath;
+      publicKeyPath = fs4.existsSync(`${privateKeyPath}.pub`) ? `${privateKeyPath}.pub` : privateKeyPath;
+    }
+    const updated = AccountProfileSchema.parse({
+      ...existing,
+      name: validatedInput.name ?? existing.name,
+      username: validatedInput.username ?? existing.username,
+      email: validatedInput.email ?? existing.email,
+      gitUserName: validatedInput.gitUserName ?? existing.gitUserName,
+      token: validatedInput.token !== void 0 ? validatedInput.token : existing.token,
+      ssh: {
+        ...existing.ssh,
+        keyPath: privateKeyPath,
+        publicKeyPath,
+        hostAlias: validatedInput.hostAlias ?? existing.ssh.hostAlias
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.configStore.setAccount(updated);
+    this.syncAllSshHosts();
+    return updated;
+  }
+  /**
+   * Removes an account profile and optionally deletes its SSH keys.
+   */
+  removeAccount(alias, deleteSshKey = false) {
+    const existing = this.configStore.getAccount(alias);
+    if (!existing) {
+      return false;
+    }
+    if (deleteSshKey) {
+      try {
+        if (fs4.existsSync(existing.ssh.keyPath)) {
+          fs4.unlinkSync(existing.ssh.keyPath);
+        }
+        if (fs4.existsSync(existing.ssh.publicKeyPath)) {
+          fs4.unlinkSync(existing.ssh.publicKeyPath);
+        }
+      } catch {
+      }
+    }
+    const removed = this.configStore.removeAccount(alias);
+    this.syncAllSshHosts();
+    return removed;
+  }
+  /**
+   * Returns a list of all configured account profiles.
+   */
+  listAccounts() {
+    const accounts = this.configStore.getAccounts();
+    return Object.values(accounts).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  /**
+   * Gets an account profile by alias.
+   */
+  getAccount(alias) {
+    return this.configStore.getAccount(alias);
+  }
+  /**
+   * Switches the global Git user to the specified account.
+   */
+  async switchGlobal(alias) {
+    const account = this.configStore.getAccount(alias);
+    if (!account) {
+      throw new Error(`Account profile '${alias}' not found.`);
+    }
+    await this.gitService.setGlobalIdentity(account.gitUserName, account.email);
+    this.configStore.setActiveGlobal(alias);
+    return account;
+  }
+  /**
+   * Switches the local Git user in the current repository to the specified account.
+   */
+  async switchLocal(alias, cwd) {
+    const account = this.configStore.getAccount(alias);
+    if (!account) {
+      throw new Error(`Account profile '${alias}' not found.`);
+    }
+    await this.gitService.setLocalIdentity(
+      account.gitUserName,
+      account.email,
+      account.ssh.keyPath,
+      cwd
+    );
+    return account;
+  }
+  /**
+   * Re-syncs all accounts into ~/.ssh/config.
+   */
+  syncAllSshHosts() {
+    const accounts = this.listAccounts();
+    const hostConfigs = accounts.map((acc) => ({
+      host: acc.ssh.hostAlias,
+      hostName: "github.com",
+      user: "git",
+      identityFile: acc.ssh.keyPath,
+      identitiesOnly: true
+    }));
+    this.sshService.syncSshConfig(hostConfigs);
+  }
+  /**
+   * Tests SSH connectivity for a specific account.
+   */
+  async testAccount(alias) {
+    const account = this.configStore.getAccount(alias);
+    if (!account) {
+      throw new Error(`Account profile '${alias}' not found.`);
+    }
+    return this.sshService.testConnection(account.ssh.hostAlias, account.username);
+  }
+};
+
+// src/ui/prompts.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+}
+async function promptAddAccount() {
+  p.intro(pc.bold(pc.cyan("octomux (omx) \u2014 Add New GitHub Account")));
+  const id = await p.text({
+    message: "Enter an alias ID for this account (e.g. work, personal, opensource):",
+    placeholder: "work",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Alias ID is required";
+      if (!/^[a-z0-9-_]+$/i.test(val)) return "Alias must contain only alphanumeric characters, dashes, or underscores";
+      return void 0;
+    }
+  });
+  handleCancel(id);
+  const username = await p.text({
+    message: "Enter GitHub username (e.g. octocat):",
+    placeholder: "octocat",
+    validate: (val) => !val || !val.trim() ? "GitHub username is required" : void 0
+  });
+  handleCancel(username);
+  const email = await p.text({
+    message: "Enter Git commit email (e.g. user@example.com):",
+    placeholder: "user@example.com",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Email is required";
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val)) return "Invalid email address";
+      return void 0;
+    }
+  });
+  handleCancel(email);
+  const gitUserName = await p.text({
+    message: "Enter Git author name (used in commit history):",
+    placeholder: username,
+    initialValue: username
+  });
+  handleCancel(gitUserName);
+  const sshService = new SshService();
+  const existingKeys = sshService.scanExistingSshKeys();
+  const keyOptions = [];
+  for (const k of existingKeys) {
+    const commentStr = k.comment ? ` (${k.comment})` : "";
+    keyOptions.push({
+      value: `existing:${k.privateKeyPath}`,
+      label: `\u{1F511} Use detected key: ${k.name} [${k.keyType}]${commentStr}`
+    });
+  }
+  keyOptions.push(
+    { value: "generate_ed25519", label: "\u2795 Generate new Ed25519 key (Recommended)" },
+    { value: "generate_rsa", label: "\u2795 Generate new RSA 4096-bit key" },
+    { value: "manual", label: "\u{1F4C1} Specify a custom private key path..." }
+  );
+  const keyChoice = await p.select({
+    message: "SSH Key configuration:",
+    options: keyOptions
+  });
+  handleCancel(keyChoice);
+  let generateKey = true;
+  let keyType = "ed25519";
+  let sshKeyPath;
+  const keyChoiceStr = keyChoice;
+  if (keyChoiceStr.startsWith("existing:")) {
+    generateKey = false;
+    sshKeyPath = keyChoiceStr.replace("existing:", "");
+    keyType = sshKeyPath.includes("rsa") ? "rsa" : "ed25519";
+  } else if (keyChoiceStr === "generate_ed25519") {
+    generateKey = true;
+    keyType = "ed25519";
+  } else if (keyChoiceStr === "generate_rsa") {
+    generateKey = true;
+    keyType = "rsa";
+  } else {
+    generateKey = false;
+    const pathInput = await p.text({
+      message: "Enter path to existing private SSH key:",
+      placeholder: "~/.ssh/id_rsa",
+      validate: (val) => !val || !val.trim() ? "Private key path is required" : void 0
+    });
+    handleCancel(pathInput);
+    sshKeyPath = pathInput;
+  }
+  const setAsGlobal = await p.confirm({
+    message: "Set this account as the active global Git identity now?",
+    initialValue: false
+  });
+  handleCancel(setAsGlobal);
+  return {
+    id: id.trim(),
+    name: username.trim(),
+    username: username.trim(),
+    email: email.trim(),
+    gitUserName: (gitUserName || username).trim(),
+    generateKey,
+    keyType,
+    sshKeyPath,
+    setAsGlobal: Boolean(setAsGlobal)
+  };
+}
+async function promptSelectAccount(accounts, message = "Select an account profile:") {
+  if (accounts.length === 0) {
+    throw new Error('No accounts available. Please add an account first with "omx account add".');
+  }
+  const selected = await p.select({
+    message,
+    options: accounts.map((acc) => ({
+      value: acc.id,
+      label: `${pc.bold(acc.id)} (@${acc.username} - ${acc.email})`
+    }))
+  });
+  handleCancel(selected);
+  const found = accounts.find((a) => a.id === selected);
+  if (!found) {
+    throw new Error("Selected account not found.");
+  }
+  return found;
+}
+async function promptEditAccount(existing) {
+  p.intro(pc.bold(pc.cyan(`Edit Account: ${existing.id}`)));
+  const username = await p.text({
+    message: "GitHub username:",
+    initialValue: existing.username
+  });
+  handleCancel(username);
+  const email = await p.text({
+    message: "Git commit email:",
+    initialValue: existing.email
+  });
+  handleCancel(email);
+  const gitUserName = await p.text({
+    message: "Git author name:",
+    initialValue: existing.gitUserName
+  });
+  handleCancel(gitUserName);
+  return {
+    username,
+    email,
+    gitUserName
+  };
+}
+async function promptConfirm(message, initialValue = false) {
+  const result = await p.confirm({
+    message,
+    initialValue
+  });
+  handleCancel(result);
+  return Boolean(result);
+}
+
+// src/ui/logger.ts
+import pc2 from "picocolors";
+import boxen from "boxen";
+var logger = {
+  success(message) {
+    console.log(`${pc2.green("\u2714")} ${message}`);
+  },
+  error(message) {
+    console.error(`${pc2.red("\u2716")} ${pc2.red(message)}`);
+  },
+  warn(message) {
+    console.warn(`${pc2.yellow("\u26A0")} ${message}`);
+  },
+  info(message) {
+    console.log(`${pc2.cyan("\u2139")} ${message}`);
+  },
+  step(stepNumber, total, message) {
+    console.log(`${pc2.magenta(`[${stepNumber}/${total}]`)} ${message}`);
+  },
+  dim(message) {
+    console.log(pc2.dim(message));
+  },
+  highlight(label, value) {
+    console.log(`  ${pc2.bold(label)}: ${pc2.cyan(value)}`);
+  },
+  box(content, title, borderColor = "cyan") {
+    console.log(
+      boxen(content, {
+        padding: 1,
+        margin: { top: 0, bottom: 0 },
+        borderStyle: "round",
+        borderColor,
+        title: title ? pc2.bold(title) : void 0,
+        titleAlignment: "left"
+      })
+    );
+  }
+};
+
+// src/ui/formatters.ts
+import pc3 from "picocolors";
+function formatPublicKeyGuide(account, publicKeyContent) {
+  const lines = [
+    pc3.bold(pc3.green("Account configured successfully!")),
+    "",
+    `${pc3.bold("Next Step:")} Add your SSH Public Key to your GitHub Account:`,
+    pc3.cyan("https://github.com/settings/ssh/new"),
+    "",
+    `${pc3.bold("Public Key Path:")} ${pc3.dim(account.ssh.publicKeyPath)}`
+  ];
+  if (publicKeyContent) {
+    lines.push("");
+    lines.push(pc3.bold("Public Key Content:"));
+    lines.push(pc3.yellow(publicKeyContent));
+  }
+  return lines.join("\n");
+}
+function formatTestResult(result) {
+  if (result.authenticated) {
+    return [
+      pc3.green(`\u2714 SSH connection to ${pc3.bold(result.hostAlias)} succeeded!`),
+      pc3.dim(`  GitHub greeting: Hi ${result.username}! You've successfully authenticated.`)
+    ].join("\n");
+  }
+  return [
+    pc3.red(`\u2716 SSH connection to ${pc3.bold(result.hostAlias)} failed.`),
+    pc3.yellow(`  Error output: ${result.error || "Authentication rejected."}`),
+    pc3.dim(`  Tip: Make sure you added your public key at https://github.com/settings/keys`)
+  ].join("\n");
+}
+function formatCloneSummary(repoName, targetDir, account) {
+  return [
+    pc3.bold(pc3.green(`Repository cloned and configured successfully!`)),
+    "",
+    `  ${pc3.bold("Repository:")} ${pc3.cyan(repoName)}`,
+    `  ${pc3.bold("Location:")}   ${targetDir}`,
+    `  ${pc3.bold("Account:")}    ${pc3.yellow(account.id)} (@${account.username})`,
+    `  ${pc3.bold("Author:")}     ${account.gitUserName} <${account.email}>`,
+    `  ${pc3.bold("SSH Host:")}   ${pc3.cyan(account.ssh.hostAlias)}`
+  ].join("\n");
+}
+
+// src/commands/account/add.ts
+function registerAccountAddCommand(accountCmd) {
+  accountCmd.command("add").description("Add and configure a new GitHub account profile").option("-a, --alias <id>", "Account alias identifier (e.g. work, personal)").option("-u, --username <username>", "GitHub username").option("-e, --email <email>", "Git commit email").option("-g, --git-name <name>", "Git author name (defaults to username)").option("-k, --key-path <path>", "Path to existing private SSH key").option("--key-type <type>", "SSH key type (ed25519 or rsa)", "ed25519").option("--no-keygen", "Do not generate a new SSH key").option("--global", "Set as default global Git identity").option("--json", "Output result in JSON format").action(async (options) => {
+    const manager = new AccountManager();
+    const sshService = new SshService();
+    let input;
+    if (options.alias && options.username && options.email) {
+      input = {
+        id: options.alias,
+        username: options.username,
+        email: options.email,
+        gitUserName: options.gitName || options.username,
+        sshKeyPath: options.keyPath,
+        generateKey: options.keygen !== false && !options.keyPath,
+        keyType: options.keyType === "rsa" ? "rsa" : "ed25519",
+        setAsGlobal: Boolean(options.global)
+      };
+    } else {
+      input = await promptAddAccount();
+    }
+    const spinner = ora("Configuring GitHub account & SSH host...").start();
+    try {
+      const profile = await manager.addAccount(input);
+      spinner.succeed(`Account '${profile.id}' (@${profile.username}) added successfully!`);
+      const pubKeyContent = sshService.getPublicKey(profile.ssh.keyPath);
+      if (options.json) {
+        console.log(JSON.stringify({ ...profile, publicKeyContent: pubKeyContent }, null, 2));
+        return;
+      }
+      const guide = formatPublicKeyGuide(profile, pubKeyContent);
+      logger.box(guide, "GitHub SSH Setup Required", "green");
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      spinner.fail(`Failed to add account: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/ui/table.ts
+import Table from "cli-table3";
+import pc4 from "picocolors";
+function renderAccountTable(accounts, activeGlobalAlias, activeLocalAlias) {
+  if (accounts.length === 0) {
+    return pc4.dim('No accounts configured yet. Run "omx account add" to get started.');
+  }
+  const table = new Table({
+    head: [
+      pc4.bold("Active"),
+      pc4.bold("Alias"),
+      pc4.bold("GitHub User"),
+      pc4.bold("Git Commit Email"),
+      pc4.bold("Git Author Name"),
+      pc4.bold("SSH Host Alias")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    }
+  });
+  for (const acc of accounts) {
+    const isGlobal = activeGlobalAlias === acc.id || acc.isDefaultGlobal;
+    const isLocal = activeLocalAlias === acc.id;
+    let statusTag = "";
+    if (isGlobal && isLocal) {
+      statusTag = pc4.green("\u2605 Global & Local");
+    } else if (isLocal) {
+      statusTag = pc4.cyan("\u25CF Local");
+    } else if (isGlobal) {
+      statusTag = pc4.green("\u2605 Global");
+    } else {
+      statusTag = pc4.dim("\u2014");
+    }
+    table.push([
+      statusTag,
+      pc4.bold(pc4.yellow(acc.id)),
+      acc.username,
+      acc.email,
+      acc.gitUserName,
+      pc4.cyan(acc.ssh.hostAlias)
+    ]);
+  }
+  return table.toString();
+}
+
+// src/commands/account/list.ts
+function registerAccountListCommand(programOrAccountCmd) {
+  const handler = async (options) => {
+    const manager = new AccountManager();
+    const gitService = new GitService();
+    const accounts = manager.listAccounts();
+    if (options.json) {
+      console.log(JSON.stringify(accounts, null, 2));
+      return;
+    }
+    const activeGlobal = manager.getAccount(manager.listAccounts().find((a) => a.isDefaultGlobal)?.id || "");
+    let activeLocalAlias;
+    const isRepo = await gitService.isInsideGitRepo();
+    if (isRepo) {
+      const localIdentity = await gitService.getIdentity("local");
+      if (localIdentity.email) {
+        const match = accounts.find((a) => a.email.toLowerCase() === localIdentity.email?.toLowerCase());
+        if (match) {
+          activeLocalAlias = match.id;
+        }
+      }
+    }
+    console.log(renderAccountTable(accounts, activeGlobal?.id, activeLocalAlias));
+  };
+  programOrAccountCmd.command("list").alias("ls").description("List all configured GitHub accounts").option("--json", "Output list as JSON").action(handler);
+}
+
+// src/commands/account/edit.ts
+import ora2 from "ora";
+function registerAccountEditCommand(accountCmd) {
+  accountCmd.command("edit [alias]").description("Update an existing GitHub account profile").option("-u, --username <username>", "Update GitHub username").option("-e, --email <email>", "Update Git commit email").option("-g, --git-name <name>", "Update Git author name").option("-k, --key-path <path>", "Update private SSH key path").option("--json", "Output updated profile in JSON format").action(async (aliasArg, options) => {
+    const manager = new AccountManager();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.warn('No accounts configured yet. Run "omx account add" first.');
+      return;
+    }
+    let alias = aliasArg;
+    let existing = alias ? manager.getAccount(alias) : void 0;
+    if (!existing) {
+      existing = await promptSelectAccount(accounts, "Select an account to edit:");
+      alias = existing.id;
+    }
+    let updateInput;
+    if (options.username || options.email || options.gitName || options.keyPath) {
+      updateInput = {
+        username: options.username,
+        email: options.email,
+        gitUserName: options.gitName,
+        sshKeyPath: options.keyPath
+      };
+    } else {
+      updateInput = await promptEditAccount(existing);
+    }
+    const spinner = ora2(`Updating account '${alias}'...`).start();
+    try {
+      const updated = await manager.updateAccount(alias, updateInput);
+      spinner.succeed(`Account '${alias}' updated successfully!`);
+      if (options.json) {
+        console.log(JSON.stringify(updated, null, 2));
+      } else {
+        logger.highlight("Username", updated.username);
+        logger.highlight("Email", updated.email);
+        logger.highlight("Git Author", updated.gitUserName);
+        logger.highlight("SSH Host", updated.ssh.hostAlias);
+      }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      spinner.fail(`Failed to update account: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/account/remove.ts
+import ora3 from "ora";
+function registerAccountRemoveCommand(accountCmd) {
+  accountCmd.command("remove [alias]").alias("rm").description("Remove a GitHub account profile").option("-d, --delete-keys", "Also delete the associated SSH private and public key files").option("-y, --yes", "Skip confirmation prompt").action(async (aliasArg, options) => {
+    const manager = new AccountManager();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.warn("No accounts configured to remove.");
+      return;
+    }
+    let alias = aliasArg;
+    let targetAccount = alias ? manager.getAccount(alias) : void 0;
+    if (!targetAccount) {
+      targetAccount = await promptSelectAccount(accounts, "Select an account to remove:");
+      alias = targetAccount.id;
+    }
+    if (!options.yes) {
+      const confirmed = await promptConfirm(
+        `Are you sure you want to remove account profile '${alias}' (@${targetAccount.username})?`,
+        false
+      );
+      if (!confirmed) {
+        logger.info("Operation aborted.");
+        return;
+      }
+    }
+    const spinner = ora3(`Removing account '${alias}'...`).start();
+    try {
+      const removed = manager.removeAccount(alias, Boolean(options.deleteKeys));
+      if (removed) {
+        spinner.succeed(`Account profile '${alias}' removed successfully.`);
+        if (options.deleteKeys) {
+          logger.dim(`SSH keys at ${targetAccount.ssh.keyPath} were deleted.`);
+        }
+      } else {
+        spinner.fail(`Account profile '${alias}' was not found.`);
+      }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      spinner.fail(`Failed to remove account: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/account/test.ts
+import ora4 from "ora";
+function registerAccountTestCommand(accountCmd) {
+  accountCmd.command("test [alias]").description("Test SSH connectivity and authentication for an account").option("--all", "Test all configured accounts").option("--json", "Output results in JSON format").action(async (aliasArg, options) => {
+    const manager = new AccountManager();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.warn('No accounts configured yet. Run "omx account add" first.');
+      return;
+    }
+    if (options.all) {
+      const results = [];
+      for (const acc of accounts) {
+        const spinner2 = ora4(`Testing SSH connection for '${acc.id}' (${acc.ssh.hostAlias})...`).start();
+        const result2 = await manager.testAccount(acc.id);
+        if (result2.authenticated) {
+          spinner2.succeed(`Account '${acc.id}' authenticated successfully.`);
+        } else {
+          spinner2.fail(`Account '${acc.id}' authentication failed.`);
+        }
+        results.push(result2);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+      } else {
+        for (const res of results) {
+          console.log("\n" + formatTestResult(res));
+        }
+      }
+      return;
+    }
+    let alias = aliasArg;
+    if (!alias) {
+      const selected = await promptSelectAccount(accounts, "Select an account to test SSH connection:");
+      alias = selected.id;
+    }
+    const targetAccount = manager.getAccount(alias);
+    if (!targetAccount) {
+      logger.error(`Account profile '${alias}' does not exist.`);
+      process.exit(1);
+    }
+    const spinner = ora4(`Testing SSH connection to ${targetAccount.ssh.hostAlias}...`).start();
+    const result = await manager.testAccount(alias);
+    if (result.authenticated) {
+      spinner.succeed(`SSH Authentication successful!`);
+    } else {
+      spinner.fail(`SSH Authentication failed.`);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log("\n" + formatTestResult(result));
+    }
+  });
+}
+
+// src/commands/account/import.ts
+import path4 from "path";
+import * as p2 from "@clack/prompts";
+import ora5 from "ora";
+import pc5 from "picocolors";
+function registerAccountImportCommand(accountCmd) {
+  accountCmd.command("import [keyPath]").description("Automatically discover or import an existing SSH key as an octomux account").option("-a, --alias <id>", "Account alias identifier").option("-u, --username <username>", "GitHub username").option("-e, --email <email>", "Git commit email").option("-g, --git-name <name>", "Git author name").option("--global", "Set as default global Git identity").action(async (keyPathArg, options) => {
+    const manager = new AccountManager();
+    const sshService = new SshService();
+    let targetKeyPath = keyPathArg;
+    let initialEmail = options.email || "";
+    let initialUsername = options.username || "";
+    if (!targetKeyPath) {
+      p2.intro(pc5.bold(pc5.cyan("octomux (omx) \u2014 Auto-Import Existing SSH Key")));
+      const discovered = sshService.scanExistingSshKeys();
+      if (discovered.length === 0) {
+        logger.warn('No existing SSH keys found in ~/.ssh. Use "omx account add" to generate one.');
+        return;
+      }
+      const selectedKey = await p2.select({
+        message: "Select an existing SSH key to import:",
+        options: discovered.map((k) => {
+          const comment = k.comment ? ` (${k.comment})` : "";
+          return {
+            value: k.privateKeyPath,
+            label: `${pc5.bold(k.name)} [${k.keyType}]${comment}`
+          };
+        })
+      });
+      handleCancel(selectedKey);
+      targetKeyPath = selectedKey;
+      const match = discovered.find((k) => k.privateKeyPath === targetKeyPath);
+      if (match?.comment) {
+        if (match.comment.includes("@")) {
+          initialEmail = match.comment;
+        } else {
+          initialUsername = match.comment;
+        }
+      }
+    }
+    const basename = path4.basename(targetKeyPath).replace(/^id_(ed25519|rsa|ecdsa)_?/, "") || "profile";
+    const defaultAlias = options.alias || (basename !== "profile" ? basename : "imported");
+    const alias = options.alias || await p2.text({
+      message: "Account alias ID (e.g. work, personal):",
+      initialValue: defaultAlias,
+      validate: (val) => !val || !val.trim() ? "Alias is required" : void 0
+    });
+    handleCancel(alias);
+    const username = options.username || await p2.text({
+      message: "GitHub username:",
+      initialValue: initialUsername,
+      validate: (val) => !val || !val.trim() ? "Username is required" : void 0
+    });
+    handleCancel(username);
+    const email = options.email || await p2.text({
+      message: "Git commit email:",
+      initialValue: initialEmail,
+      validate: (val) => {
+        if (!val || !val.trim()) return "Email is required";
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(val)) return "Invalid email address";
+        return void 0;
+      }
+    });
+    handleCancel(email);
+    const gitUserName = options.gitName || await p2.text({
+      message: "Git author name:",
+      initialValue: username
+    });
+    handleCancel(gitUserName);
+    const setAsGlobal = options.global !== void 0 ? Boolean(options.global) : await p2.confirm({
+      message: "Set as active global Git identity?",
+      initialValue: false
+    });
+    handleCancel(setAsGlobal);
+    const spinner = ora5("Importing key and configuring SSH host...").start();
+    try {
+      const profile = await manager.addAccount({
+        id: alias.trim(),
+        username: username.trim(),
+        email: email.trim(),
+        gitUserName: (gitUserName || username).trim(),
+        sshKeyPath: targetKeyPath,
+        generateKey: false,
+        setAsGlobal: Boolean(setAsGlobal)
+      });
+      spinner.succeed(`Account '${profile.id}' imported successfully with key: ${path4.basename(targetKeyPath)}`);
+      const pubKeyContent = sshService.getPublicKey(profile.ssh.keyPath);
+      const guide = formatPublicKeyGuide(profile, pubKeyContent);
+      logger.box(guide, "Account Imported", "green");
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      spinner.fail(`Failed to import account: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/account/index.ts
+function registerAccountCommands(program) {
+  const accountCmd = program.command("account").alias("acc").description("Manage GitHub account profiles and SSH configurations");
+  registerAccountAddCommand(accountCmd);
+  registerAccountListCommand(accountCmd);
+  registerAccountEditCommand(accountCmd);
+  registerAccountRemoveCommand(accountCmd);
+  registerAccountTestCommand(accountCmd);
+  registerAccountImportCommand(accountCmd);
+  registerAccountListCommand(program);
+  registerAccountImportCommand(program);
+}
+
+// src/commands/switch.ts
+import * as p3 from "@clack/prompts";
+function registerSwitchCommand(program) {
+  program.command("switch [alias]").alias("use").description("Switch active Git identity locally in current repository or globally").option("-g, --global", "Apply switch to global Git configuration").option("-l, --local", "Apply switch to local repository Git configuration").action(async (aliasArg, options) => {
+    const manager = new AccountManager();
+    const gitService = new GitService();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.warn('No accounts configured yet. Run "omx account add" first.');
+      return;
+    }
+    let targetAccount = aliasArg ? manager.getAccount(aliasArg) : void 0;
+    if (!targetAccount) {
+      targetAccount = await promptSelectAccount(accounts, "Select account to switch to:");
+    }
+    let isGlobal = Boolean(options.global);
+    let isLocal = Boolean(options.local);
+    const inRepo = await gitService.isInsideGitRepo();
+    if (!isGlobal && !isLocal) {
+      if (inRepo) {
+        const scope = await p3.select({
+          message: `Where do you want to apply account '${targetAccount.id}'?`,
+          options: [
+            { value: "local", label: "Local Repository (Current folder only, with dedicated SSH key)" },
+            { value: "global", label: "Global (System-wide default Git user)" },
+            { value: "both", label: "Both Local Repository & Global" }
+          ]
+        });
+        handleCancel(scope);
+        if (scope === "local" || scope === "both") isLocal = true;
+        if (scope === "global" || scope === "both") isGlobal = true;
+      } else {
+        isGlobal = true;
+      }
+    }
+    if (isGlobal) {
+      await manager.switchGlobal(targetAccount.id);
+      logger.success(`Global Git identity switched to: ${targetAccount.gitUserName} <${targetAccount.email}>`);
+    }
+    if (isLocal) {
+      if (!inRepo) {
+        logger.error("Cannot apply local config: Current directory is not inside a Git repository.");
+        process.exit(1);
+      }
+      await manager.switchLocal(targetAccount.id);
+      logger.success(`Local repository Git identity switched to: ${targetAccount.gitUserName} <${targetAccount.email}>`);
+      logger.dim(`SSH Key bound: ${targetAccount.ssh.keyPath}`);
+    }
+  });
+}
+
+// src/commands/status.ts
+import pc6 from "picocolors";
+function registerStatusCommand(program) {
+  const handler = async (options) => {
+    const manager = new AccountManager();
+    const gitService = new GitService();
+    const accounts = manager.listAccounts();
+    const globalIdentity = await gitService.getIdentity("global");
+    const inRepo = await gitService.isInsideGitRepo();
+    let localIdentity;
+    let repoRoot;
+    let remoteUrl;
+    if (inRepo) {
+      localIdentity = await gitService.getIdentity("local");
+      repoRoot = await gitService.getRepoRoot();
+      remoteUrl = await gitService.getRemoteUrl();
+    }
+    const matchedGlobal = accounts.find(
+      (a) => a.email.toLowerCase() === globalIdentity.email?.toLowerCase()
+    );
+    const matchedLocal = localIdentity?.email ? accounts.find((a) => a.email.toLowerCase() === localIdentity?.email?.toLowerCase()) : void 0;
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            inRepo,
+            repoRoot,
+            remoteUrl,
+            global: {
+              ...globalIdentity,
+              matchedAccount: matchedGlobal?.id
+            },
+            local: inRepo ? {
+              ...localIdentity,
+              matchedAccount: matchedLocal?.id
+            } : null
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const lines = [];
+    lines.push(pc6.bold(pc6.cyan("\u25CF Global Git Configuration:")));
+    lines.push(
+      `  Author: ${globalIdentity.name || pc6.dim("(not set)")} <${globalIdentity.email || pc6.dim("(not set)")}>`
+    );
+    if (matchedGlobal) {
+      lines.push(`  Profile: ${pc6.yellow(matchedGlobal.id)} (@${matchedGlobal.username})`);
+    } else {
+      lines.push(`  Profile: ${pc6.dim("No matching octomux profile")}`);
+    }
+    lines.push("");
+    if (inRepo) {
+      lines.push(pc6.bold(pc6.green("\u25CF Current Local Repository:")));
+      lines.push(`  Path:   ${repoRoot}`);
+      if (remoteUrl) {
+        lines.push(`  Remote: ${pc6.dim(remoteUrl)}`);
+      }
+      lines.push(
+        `  Author: ${localIdentity?.name || pc6.dim("(inherited from global)")} <${localIdentity?.email || pc6.dim("(inherited from global)")}>`
+      );
+      if (localIdentity?.sshCommand) {
+        lines.push(`  SSH:    ${pc6.dim(localIdentity.sshCommand)}`);
+      }
+      if (matchedLocal) {
+        lines.push(`  Profile: ${pc6.yellow(matchedLocal.id)} (@${matchedLocal.username})`);
+      }
+    } else {
+      lines.push(pc6.bold(pc6.dim("\u25CF Current Directory is not a Git repository.")));
+    }
+    logger.box(lines.join("\n"), "Git & Identity Status", inRepo ? "green" : "cyan");
+  };
+  program.command("status").alias("current").description("Show active Git identities (global & local repository) and profile match").option("--json", "Output status as JSON").action(handler);
+}
+
+// src/commands/clone.ts
+import path5 from "path";
+import fs5 from "fs";
+import ora6 from "ora";
+function registerCloneCommand(program) {
+  program.command("clone <repo> [directory]").description("Smart clone a GitHub repository and automatically configure local identity").option("-a, --account <alias>", "Account profile to clone and bind with").option("--json", "Output clone result as JSON").allowUnknownOption(false).action(async (repoInput, directoryArg, options) => {
+    const manager = new AccountManager();
+    const gitService = new GitService();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.error('No accounts configured in octomux yet. Please run "omx account add" first.');
+      process.exit(1);
+    }
+    const parsedRepo = gitService.parseRepoInput(repoInput);
+    if (!parsedRepo) {
+      logger.error(
+        `Invalid repository format: "${repoInput}".
+Supported formats:
+  - owner/repo
+  - https://github.com/owner/repo.git
+  - git@github.com:owner/repo.git`
+      );
+      process.exit(1);
+    }
+    let account;
+    if (options.account) {
+      account = manager.getAccount(options.account);
+      if (!account) {
+        logger.error(`Account profile '${options.account}' not found.`);
+        process.exit(1);
+      }
+    } else if (accounts.length === 1 && accounts[0]) {
+      account = accounts[0];
+    } else {
+      account = await promptSelectAccount(
+        accounts,
+        `Select the account to clone ${parsedRepo.owner}/${parsedRepo.repo}:`
+      );
+    }
+    const sshCloneUrl = gitService.formatSshCloneUrl(
+      account.ssh.hostAlias,
+      parsedRepo.owner,
+      parsedRepo.repo
+    );
+    logger.info(`Cloning with profile ${account.id} using SSH host: ${account.ssh.hostAlias}`);
+    try {
+      const clonedDirName = await gitService.clone(sshCloneUrl, directoryArg);
+      const resolvedPath = path5.resolve(process.cwd(), clonedDirName);
+      if (fs5.existsSync(resolvedPath)) {
+        const spinner = ora6("Binding local Git author & SSH key configuration...").start();
+        await gitService.setLocalIdentity(
+          account.gitUserName,
+          account.email,
+          account.ssh.keyPath,
+          resolvedPath
+        );
+        spinner.succeed("Local Git identity configured!");
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                success: true,
+                repository: `${parsedRepo.owner}/${parsedRepo.repo}`,
+                path: resolvedPath,
+                account: account.id,
+                gitUserName: account.gitUserName,
+                email: account.email,
+                sshKey: account.ssh.keyPath
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          const summary = formatCloneSummary(
+            `${parsedRepo.owner}/${parsedRepo.repo}`,
+            resolvedPath,
+            account
+          );
+          logger.box(summary, "Smart Clone Complete", "green");
+        }
+      }
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      logger.error(`Git clone failed: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/remote.ts
+import * as p4 from "@clack/prompts";
+import pc7 from "picocolors";
+function registerRemoteCommand(program) {
+  program.command("remote [repo]").alias("origin").description("Add or update Git remote origin and automatically bind local identity").option("-a, --account <alias>", "Account profile to bind with this remote").option("-r, --remote <name>", "Remote name", "origin").option("--init", "Initialize a new Git repository if not already one").option("--json", "Output result in JSON format").action(async (repoArg, options) => {
+    const manager = new AccountManager();
+    const gitService = new GitService();
+    const accounts = manager.listAccounts();
+    if (accounts.length === 0) {
+      logger.error('No accounts configured in octomux yet. Run "omx account add" first.');
+      process.exit(1);
+    }
+    let inRepo = await gitService.isInsideGitRepo();
+    if (!inRepo) {
+      if (options.init) {
+        await gitService.initRepo();
+        logger.success("Initialized new Git repository in current directory.");
+        inRepo = true;
+      } else {
+        const shouldInit = await promptConfirm(
+          "Current directory is not a Git repository. Initialize git repository now?",
+          true
+        );
+        if (shouldInit) {
+          await gitService.initRepo();
+          logger.success("Initialized new Git repository in current directory.");
+          inRepo = true;
+        } else {
+          logger.error("Operation aborted: Not a Git repository.");
+          process.exit(1);
+        }
+      }
+    }
+    let repoInput = repoArg;
+    if (!repoInput) {
+      const input = await p4.text({
+        message: "Enter GitHub repository (e.g. owner/repo, https://github.com/owner/repo, or git@...):",
+        placeholder: "username/repo-name",
+        validate: (val) => !val || !val.trim() ? "Repository is required" : void 0
+      });
+      handleCancel(input);
+      repoInput = input;
+    }
+    const parsedRepo = gitService.parseRepoInput(repoInput);
+    if (!parsedRepo) {
+      logger.error(
+        `Invalid repository format: "${repoInput}".
+Supported formats:
+  - owner/repo
+  - https://github.com/owner/repo.git
+  - git@github.com:owner/repo.git`
+      );
+      process.exit(1);
+    }
+    let account;
+    if (options.account) {
+      account = manager.getAccount(options.account);
+      if (!account) {
+        logger.error(`Account profile '${options.account}' not found.`);
+        process.exit(1);
+      }
+    } else if (accounts.length === 1 && accounts[0]) {
+      account = accounts[0];
+    } else {
+      account = await promptSelectAccount(
+        accounts,
+        `Select the account profile for remote '${options.remote}':`
+      );
+    }
+    const sshRemoteUrl = gitService.formatSshCloneUrl(
+      account.ssh.hostAlias,
+      parsedRepo.owner,
+      parsedRepo.repo
+    );
+    const remoteName = options.remote || "origin";
+    const existingUrl = await gitService.getRemoteUrl(remoteName);
+    if (existingUrl) {
+      await gitService.setRemoteUrl(remoteName, sshRemoteUrl);
+      logger.success(`Updated existing remote '${remoteName}' URL.`);
+    } else {
+      await gitService.addRemoteUrl(remoteName, sshRemoteUrl);
+      logger.success(`Added remote '${remoteName}'.`);
+    }
+    await gitService.setLocalIdentity(
+      account.gitUserName,
+      account.email,
+      account.ssh.keyPath
+    );
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: true,
+            remote: remoteName,
+            url: sshRemoteUrl,
+            account: account.id,
+            gitUserName: account.gitUserName,
+            email: account.email,
+            sshKey: account.ssh.keyPath
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const summaryLines = [
+      pc7.bold(pc7.green(`Remote '${remoteName}' configured successfully!`)),
+      "",
+      `  ${pc7.bold("Remote URL:")}  ${pc7.cyan(sshRemoteUrl)}`,
+      `  ${pc7.bold("Account:")}     ${pc7.yellow(account.id)} (@${account.username})`,
+      `  ${pc7.bold("Author:")}      ${account.gitUserName} <${account.email}>`,
+      `  ${pc7.bold("SSH Host:")}    ${pc7.cyan(account.ssh.hostAlias)}`,
+      "",
+      pc7.dim("You can now push with: git push -u " + remoteName + " main")
+    ];
+    logger.box(summaryLines.join("\n"), "Remote Origin Configured", "green");
+  });
+}
+
+// src/commands/uninstall.ts
+import fs6 from "fs";
+import path6 from "path";
+import ora7 from "ora";
+function registerUninstallCommand(program) {
+  program.command("uninstall").alias("purge").description("Safely clean up octomux configurations, SSH blocks, and local data").option("--delete-keys", "Also delete octomux-generated SSH private & public keys").option("-y, --yes", "Skip interactive confirmation").action(async (options) => {
+    const configStore = new ConfigStore();
+    const sshService = new SshService();
+    logger.warn("This will safely remove octomux configurations from your system.");
+    if (!options.yes) {
+      const confirmed = await promptConfirm(
+        "Are you sure you want to clean up all octomux managed configurations?",
+        false
+      );
+      if (!confirmed) {
+        logger.info("Uninstall operation aborted.");
+        return;
+      }
+    }
+    let deleteKeys = Boolean(options.deleteKeys);
+    if (!options.yes && !options.deleteKeys) {
+      deleteKeys = await promptConfirm(
+        "Do you also want to delete all SSH keys generated by octomux (~/.ssh/id_*_octomux_*)?",
+        false
+      );
+    }
+    const spinner = ora7("Cleaning up octomux configurations...").start();
+    try {
+      sshService.syncSshConfig([]);
+      spinner.text = "Cleaned octomux managed block in ~/.ssh/config...";
+      if (deleteKeys) {
+        const accounts = Object.values(configStore.getAccounts());
+        for (const acc of accounts) {
+          if (fs6.existsSync(acc.ssh.keyPath)) {
+            try {
+              fs6.unlinkSync(acc.ssh.keyPath);
+            } catch {
+            }
+          }
+          if (fs6.existsSync(acc.ssh.publicKeyPath)) {
+            try {
+              fs6.unlinkSync(acc.ssh.publicKeyPath);
+            } catch {
+            }
+          }
+        }
+        const sshDir = getSshDir();
+        if (fs6.existsSync(sshDir)) {
+          const files = fs6.readdirSync(sshDir);
+          for (const file of files) {
+            if (file.includes("_octomux_")) {
+              try {
+                fs6.unlinkSync(path6.join(sshDir, file));
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      const octomuxDir = getOctomuxDir();
+      if (fs6.existsSync(octomuxDir)) {
+        fs6.rmSync(octomuxDir, { recursive: true, force: true });
+      }
+      spinner.succeed("octomux configurations cleaned up successfully!");
+      const lines = [
+        "octomux data has been safely uninstalled:",
+        "  \u2714 Cleaned managed entries from ~/.ssh/config (custom user hosts preserved)",
+        deleteKeys ? "  \u2714 Deleted octomux-generated SSH keys" : "  \u2139 Preserved SSH keys in ~/.ssh/",
+        "  \u2714 Removed ~/.octomux configuration store",
+        "",
+        "To remove the npm binary package, run:",
+        '  npm uninstall -g octomux   (or "npm unlink -g octomux" for dev builds)'
+      ];
+      logger.box(lines.join("\n"), "Safe Uninstall Complete", "green");
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      spinner.fail(`Failed to clean up: ${errorMsg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("octomux").description("Enterprise-grade cross-platform GitHub multi-account & SSH identity manager").version("1.0.0", "-v, --version", "Output the current version of octomux");
+  registerAccountCommands(program);
+  registerSwitchCommand(program);
+  registerStatusCommand(program);
+  registerCloneCommand(program);
+  registerRemoteCommand(program);
+  registerUninstallCommand(program);
+  program.action(async () => {
+    p5.intro(pc8.bold(pc8.cyan("\u{1F419} octomux (omx) \u2014 GitHub Identity & SSH Manager")));
+    const action = await p5.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "list", label: "\u{1F4CB} List configured accounts" },
+        { value: "add", label: "\u2795 Add a new GitHub account" },
+        { value: "import", label: "\u{1F511} Auto-import existing SSH keys" },
+        { value: "switch", label: "\u{1F500} Switch Git identity (global / local)" },
+        { value: "remote", label: "\u{1F517} Add or set remote origin for this repo" },
+        { value: "clone", label: "\u{1F4E6} Smart clone a repository" },
+        { value: "status", label: "\u{1F50D} Check active Git & SSH status" },
+        { value: "test", label: "\u26A1 Test SSH connections" },
+        { value: "uninstall", label: "\u{1F5D1}\uFE0F  Uninstall & clean up octomux" },
+        { value: "exit", label: "\u{1F6AA} Exit" }
+      ]
+    });
+    handleCancel(action);
+    if (action === "exit") {
+      p5.outro("Goodbye!");
+      process.exit(0);
+    }
+    switch (action) {
+      case "list":
+        await program.parseAsync(["node", "octomux", "account", "list"]);
+        break;
+      case "add":
+        await program.parseAsync(["node", "octomux", "account", "add"]);
+        break;
+      case "import":
+        await program.parseAsync(["node", "octomux", "account", "import"]);
+        break;
+      case "switch":
+        await program.parseAsync(["node", "octomux", "switch"]);
+        break;
+      case "remote": {
+        const repo = await p5.text({
+          message: "Enter GitHub repository (e.g. owner/repo, https://github.com/...):",
+          validate: (val) => !val || !val.trim() ? "Repository is required" : void 0
+        });
+        handleCancel(repo);
+        await program.parseAsync(["node", "octomux", "remote", repo]);
+        break;
+      }
+      case "clone": {
+        const repo = await p5.text({
+          message: "Enter repository slug or URL (e.g. owner/repo):",
+          validate: (val) => !val || !val.trim() ? "Repository is required" : void 0
+        });
+        handleCancel(repo);
+        await program.parseAsync(["node", "octomux", "clone", repo]);
+        break;
+      }
+      case "status":
+        await program.parseAsync(["node", "octomux", "status"]);
+        break;
+      case "test":
+        await program.parseAsync(["node", "octomux", "account", "test"]);
+        break;
+      case "uninstall":
+        await program.parseAsync(["node", "octomux", "uninstall"]);
+        break;
+    }
+  });
+  return program;
+}
+async function run(argv = process.argv) {
+  const program = createProgram();
+  await program.parseAsync(argv);
+}
+
+export {
+  logger,
+  createProgram,
+  run
+};
+//# sourceMappingURL=chunk-3NCQOE6V.js.map