@aeriondyseti/claude-profiles 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@aeriondyseti/claude-profiles",
+  "version": "0.1.0",
+  "description": "TUI and CLI for managing Claude Code profiles",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "claude-profiles": "src/cli.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublishOnly": "bunx tsc --noEmit"
+  },
+  "keywords": [
+    "claude",
+    "cli",
+    "profiles",
+    "tui"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.10.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+
+import { main } from "./index.ts";
+import { listProfiles } from "./commands/list.ts";
+import { createProfileCommand } from "./commands/create.ts";
+import { editProfileCommand } from "./commands/edit.ts";
+import { cloneProfileCommand } from "./commands/clone.ts";
+import { deleteProfileCommand } from "./commands/delete.ts";
+import { switchProfileCommand } from "./commands/switch.ts";
+import { runProfileCommand } from "./commands/run.ts";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function run(): Promise<void> {
+  switch (command) {
+    case "list":
+    case "ls":
+      await listProfiles();
+      break;
+
+    case "create":
+    case "new":
+      await createProfileCommand(args[1]);
+      break;
+
+    case "edit":
+      await editProfileCommand(args[1]);
+      break;
+
+    case "clone":
+    case "cp":
+      await cloneProfileCommand(args[1], args[2]);
+      break;
+
+    case "delete":
+    case "rm":
+      await deleteProfileCommand(args[1]);
+      break;
+
+    case "switch":
+    case "use":
+      await switchProfileCommand(args[1]);
+      break;
+
+    case "run":
+    case "exec": {
+      const dashDash = args.indexOf("--");
+      const profileName = args[1];
+      const extraArgs = dashDash >= 0 ? args.slice(dashDash + 1) : [];
+      await runProfileCommand(profileName, extraArgs);
+      break;
+    }
+
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+
+    case undefined:
+      // No command — launch interactive TUI
+      await main();
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+function printHelp(): void {
+  console.log(`
+claude-profiles — Manage Claude Code profiles
+
+Usage:
+  claude-profiles                          Interactive TUI
+  claude-profiles list                     List all profiles
+  claude-profiles create [name]            Create a new profile
+  claude-profiles edit [name]              Edit profile settings.json
+  claude-profiles clone [source] [name]    Clone a profile
+  claude-profiles delete [name]            Delete a profile
+  claude-profiles switch [name]            Show how to activate a profile
+  claude-profiles run [name] [-- args]     Run Claude with a specific profile
+
+Aliases:
+  ls = list, new = create, cp = clone,
+  rm = delete, use = switch, exec = run
+`);
+}
+
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/commands/clone.ts

@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import { cloneProfile } from "../profiles.ts";
+import { selectProfile } from "./shared.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function cloneProfileCommand(
+  sourceArg?: string,
+  nameArg?: string,
+): Promise<void> {
+  const source = await selectProfile("Which profile to clone?", sourceArg);
+  if (!source) return;
+
+  let name = nameArg;
+  if (!name) {
+    const input = await p.text({
+      message: "New profile name:",
+      placeholder: `e.g. ${source.name}-copy`,
+      validate(value) {
+        if (!value.trim()) return "Name is required";
+        if (!/^[a-zA-Z0-9_-]+$/.test(value))
+          return "Name must be alphanumeric (hyphens and underscores allowed)";
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    name = input;
+  }
+
+  try {
+    const dir = await cloneProfile(source.dir, name);
+    p.log.success(`Cloned "${source.name}" → "${name}" at ${dir}`);
+    p.log.info(
+      "Cloned: settings.json, CLAUDE.md, commands/, hooks/, agents/, skills/, output-styles/",
+    );
+    p.log.info("Excluded: sessions, history, auth state (.claude.json)");
+  } catch (err) {
+    p.log.error(String(err));
+  }
+}

package/src/commands/create.ts

@@ -0,0 +1,72 @@
+import * as p from "@clack/prompts";
+import { createProfile, getAllProfiles, readSettings } from "../profiles.ts";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function createProfileCommand(nameArg?: string): Promise<void> {
+  let name = nameArg;
+
+  if (!name) {
+    const input = await p.text({
+      message: "Profile name:",
+      placeholder: "e.g. work, personal, testing",
+      validate(value) {
+        if (!value.trim()) return "Name is required";
+        if (!/^[a-zA-Z0-9_-]+$/.test(value))
+          return "Name must be alphanumeric (hyphens and underscores allowed)";
+        return undefined;
+      },
+    });
+    if (isCancel(input)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    name = input;
+  }
+
+  const profiles = await getAllProfiles();
+
+  let copyFrom: string | null = null;
+  if (profiles.length > 0) {
+    const copy = await p.select({
+      message: "Copy settings from an existing profile?",
+      options: [
+        { value: "__none__", label: "No, start fresh" },
+        ...profiles.map((prof) => ({
+          value: prof.dir,
+          label: prof.name,
+        })),
+      ],
+    });
+    if (isCancel(copy)) {
+      p.cancel("Cancelled.");
+      return;
+    }
+    if (copy !== "__none__") {
+      copyFrom = copy as string;
+    }
+  }
+
+  const dir = await createProfile(name);
+
+  if (copyFrom) {
+    const settings = await readSettings(copyFrom);
+    if (settings) {
+      await writeFile(
+        join(dir, "settings.json"),
+        JSON.stringify(settings, null, 2) + "\n",
+      );
+    }
+  }
+
+  p.log.success(
+    `Created profile "${name}" at ${dir}`,
+  );
+  p.log.info(
+    `Run with: CLAUDE_CONFIG_DIR=${dir} claude`,
+  );
+}

package/src/commands/delete.ts

@@ -0,0 +1,32 @@
+import * as p from "@clack/prompts";
+import { deleteProfile } from "../profiles.ts";
+import { isActiveProfile } from "../utils.ts";
+import { selectProfile } from "./shared.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function deleteProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Which profile to delete?", nameArg);
+  if (!profile) return;
+
+  if (isActiveProfile(profile.dir)) {
+    p.log.error(
+      `Cannot delete "${profile.name}" — it is the currently active profile.`,
+    );
+    return;
+  }
+
+  const confirmed = await p.confirm({
+    message: `Delete profile "${profile.name}"? This will remove ${profile.dir} and all its contents.`,
+    initialValue: false,
+  });
+  if (isCancel(confirmed) || !confirmed) {
+    p.cancel("Cancelled.");
+    return;
+  }
+
+  await deleteProfile(profile.dir);
+  p.log.success(`Deleted profile "${profile.name}".`);
+}

package/src/commands/edit.ts

@@ -0,0 +1,21 @@
+import * as p from "@clack/prompts";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { selectProfile } from "./shared.ts";
+
+export async function editProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Which profile to edit?", nameArg);
+  if (!profile) return;
+
+  const settingsPath = join(profile.dir, "settings.json");
+  const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+
+  p.log.info(`Opening ${settingsPath} in ${editor}...`);
+
+  try {
+    execSync(`${editor} "${settingsPath}"`, { stdio: "inherit" });
+    p.log.success("Settings updated.");
+  } catch {
+    p.log.error("Editor exited with an error.");
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,29 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { getAllProfiles } from "../profiles.ts";
+import { isActiveProfile } from "../utils.ts";
+
+export async function listProfiles(): Promise<void> {
+  const profiles = await getAllProfiles();
+
+  if (profiles.length === 0) {
+    p.log.warn("No profiles found. Create one with `claude-profiles create`.");
+    return;
+  }
+
+  p.log.info(pc.bold("Claude Code Profiles"));
+
+  for (const profile of profiles) {
+    const active = isActiveProfile(profile.dir);
+    const marker = active ? pc.green("●") : pc.dim("○");
+    const name = active ? pc.green(pc.bold(profile.name)) : profile.name;
+    const details: string[] = [];
+    if (profile.email) details.push(profile.email);
+    // Only show org name if it's not just the email repeated
+    if (profile.orgName && !profile.orgName.includes(profile.email ?? ""))
+      details.push(profile.orgName);
+    const detailStr = details.length > 0 ? pc.dim(` (${details.join(" — ")})`) : "";
+
+    p.log.message(`${marker} ${name}${detailStr}`);
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,31 @@
+import * as p from "@clack/prompts";
+import { execFileSync } from "node:child_process";
+import { selectProfile } from "./shared.ts";
+
+export async function runProfileCommand(
+  nameArg?: string,
+  extraArgs: string[] = [],
+): Promise<void> {
+  const profile = await selectProfile("Run Claude with which profile?", nameArg);
+  if (!profile) return;
+
+  const claudeCmd = "claude";
+  p.log.info(
+    `Running: CLAUDE_CONFIG_DIR=${profile.dir} ${claudeCmd} ${extraArgs.join(" ")}`,
+  );
+
+  try {
+    execFileSync(claudeCmd, extraArgs, {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: profile.dir,
+      },
+    });
+  } catch (err: unknown) {
+    const code = (err as { status?: number }).status;
+    if (code !== null && code !== undefined) {
+      process.exit(code);
+    }
+  }
+}

package/src/commands/shared.ts

@@ -0,0 +1,45 @@
+import * as p from "@clack/prompts";
+import { getAllProfiles, type ProfileInfo } from "../profiles.ts";
+import { formatProfileOption } from "../utils.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function selectProfile(
+  message: string,
+  nameArg?: string,
+): Promise<ProfileInfo | null> {
+  const profiles = await getAllProfiles();
+
+  if (profiles.length === 0) {
+    p.log.warn("No profiles found. Create one first.");
+    return null;
+  }
+
+  if (nameArg) {
+    const match = profiles.find((prof) => prof.name === nameArg);
+    if (!match) {
+      p.log.error(
+        `Profile "${nameArg}" not found. Available: ${profiles.map((p) => p.name).join(", ")}`,
+      );
+      return null;
+    }
+    return match;
+  }
+
+  const selected = await p.select({
+    message,
+    options: profiles.map((prof) => ({
+      value: prof.dir,
+      label: formatProfileOption(prof.dir, prof.email),
+    })),
+  });
+
+  if (isCancel(selected)) {
+    p.cancel("Cancelled.");
+    return null;
+  }
+
+  return profiles.find((prof) => prof.dir === selected) ?? null;
+}

package/src/commands/switch.ts

@@ -0,0 +1,19 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { selectProfile } from "./shared.ts";
+
+export async function switchProfileCommand(nameArg?: string): Promise<void> {
+  const profile = await selectProfile("Switch to which profile?", nameArg);
+  if (!profile) return;
+
+  p.log.info("To activate this profile, run:");
+  p.log.message(
+    pc.cyan(`export CLAUDE_CONFIG_DIR=${profile.dir}`),
+  );
+  p.log.info("Or add an alias to your shell config:");
+  p.log.message(
+    pc.cyan(
+      `alias claude-${profile.name}='CLAUDE_CONFIG_DIR=${profile.dir} claude'`,
+    ),
+  );
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { listProfiles } from "./commands/list.ts";
+import { createProfileCommand } from "./commands/create.ts";
+import { editProfileCommand } from "./commands/edit.ts";
+import { cloneProfileCommand } from "./commands/clone.ts";
+import { deleteProfileCommand } from "./commands/delete.ts";
+import { switchProfileCommand } from "./commands/switch.ts";
+import { runProfileCommand } from "./commands/run.ts";
+
+function isCancel(value: unknown): value is symbol {
+  return p.isCancel(value);
+}
+
+export async function main(): Promise<void> {
+  p.intro(pc.bgCyan(pc.black(" claude-profiles ")));
+
+  while (true) {
+    const action = await p.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "list", label: "List profiles" },
+        { value: "create", label: "Create profile" },
+        { value: "edit", label: "Edit profile" },
+        { value: "clone", label: "Clone profile" },
+        { value: "delete", label: "Delete profile" },
+        { value: "switch", label: "Switch active profile" },
+        { value: "run", label: "Run Claude with profile" },
+        { value: "exit", label: "Exit" },
+      ],
+    });
+
+    if (isCancel(action) || action === "exit") {
+      p.outro("Goodbye!");
+      return;
+    }
+
+    switch (action) {
+      case "list":
+        await listProfiles();
+        break;
+      case "create":
+        await createProfileCommand();
+        break;
+      case "edit":
+        await editProfileCommand();
+        break;
+      case "clone":
+        await cloneProfileCommand();
+        break;
+      case "delete":
+        await deleteProfileCommand();
+        break;
+      case "switch":
+        await switchProfileCommand();
+        break;
+      case "run":
+        await runProfileCommand();
+        break;
+    }
+  }
+}

package/src/profiles.ts

@@ -0,0 +1,137 @@
+import { join } from "node:path";
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  rm,
+  readdir,
+  copyFile,
+  stat,
+} from "node:fs/promises";
+import { getProfileDir, discoverProfiles, profileNameFromDir } from "./utils.ts";
+
+export interface ProfileInfo {
+  name: string;
+  dir: string;
+  email: string | null;
+  orgName: string | null;
+  hasSettings: boolean;
+}
+
+async function exists(path: string): Promise<boolean> {
+  return stat(path)
+    .then(() => true)
+    .catch(() => false);
+}
+
+export async function readClaudeJson(
+  dir: string,
+): Promise<Record<string, unknown> | null> {
+  try {
+    const raw = await readFile(join(dir, ".claude.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function readSettings(
+  dir: string,
+): Promise<Record<string, unknown> | null> {
+  try {
+    const raw = await readFile(join(dir, "settings.json"), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function getProfileInfo(dir: string): Promise<ProfileInfo> {
+  const claudeJson = await readClaudeJson(dir);
+  const settings = await readSettings(dir);
+  const oauth = claudeJson?.oauthAccount as
+    | Record<string, unknown>
+    | undefined;
+
+  return {
+    name: profileNameFromDir(dir),
+    dir,
+    email: (oauth?.emailAddress as string) ?? null,
+    orgName: (oauth?.organizationName as string) ?? null,
+    hasSettings: settings !== null,
+  };
+}
+
+export async function getAllProfiles(): Promise<ProfileInfo[]> {
+  const dirs = await discoverProfiles();
+  return Promise.all(dirs.map(getProfileInfo));
+}
+
+export async function createProfile(name: string): Promise<string> {
+  const dir = getProfileDir(name);
+  if (await exists(dir)) {
+    throw new Error(`Profile "${name}" already exists at ${dir}`);
+  }
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "settings.json"), "{}\n");
+  return dir;
+}
+
+// Directories and files to copy when cloning (config-only, no session data)
+const CLONE_ITEMS = [
+  "settings.json",
+  "CLAUDE.md",
+  "commands",
+  "hooks",
+  "agents",
+  "skills",
+  "output-styles",
+];
+
+async function copyDir(src: string, dest: string): Promise<void> {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+
+export async function cloneProfile(
+  sourceDir: string,
+  newName: string,
+): Promise<string> {
+  const destDir = getProfileDir(newName);
+  if (await exists(destDir)) {
+    throw new Error(`Profile "${newName}" already exists at ${destDir}`);
+  }
+  await mkdir(destDir, { recursive: true });
+
+  for (const item of CLONE_ITEMS) {
+    const srcPath = join(sourceDir, item);
+    const destPath = join(destDir, item);
+    const s = await stat(srcPath).catch(() => null);
+    if (!s) continue;
+
+    if (s.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+    }
+  }
+
+  return destDir;
+}
+
+export async function deleteProfile(dir: string): Promise<void> {
+  await rm(dir, { recursive: true, force: true });
+}
+
+export async function profileExists(name: string): Promise<boolean> {
+  return exists(getProfileDir(name));
+}

package/src/utils.ts

@@ -0,0 +1,66 @@
+import { homedir } from "node:os";
+import { join, basename } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+import pc from "picocolors";
+
+export const HOME = homedir();
+export const CLAUDE_DIR_PREFIX = ".claude-";
+export const EXCLUDED_DIRS = new Set(["worktrees"]);
+
+export function getProfileDir(name: string): string {
+  return join(HOME, `${CLAUDE_DIR_PREFIX}${name}`);
+}
+
+export function profileNameFromDir(dir: string): string {
+  return basename(dir).replace(CLAUDE_DIR_PREFIX, "");
+}
+
+export function getActiveProfileDir(): string | null {
+  return process.env.CLAUDE_CONFIG_DIR || null;
+}
+
+export function isActiveProfile(dir: string): boolean {
+  const active = getActiveProfileDir();
+  if (!active) return false;
+  // Normalize ~ and trailing slashes
+  const normalize = (p: string) =>
+    p.replace(/^~/, HOME).replace(/\/+$/, "");
+  return normalize(active) === normalize(dir);
+}
+
+export async function discoverProfiles(): Promise<string[]> {
+  const entries = await readdir(HOME);
+  const profiles: string[] = [];
+
+  for (const entry of entries) {
+    if (!entry.startsWith(CLAUDE_DIR_PREFIX)) continue;
+    const name = entry.slice(CLAUDE_DIR_PREFIX.length);
+    if (EXCLUDED_DIRS.has(name)) continue;
+
+    const fullPath = join(HOME, entry);
+    const s = await stat(fullPath).catch(() => null);
+    if (s?.isDirectory()) {
+      profiles.push(fullPath);
+    }
+  }
+
+  return profiles.sort();
+}
+
+export function formatProfileName(dir: string): string {
+  const name = profileNameFromDir(dir);
+  const active = isActiveProfile(dir);
+  return active ? pc.green(`${name} (active)`) : name;
+}
+
+export function formatProfileOption(
+  dir: string,
+  email?: string | null,
+): string {
+  const name = profileNameFromDir(dir);
+  const active = isActiveProfile(dir);
+  const parts: string[] = [name];
+  if (email) parts.push(pc.dim(`(${email})`));
+  if (active) parts.push(pc.green("● active"));
+  return parts.join(" ");
+}