@aeriondyseti/claude-profiles 0.1.0-dev.9

package/src/commands/unbind.ts

@@ -0,0 +1,27 @@
+import * as p from "@clack/prompts";
+import { rm, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { PROFILE_FILENAME, parseProfileFile } from "../detect.ts";
+
+export async function unbindCommand(pathArg?: string): Promise<void> {
+  const dir = resolve(pathArg ?? process.cwd());
+  const filePath = join(dir, PROFILE_FILENAME);
+
+  const exists = await stat(filePath)
+    .then(() => true)
+    .catch(() => false);
+
+  if (!exists) {
+    p.log.warn(`No ${PROFILE_FILENAME} found in ${dir}`);
+    return;
+  }
+
+  const profileName = await parseProfileFile(filePath);
+  await rm(filePath);
+
+  if (profileName) {
+    p.log.success(`Removed profile binding '${profileName}' from ${dir}`);
+  } else {
+    p.log.success(`Removed ${PROFILE_FILENAME} from ${dir}`);
+  }
+}

package/src/detect.test.ts

@@ -0,0 +1,174 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, writeFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { parseProfileFile, detectProfile, PROFILE_FILENAME } from "./detect.ts";
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await mkdtemp(join(tmpdir(), "claude-profiles-test-"));
+});
+
+afterEach(async () => {
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+describe("parseProfileFile", () => {
+  test("parses valid TOML with profile key", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "work"\n');
+    expect(await parseProfileFile(filePath)).toBe("work");
+  });
+
+  test("trims whitespace from profile name", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "  work  "\n');
+    expect(await parseProfileFile(filePath)).toBe("work");
+  });
+
+  test("returns null for missing file", async () => {
+    const filePath = join(tempDir, "nonexistent");
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null for empty file", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, "");
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null when profile key is missing", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'other = "value"\n');
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null when profile key is not a string", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, "profile = 42\n");
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null when profile is empty string", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = ""\n');
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null when profile is only whitespace", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "   "\n');
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("returns null for invalid TOML", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, "not valid toml {{{}}}");
+    expect(await parseProfileFile(filePath)).toBeNull();
+  });
+
+  test("handles TOML with extra keys", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "work"\nextra = "data"\n');
+    expect(await parseProfileFile(filePath)).toBe("work");
+  });
+});
+
+describe("detectProfile", () => {
+  test("finds .claude-profile in current directory", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "work"\n');
+
+    const originalCwd = process.cwd();
+    process.chdir(tempDir);
+    try {
+      const result = await detectProfile();
+      expect(result).not.toBeNull();
+      expect(result!.name).toBe("work");
+      expect(result!.filePath).toBe(filePath);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  test("finds .claude-profile in ancestor directory", async () => {
+    const filePath = join(tempDir, PROFILE_FILENAME);
+    await writeFile(filePath, 'profile = "ancestor"\n');
+
+    const nested = join(tempDir, "a", "b", "c");
+    await mkdir(nested, { recursive: true });
+
+    const originalCwd = process.cwd();
+    process.chdir(nested);
+    try {
+      const result = await detectProfile();
+      expect(result).not.toBeNull();
+      expect(result!.name).toBe("ancestor");
+      expect(result!.filePath).toBe(filePath);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  test("returns closest .claude-profile when multiple exist", async () => {
+    // Parent has one profile
+    await writeFile(join(tempDir, PROFILE_FILENAME), 'profile = "parent"\n');
+
+    // Child has a different profile
+    const child = join(tempDir, "child");
+    await mkdir(child);
+    await writeFile(join(child, PROFILE_FILENAME), 'profile = "child"\n');
+
+    const originalCwd = process.cwd();
+    process.chdir(child);
+    try {
+      const result = await detectProfile();
+      expect(result).not.toBeNull();
+      expect(result!.name).toBe("child");
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  test("returns null when no .claude-profile exists", async () => {
+    const nested = join(tempDir, "empty");
+    await mkdir(nested);
+
+    const originalCwd = process.cwd();
+    process.chdir(nested);
+    try {
+      // This will walk up to / and not find anything
+      // (unless the test runner's machine has one, which is unlikely in temp)
+      const result = await detectProfile();
+      // We can't guarantee null here since it walks to /, but we can test
+      // that it doesn't find one in our temp tree by checking the path
+      if (result) {
+        // If found, it should NOT be in our tempDir (since we didn't create one in "empty")
+        expect(result.filePath.startsWith(tempDir + "/empty")).toBe(false);
+      }
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  test("skips invalid .claude-profile files during walk", async () => {
+    // Child has invalid file
+    const child = join(tempDir, "child");
+    await mkdir(child);
+    await writeFile(join(child, PROFILE_FILENAME), "not valid toml {{{");
+
+    // Parent has valid file
+    await writeFile(join(tempDir, PROFILE_FILENAME), 'profile = "parent"\n');
+
+    const originalCwd = process.cwd();
+    process.chdir(child);
+    try {
+      const result = await detectProfile();
+      expect(result).not.toBeNull();
+      expect(result!.name).toBe("parent");
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});

package/src/detect.ts

@@ -0,0 +1,44 @@
+import { readFile } from "node:fs/promises";
+import { join, dirname, parse as parsePath } from "node:path";
+import { parse as parseToml } from "smol-toml";
+
+export const PROFILE_FILENAME = ".claude-profile";
+
+export interface DetectedProfile {
+  name: string;
+  filePath: string;
+}
+
+export async function parseProfileFile(
+  filePath: string,
+): Promise<string | null> {
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const data = parseToml(raw);
+    const profile = data.profile;
+    if (typeof profile === "string" && profile.trim()) {
+      return profile.trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function detectProfile(): Promise<DetectedProfile | null> {
+  let dir = process.cwd();
+
+  while (true) {
+    const filePath = join(dir, PROFILE_FILENAME);
+    const name = await parseProfileFile(filePath);
+    if (name) {
+      return { name, filePath };
+    }
+
+    const parent = dirname(dir);
+    if (parent === dir) break; // reached filesystem root
+    dir = parent;
+  }
+
+  return null;
+}

package/src/index.ts

@@ -0,0 +1,72 @@
+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";
+import { bindProfileCommand } from "./commands/bind.ts";
+import { unbindCommand } from "./commands/unbind.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: "bind", label: "Bind profile to directory" },
+        { value: "unbind", label: "Unbind profile from directory" },
+        { 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;
+      case "bind":
+        await bindProfileCommand();
+        break;
+      case "unbind":
+        await unbindCommand();
+        break;
+    }
+  }
+}

package/src/profiles.test.ts

@@ -0,0 +1,45 @@
+import { describe, test, expect } from "bun:test";
+import { defaultSettings } from "./profiles.ts";
+
+describe("defaultSettings", () => {
+  test("includes env with all three default vars", () => {
+    const settings = defaultSettings("test-profile");
+    const env = settings.env as Record<string, string>;
+    expect(env).toBeDefined();
+    expect(env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS).toBe("1");
+    expect(env.ENABLE_CLAUDEAI_MCP_SERVERS).toBe("false");
+    expect(env.CLAUDE_CODE_DISABLE_AUTO_MEMORY).toBe("1");
+  });
+
+  test("includes exactly three env vars", () => {
+    const settings = defaultSettings("test");
+    const env = settings.env as Record<string, string>;
+    expect(Object.keys(env)).toHaveLength(3);
+  });
+
+  test("includes SessionStart hook with profile name", () => {
+    const settings = defaultSettings("my-work");
+    const hooks = settings.hooks as Record<string, unknown[]>;
+    expect(hooks).toBeDefined();
+    expect(hooks.SessionStart).toBeArray();
+
+    const hookEntry = hooks.SessionStart[0] as Record<string, unknown>;
+    const hookList = hookEntry.hooks as Array<Record<string, string>>;
+    expect(hookList[0].command).toContain("my-work");
+  });
+
+  test("embeds profile name in hook command", () => {
+    const settings = defaultSettings("special");
+    const hooks = settings.hooks as Record<string, unknown[]>;
+    const hookEntry = hooks.SessionStart[0] as Record<string, unknown>;
+    const hookList = hookEntry.hooks as Array<Record<string, string>>;
+    expect(hookList[0].command).toContain("'special'");
+  });
+
+  test("returns a new object each time", () => {
+    const a = defaultSettings("test");
+    const b = defaultSettings("test");
+    expect(a).not.toBe(b);
+    expect(a).toEqual(b);
+  });
+});

package/src/profiles.ts

@@ -0,0 +1,174 @@
+import { join } from "node:path";
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  rm,
+  readdir,
+  copyFile,
+  stat,
+} from "node:fs/promises";
+import { getProfileDir, discoverProfiles, profileNameFromDir, DEFAULT_PROFILE_NAME, DEFAULT_PROFILE_DIR, HOME } 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);
+}
+
+function claudeJsonPath(dir: string): string {
+  // The default profile (~/.claude) stores .claude.json in ~ instead of inside the config dir
+  if (dir === DEFAULT_PROFILE_DIR) {
+    return join(HOME, ".claude.json");
+  }
+  return join(dir, ".claude.json");
+}
+
+export async function readClaudeJson(
+  dir: string,
+): Promise<Record<string, unknown> | null> {
+  try {
+    const raw = await readFile(claudeJsonPath(dir), "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 function defaultSettings(profileName: string): Record<string, unknown> {
+  return {
+    env: {
+      CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: "1",
+      ENABLE_CLAUDEAI_MCP_SERVERS: "false",
+      CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1",
+    },
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "",
+          hooks: [
+            {
+              type: "command",
+              command: `echo "claude-profiles: active profile is '${profileName}' ($CLAUDE_CONFIG_DIR)"`,
+            },
+          ],
+        },
+      ],
+    },
+  };
+}
+
+export async function createProfile(name: string): Promise<string> {
+  if (name === DEFAULT_PROFILE_NAME) {
+    throw new Error(`Cannot create a profile named "${DEFAULT_PROFILE_NAME}" — it refers to the built-in ~/.claude directory`);
+  }
+  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"),
+    JSON.stringify(defaultSettings(name), null, 2) + "\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.test.ts

@@ -0,0 +1,134 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import {
+  getProfileDir,
+  profileNameFromDir,
+  getActiveProfileDir,
+  isActiveProfile,
+  HOME,
+  CLAUDE_DIR_PREFIX,
+  DEFAULT_PROFILE_NAME,
+  DEFAULT_PROFILE_DIR,
+} from "./utils.ts";
+import { join } from "node:path";
+
+describe("getProfileDir", () => {
+  test("returns ~/.claude for default profile", () => {
+    expect(getProfileDir("default")).toBe(join(HOME, ".claude"));
+  });
+
+  test("returns ~/.claude-<name> for named profiles", () => {
+    expect(getProfileDir("work")).toBe(join(HOME, ".claude-work"));
+  });
+
+  test("handles hyphens in profile names", () => {
+    expect(getProfileDir("my-project")).toBe(join(HOME, ".claude-my-project"));
+  });
+
+  test("handles underscores in profile names", () => {
+    expect(getProfileDir("my_project")).toBe(join(HOME, ".claude-my_project"));
+  });
+});
+
+describe("profileNameFromDir", () => {
+  test("returns 'default' for ~/.claude", () => {
+    expect(profileNameFromDir(DEFAULT_PROFILE_DIR)).toBe("default");
+  });
+
+  test("returns 'default' for any path ending in .claude", () => {
+    expect(profileNameFromDir("/some/path/.claude")).toBe("default");
+  });
+
+  test("extracts name from ~/.claude-<name> path", () => {
+    expect(profileNameFromDir(join(HOME, ".claude-work"))).toBe("work");
+  });
+
+  test("extracts hyphenated names correctly", () => {
+    expect(profileNameFromDir(join(HOME, ".claude-my-project"))).toBe(
+      "my-project",
+    );
+  });
+});
+
+describe("getActiveProfileDir", () => {
+  const originalEnv = process.env.CLAUDE_CONFIG_DIR;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.CLAUDE_CONFIG_DIR = originalEnv;
+    } else {
+      delete process.env.CLAUDE_CONFIG_DIR;
+    }
+  });
+
+  test("returns null when CLAUDE_CONFIG_DIR is not set", () => {
+    delete process.env.CLAUDE_CONFIG_DIR;
+    expect(getActiveProfileDir()).toBeNull();
+  });
+
+  test("returns null when CLAUDE_CONFIG_DIR is empty", () => {
+    process.env.CLAUDE_CONFIG_DIR = "";
+    expect(getActiveProfileDir()).toBeNull();
+  });
+
+  test("returns the value of CLAUDE_CONFIG_DIR", () => {
+    process.env.CLAUDE_CONFIG_DIR = "/home/user/.claude-work";
+    expect(getActiveProfileDir()).toBe("/home/user/.claude-work");
+  });
+});
+
+describe("isActiveProfile", () => {
+  const originalEnv = process.env.CLAUDE_CONFIG_DIR;
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.CLAUDE_CONFIG_DIR = originalEnv;
+    } else {
+      delete process.env.CLAUDE_CONFIG_DIR;
+    }
+  });
+
+  test("returns false when no profile is active", () => {
+    delete process.env.CLAUDE_CONFIG_DIR;
+    expect(isActiveProfile(join(HOME, ".claude-work"))).toBe(false);
+  });
+
+  test("returns true for matching profile dir", () => {
+    const dir = join(HOME, ".claude-work");
+    process.env.CLAUDE_CONFIG_DIR = dir;
+    expect(isActiveProfile(dir)).toBe(true);
+  });
+
+  test("returns false for non-matching profile dir", () => {
+    process.env.CLAUDE_CONFIG_DIR = join(HOME, ".claude-work");
+    expect(isActiveProfile(join(HOME, ".claude-personal"))).toBe(false);
+  });
+
+  test("normalizes trailing slashes", () => {
+    const dir = join(HOME, ".claude-work");
+    process.env.CLAUDE_CONFIG_DIR = dir + "/";
+    expect(isActiveProfile(dir)).toBe(true);
+  });
+
+  test("normalizes tilde in env var", () => {
+    process.env.CLAUDE_CONFIG_DIR = "~/.claude-work";
+    expect(isActiveProfile(join(HOME, ".claude-work"))).toBe(true);
+  });
+});
+
+describe("constants", () => {
+  test("HOME is set", () => {
+    expect(HOME).toBeTruthy();
+  });
+
+  test("CLAUDE_DIR_PREFIX is .claude-", () => {
+    expect(CLAUDE_DIR_PREFIX).toBe(".claude-");
+  });
+
+  test("DEFAULT_PROFILE_NAME is 'default'", () => {
+    expect(DEFAULT_PROFILE_NAME).toBe("default");
+  });
+
+  test("DEFAULT_PROFILE_DIR is HOME/.claude", () => {
+    expect(DEFAULT_PROFILE_DIR).toBe(join(HOME, ".claude"));
+  });
+});