@leynier/ccst 0.2.1 → 0.3.1

package/src/index.ts

@@ -1,146 +1,185 @@
 #!/usr/bin/env bun
 import { Command } from "commander";
-import { getPaths } from "./utils/paths.js";
-import { ContextManager } from "./core/context-manager.js";
-import { resolveSettingsLevel } from "./core/settings-level.js";
-import { listCommand } from "./commands/list.js";
-import { switchCommand, switchPreviousCommand } from "./commands/switch.js";
+import { completionsCommand } from "./commands/completions.js";
+import { configDumpCommand } from "./commands/config/dump.js";
+import { configLoadCommand } from "./commands/config/load.js";
 import { createCommand } from "./commands/create.js";
 import { deleteCommand } from "./commands/delete.js";
-import { renameCommand } from "./commands/rename.js";
 import { editCommand } from "./commands/edit.js";
-import { showCommand } from "./commands/show.js";
 import { exportCommand } from "./commands/export.js";
 import { importCommand } from "./commands/import.js";
-import { unsetCommand } from "./commands/unset.js";
-import { mergeCommand, mergeHistoryCommand, unmergeCommand } from "./commands/merge.js";
-import { completionsCommand } from "./commands/completions.js";
 import { importFromCcs } from "./commands/import-profiles/ccs.js";
 import { importFromConfigs } from "./commands/import-profiles/configs.js";
+import { listCommand } from "./commands/list.js";
+import {
+	mergeCommand,
+	mergeHistoryCommand,
+	unmergeCommand,
+} from "./commands/merge.js";
+import { renameCommand } from "./commands/rename.js";
+import { showCommand } from "./commands/show.js";
+import { switchCommand, switchPreviousCommand } from "./commands/switch.js";
+import { unsetCommand } from "./commands/unset.js";
+import { ContextManager } from "./core/context-manager.js";
+import { resolveSettingsLevel } from "./core/settings-level.js";
+import { getPaths } from "./utils/paths.js";
 
 export const program = new Command();
 
 const main = async (): Promise<void> => {
-  program
-    .name("ccst")
-    .description("Claude Code Switch Tools")
-    .argument("[context]", "context name")
-    .option("-d, --delete", "delete context")
-    .option("-c, --current", "print current context")
-    .option("-r, --rename", "rename context")
-    .option("-n, --new", "create new context")
-    .option("-e, --edit", "edit context")
-    .option("-s, --show", "show context")
-    .option("--export", "export context to stdout")
-    .option("--import", "import context from stdin")
-    .option("-u, --unset", "unset current context")
-    .option("--completions <shell>", "generate completions")
-    .option("-q, --quiet", "show only current context")
-    .option("--in-project", "use project settings level")
-    .option("--local", "use local settings level")
-    .option("--merge-from <source>", "merge permissions from source")
-    .option("--unmerge <source>", "remove permissions merged from source")
-    .option("--merge-history", "show merge history")
-    .option("--merge-full", "merge full settings")
-    .allowExcessArguments(false)
-    .action(async (context: string | undefined, options: Record<string, unknown>) => {
-      if (options.completions) {
-        completionsCommand(options.completions as string);
-        return;
-      }
-      const level = resolveSettingsLevel(options);
-      const manager = new ContextManager(getPaths(level));
-      if (options.current) {
-        const current = await manager.getCurrentContext();
-        if (current) {
-          console.log(current);
-        }
-        return;
-      }
-      if (options.unset) {
-        await unsetCommand(manager);
-        return;
-      }
-      if (options.delete) {
-        await deleteCommand(manager, context);
-        return;
-      }
-      if (options.rename) {
-        await renameCommand(manager, context);
-        return;
-      }
-      if (options.new) {
-        if (!context) {
-          await manager.interactiveCreateContext();
-          return;
-        }
-        await createCommand(manager, context);
-        return;
-      }
-      if (options.edit) {
-        await editCommand(manager, context);
-        return;
-      }
-      if (options.show) {
-        await showCommand(manager, context);
-        return;
-      }
-      if (options.export) {
-        await exportCommand(manager, context);
-        return;
-      }
-      if (options.import) {
-        await importCommand(manager, context);
-        return;
-      }
-      if (options.mergeFrom) {
-        await mergeCommand(manager, options.mergeFrom as string, context, options.mergeFull as boolean);
-        return;
-      }
-      if (options.unmerge) {
-        await unmergeCommand(manager, options.unmerge as string, context, options.mergeFull as boolean);
-        return;
-      }
-      if (options.mergeHistory) {
-        await mergeHistoryCommand(manager, context);
-        return;
-      }
-      if (context === "-") {
-        await switchPreviousCommand(manager);
-        return;
-      }
-      if (context) {
-        await switchCommand(manager, context);
-        return;
-      }
-      if (process.env.CCTX_INTERACTIVE === "1") {
-        await manager.interactiveSelect();
-        return;
-      }
-      await listCommand(manager, options.quiet as boolean);
-    });
-  const importCommandGroup = program.command("import").description("import profiles");
-  importCommandGroup
-    .command("ccs")
-    .description("import from CCS settings")
-    .option("-d, --configs-dir <dir>", "configs directory")
-    .action(async (options) => {
-      const manager = new ContextManager(getPaths("user"));
-      await importFromCcs(manager, options.configsDir);
-    });
-  importCommandGroup
-    .command("configs")
-    .description("import from configs directory")
-    .option("-d, --configs-dir <dir>", "configs directory")
-    .action(async (options) => {
-      const manager = new ContextManager(getPaths("user"));
-      await importFromConfigs(manager, options.configsDir);
-    });
-  try {
-    await program.parseAsync(process.argv);
-  } catch {
-    return;
-  }
+	program
+		.name("ccst")
+		.description("Claude Code Switch Tools")
+		.argument("[context]", "context name")
+		.option("-d, --delete", "delete context")
+		.option("-c, --current", "print current context")
+		.option("-r, --rename", "rename context")
+		.option("-n, --new", "create new context")
+		.option("-e, --edit", "edit context")
+		.option("-s, --show", "show context")
+		.option("--export", "export context to stdout")
+		.option("--import", "import context from stdin")
+		.option("-u, --unset", "unset current context")
+		.option("--completions <shell>", "generate completions")
+		.option("-q, --quiet", "show only current context")
+		.option("--in-project", "use project settings level")
+		.option("--local", "use local settings level")
+		.option("--merge-from <source>", "merge permissions from source")
+		.option("--unmerge <source>", "remove permissions merged from source")
+		.option("--merge-history", "show merge history")
+		.option("--merge-full", "merge full settings")
+		.allowExcessArguments(false)
+		.action(
+			async (context: string | undefined, options: Record<string, unknown>) => {
+				if (options.completions) {
+					completionsCommand(options.completions as string);
+					return;
+				}
+				const level = resolveSettingsLevel(options);
+				const manager = new ContextManager(getPaths(level));
+				if (options.current) {
+					const current = await manager.getCurrentContext();
+					if (current) {
+						console.log(current);
+					}
+					return;
+				}
+				if (options.unset) {
+					await unsetCommand(manager);
+					return;
+				}
+				if (options.delete) {
+					await deleteCommand(manager, context);
+					return;
+				}
+				if (options.rename) {
+					await renameCommand(manager, context);
+					return;
+				}
+				if (options.new) {
+					if (!context) {
+						await manager.interactiveCreateContext();
+						return;
+					}
+					await createCommand(manager, context);
+					return;
+				}
+				if (options.edit) {
+					await editCommand(manager, context);
+					return;
+				}
+				if (options.show) {
+					await showCommand(manager, context);
+					return;
+				}
+				if (options.export) {
+					await exportCommand(manager, context);
+					return;
+				}
+				if (options.import) {
+					await importCommand(manager, context);
+					return;
+				}
+				if (options.mergeFrom) {
+					await mergeCommand(
+						manager,
+						options.mergeFrom as string,
+						context,
+						options.mergeFull as boolean,
+					);
+					return;
+				}
+				if (options.unmerge) {
+					await unmergeCommand(
+						manager,
+						options.unmerge as string,
+						context,
+						options.mergeFull as boolean,
+					);
+					return;
+				}
+				if (options.mergeHistory) {
+					await mergeHistoryCommand(manager, context);
+					return;
+				}
+				if (context === "-") {
+					await switchPreviousCommand(manager);
+					return;
+				}
+				if (context) {
+					await switchCommand(manager, context);
+					return;
+				}
+				if (process.env.CCTX_INTERACTIVE === "1") {
+					await manager.interactiveSelect();
+					return;
+				}
+				await listCommand(manager, options.quiet as boolean);
+			},
+		);
+	const importCommandGroup = program
+		.command("import")
+		.description("import profiles");
+	importCommandGroup
+		.command("ccs")
+		.description("import from CCS settings")
+		.option("-d, --configs-dir <dir>", "configs directory")
+		.action(async (options) => {
+			const manager = new ContextManager(getPaths("user"));
+			await importFromCcs(manager, options.configsDir);
+		});
+	importCommandGroup
+		.command("configs")
+		.description("import from configs directory")
+		.option("-d, --configs-dir <dir>", "configs directory")
+		.action(async (options) => {
+			const manager = new ContextManager(getPaths("user"));
+			await importFromConfigs(manager, options.configsDir);
+		});
+	const configCommandGroup = program
+		.command("config")
+		.description("CCS config backup/restore");
+	configCommandGroup
+		.command("dump")
+		.description("export CCS config to zip")
+		.argument("[output]", "output path", "ccs-config.zip")
+		.action(async (output) => {
+			await configDumpCommand(output);
+		});
+	configCommandGroup
+		.command("load")
+		.description("import CCS config from zip")
+		.argument("[input]", "input path", "ccs-config.zip")
+		.option("-r, --replace", "replace all existing files")
+		.option("-y, --yes", "skip confirmation prompt")
+		.action(async (input, options) => {
+			await configLoadCommand(input, options);
+		});
+	try {
+		await program.parseAsync(process.argv);
+	} catch {
+		return;
+	}
 };
 
 await main();

package/src/types/index.ts

@@ -1,14 +1,14 @@
 export type SettingsLevel = "user" | "project" | "local";
 
 export type State = {
-  current?: string;
-  previous?: string;
+	current?: string;
+	previous?: string;
 };
 
 export type MergeHistoryEntry = {
-  source: string;
-  mergedItems: string[];
-  timestamp: string;
+	source: string;
+	mergedItems: string[];
+	timestamp: string;
 };
 
 export type MergeHistory = MergeHistoryEntry[];

package/src/utils/ccs-paths.ts

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative } from "node:path";
+
+// Cross-platform CCS home directory
+export const getCcsHome = (): string => join(homedir(), ".ccs");
+
+// File patterns to backup
+export type CcsBackupFiles = {
+	config: string | null;
+	settingsProfiles: string[];
+	cliproxyAccounts: string | null;
+	cliproxyConfig: string | null;
+	cliproxyAuthFiles: string[];
+};
+
+// Helper to safely read directory contents
+const safeReaddirSync = (dirPath: string): string[] => {
+	try {
+		return readdirSync(dirPath);
+	} catch {
+		return [];
+	}
+};
+
+// Get all files to backup from CCS directory
+export const getCcsBackupFiles = (): CcsBackupFiles => {
+	const ccsHome = getCcsHome();
+	const result: CcsBackupFiles = {
+		config: null,
+		settingsProfiles: [],
+		cliproxyAccounts: null,
+		cliproxyConfig: null,
+		cliproxyAuthFiles: [],
+	};
+	if (!existsSync(ccsHome)) {
+		return result;
+	}
+	// config.yaml
+	const configPath = join(ccsHome, "config.yaml");
+	if (existsSync(configPath)) {
+		result.config = configPath;
+	}
+	// *.settings.json profiles
+	const rootFiles = safeReaddirSync(ccsHome);
+	for (const file of rootFiles) {
+		if (file.endsWith(".settings.json")) {
+			result.settingsProfiles.push(join(ccsHome, file));
+		}
+	}
+	// cliproxy files
+	const cliproxyDir = join(ccsHome, "cliproxy");
+	if (existsSync(cliproxyDir)) {
+		const accountsPath = join(cliproxyDir, "accounts.json");
+		if (existsSync(accountsPath)) {
+			result.cliproxyAccounts = accountsPath;
+		}
+		const configPath = join(cliproxyDir, "config.yaml");
+		if (existsSync(configPath)) {
+			result.cliproxyConfig = configPath;
+		}
+		// cliproxy/auth/*.json
+		const authDir = join(cliproxyDir, "auth");
+		if (existsSync(authDir)) {
+			const authFiles = safeReaddirSync(authDir);
+			for (const file of authFiles) {
+				if (file.endsWith(".json")) {
+					result.cliproxyAuthFiles.push(join(authDir, file));
+				}
+			}
+		}
+	}
+	return result;
+};
+
+// Get relative path from CCS home for zip storage (always use forward slashes)
+export const getRelativePath = (absolutePath: string): string => {
+	const ccsHome = getCcsHome();
+	const relativePath = relative(ccsHome, absolutePath);
+	// Convert to forward slashes for zip compatibility (works on all platforms)
+	return relativePath.replace(/\\/g, "/");
+};
+
+// Ensure directory exists for a file path (cross-platform)
+export const ensureDirectoryExists = (filePath: string): void => {
+	const dir = dirname(filePath);
+	if (dir && dir !== "." && !existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+};
+
+// Get all backup file paths as a flat array
+export const getAllBackupFilePaths = (): string[] => {
+	const files = getCcsBackupFiles();
+	const paths: string[] = [];
+	if (files.config) {
+		paths.push(files.config);
+	}
+	paths.push(...files.settingsProfiles);
+	if (files.cliproxyAccounts) {
+		paths.push(files.cliproxyAccounts);
+	}
+	if (files.cliproxyConfig) {
+		paths.push(files.cliproxyConfig);
+	}
+	paths.push(...files.cliproxyAuthFiles);
+	return paths;
+};
+
+// Get files that would be deleted in replace mode
+export const getFilesToDelete = (): {
+	profiles: string[];
+	authFiles: string[];
+} => {
+	const files = getCcsBackupFiles();
+	return {
+		profiles: files.settingsProfiles,
+		authFiles: files.cliproxyAuthFiles,
+	};
+};

package/src/utils/colors.ts

@@ -1,10 +1,10 @@
 import pc from "picocolors";
 
 export const colors = {
-  green: pc.green,
-  red: pc.red,
-  cyan: pc.cyan,
-  yellow: pc.yellow,
-  bold: pc.bold,
-  dim: pc.dim,
+	green: pc.green,
+	red: pc.red,
+	cyan: pc.cyan,
+	yellow: pc.yellow,
+	bold: pc.bold,
+	dim: pc.dim,
 };

package/src/utils/deep-merge.ts

@@ -1,22 +1,25 @@
-export const deepMerge = (base: Record<string, unknown>, override: Record<string, unknown>): Record<string, unknown> => {
-  const result: Record<string, unknown> = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    const baseValue = result[key];
-    if (isPlainObject(baseValue) && isPlainObject(value)) {
-      result[key] = deepMerge(baseValue, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
+export const deepMerge = (
+	base: Record<string, unknown>,
+	override: Record<string, unknown>,
+): Record<string, unknown> => {
+	const result: Record<string, unknown> = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		const baseValue = result[key];
+		if (isPlainObject(baseValue) && isPlainObject(value)) {
+			result[key] = deepMerge(baseValue, value);
+		} else {
+			result[key] = value;
+		}
+	}
+	return result;
 };
 
 const isPlainObject = (value: unknown): value is Record<string, unknown> => {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
-  }
-  return Object.getPrototypeOf(value) === Object.prototype;
+	if (value === null || typeof value !== "object") {
+		return false;
+	}
+	if (Array.isArray(value)) {
+		return false;
+	}
+	return Object.getPrototypeOf(value) === Object.prototype;
 };

package/src/utils/interactive.ts

@@ -1,69 +1,81 @@
 import { spawnSync } from "node:child_process";
 
 const hasFzf = (): boolean => {
-  const which = spawnSync("which", ["fzf"], { stdio: "ignore" });
-  return which.status === 0 && Boolean(process.env.TERM);
+	const which = spawnSync("which", ["fzf"], { stdio: "ignore" });
+	return which.status === 0 && Boolean(process.env.TERM);
 };
 
-export const selectContext = async (contexts: string[], current?: string): Promise<string | undefined> => {
-  if (contexts.length === 0) {
-    return undefined;
-  }
-  if (hasFzf()) {
-    const input = contexts.join("\n");
-    const result = spawnSync("fzf", [], { input, encoding: "utf8", stdio: ["pipe", "pipe", "inherit"] });
-    if (result.status !== 0) {
-      return undefined;
-    }
-    const selected = String(result.stdout).trim();
-    return selected.length > 0 ? selected : undefined;
-  }
-  return promptSelect(contexts, current);
+export const selectContext = async (
+	contexts: string[],
+	current?: string,
+): Promise<string | undefined> => {
+	if (contexts.length === 0) {
+		return undefined;
+	}
+	if (hasFzf()) {
+		const input = contexts.join("\n");
+		const result = spawnSync("fzf", [], {
+			input,
+			encoding: "utf8",
+			stdio: ["pipe", "pipe", "inherit"],
+		});
+		if (result.status !== 0) {
+			return undefined;
+		}
+		const selected = String(result.stdout).trim();
+		return selected.length > 0 ? selected : undefined;
+	}
+	return promptSelect(contexts, current);
 };
 
-const promptSelect = async (contexts: string[], current?: string): Promise<string | undefined> => {
-  const lines = contexts.map((ctx, index) => {
-    const marker = current && ctx === current ? " (current)" : "";
-    return `${index + 1}. ${ctx}${marker}`;
-  });
-  process.stdout.write(`${lines.join("\n")}\nSelect a context (number): `);
-  const input = await readStdinLine();
-  const index = Number.parseInt(input, 10);
-  if (!Number.isFinite(index) || index < 1 || index > contexts.length) {
-    return undefined;
-  }
-  return contexts[index - 1];
+const promptSelect = async (
+	contexts: string[],
+	current?: string,
+): Promise<string | undefined> => {
+	const lines = contexts.map((ctx, index) => {
+		const marker = current && ctx === current ? " (current)" : "";
+		return `${index + 1}. ${ctx}${marker}`;
+	});
+	process.stdout.write(`${lines.join("\n")}\nSelect a context (number): `);
+	const input = await readStdinLine();
+	const index = Number.parseInt(input, 10);
+	if (!Number.isFinite(index) || index < 1 || index > contexts.length) {
+		return undefined;
+	}
+	return contexts[index - 1];
 };
 
-export const promptInput = async (label: string): Promise<string | undefined> => {
-  process.stdout.write(`${label}: `);
-  const input = await readStdinLine();
-  const trimmed = input.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
+export const promptInput = async (
+	label: string,
+): Promise<string | undefined> => {
+	process.stdout.write(`${label}: `);
+	const input = await readStdinLine();
+	const trimmed = input.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
 };
 
 const readStdinLine = async (): Promise<string> => {
-  return new Promise((resolve) => {
-    const chunks: Buffer[] = [];
-    const onData = (chunk: Buffer) => {
-      chunks.push(chunk);
-      if (chunk.includes(10)) {
-        cleanup();
-        resolve(Buffer.concat(chunks).toString("utf8").trim());
-      }
-    };
-    const onEnd = () => {
-      cleanup();
-      resolve(Buffer.concat(chunks).toString("utf8").trim());
-    };
-    const cleanup = () => {
-      process.stdin.off("data", onData);
-      process.stdin.off("end", onEnd);
-    };
-    if (process.stdin.isTTY) {
-      process.stdin.resume();
-    }
-    process.stdin.on("data", onData);
-    process.stdin.on("end", onEnd);
-  });
+	return new Promise((resolve) => {
+		const chunks: Buffer[] = [];
+		const onData = (chunk: Buffer) => {
+			chunks.push(chunk);
+			if (chunk.includes(10)) {
+				cleanup();
+				resolve(Buffer.concat(chunks).toString("utf8").trim());
+			}
+		};
+		const onEnd = () => {
+			cleanup();
+			resolve(Buffer.concat(chunks).toString("utf8").trim());
+		};
+		const cleanup = () => {
+			process.stdin.off("data", onData);
+			process.stdin.off("end", onEnd);
+		};
+		if (process.stdin.isTTY) {
+			process.stdin.resume();
+		}
+		process.stdin.on("data", onData);
+		process.stdin.on("end", onEnd);
+	});
 };