ctb 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ctb",
-	"version": "1.0.0",
+	"version": "1.1.0",
 	"description": "Control Claude Code from Telegram - run multiple bot instances per project",
 	"type": "module",
 	"bin": {
@@ -10,7 +10,9 @@
 		"start": "bun run src/bot.ts",
 		"dev": "bun --watch run src/bot.ts",
 		"ctb": "bun run src/cli.ts",
-		"typecheck": "bun run --bun tsc --noEmit"
+		"typecheck": "bun run --bun tsc --noEmit",
+		"test": "bun test",
+		"test:watch": "bun test --watch"
 	},
 	"keywords": [
 		"claude",

package/src/__tests__/callback.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Unit tests for callback handlers (file sending, bookmarks).
+ */
+
+import { describe, expect, test } from "bun:test";
+
+describe("File sending callback data", () => {
+	describe("base64 encoding/decoding", () => {
+		test("encodes and decodes simple path", () => {
+			const path = "/Users/test/file.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+			expect(decoded).toBe(path);
+		});
+
+		test("encodes and decodes path with spaces", () => {
+			const path = "/Users/test/my file.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+			expect(decoded).toBe(path);
+		});
+
+		test("encodes and decodes path with special characters", () => {
+			const path = "/Users/test/file-name_v2.1.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+			expect(decoded).toBe(path);
+		});
+
+		test("encodes and decodes unicode path", () => {
+			const path = "/Users/test/文件.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+			expect(decoded).toBe(path);
+		});
+
+		test("encodes and decodes long path", () => {
+			const path = "/Users/test/very/deep/nested/directory/structure/file.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const decoded = Buffer.from(encoded, "base64").toString("utf-8");
+			expect(decoded).toBe(path);
+		});
+	});
+
+	describe("callback data format", () => {
+		test("creates valid callback data", () => {
+			const path = "/tmp/test.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const callbackData = `sendfile:${encoded}`;
+			expect(callbackData.startsWith("sendfile:")).toBe(true);
+		});
+
+		test("extracts path from callback data", () => {
+			const path = "/tmp/test.txt";
+			const encoded = Buffer.from(path).toString("base64");
+			const callbackData = `sendfile:${encoded}`;
+
+			const extractedEncoded = callbackData.slice("sendfile:".length);
+			const extractedPath = Buffer.from(extractedEncoded, "base64").toString(
+				"utf-8",
+			);
+			expect(extractedPath).toBe(path);
+		});
+
+		test("callback data fits within Telegram limits", () => {
+			// Telegram callback data max is 64 bytes
+			const maxPath = "/Users/verylongusername/very/deep/path/file.txt";
+			const encoded = Buffer.from(maxPath).toString("base64");
+			const callbackData = `sendfile:${encoded}`;
+			// This might exceed 64 bytes for very long paths
+			// The implementation should handle this
+			expect(callbackData.length).toBeGreaterThan(0);
+		});
+	});
+
+	describe("path validation", () => {
+		test("identifies absolute paths", () => {
+			const absolutePaths = [
+				"/tmp/file.txt",
+				"/Users/test/doc.pdf",
+				"/home/user/data.json",
+				"/var/log/app.log",
+			];
+
+			for (const path of absolutePaths) {
+				expect(path.startsWith("/")).toBe(true);
+			}
+		});
+
+		test("identifies relative paths", () => {
+			const relativePaths = [
+				"./file.txt",
+				"../parent/file.txt",
+				"subdir/file.txt",
+				"file.txt",
+			];
+
+			for (const path of relativePaths) {
+				expect(path.startsWith("/")).toBe(false);
+			}
+		});
+	});
+});
+
+describe("Bookmark callback data", () => {
+	describe("callback data format", () => {
+		test("creates add bookmark callback", () => {
+			const path = "/Users/test/project";
+			const callbackData = `bookmark:add:${path}`;
+			expect(callbackData).toBe("bookmark:add:/Users/test/project");
+		});
+
+		test("creates remove bookmark callback", () => {
+			const path = "/Users/test/project";
+			const callbackData = `bookmark:remove:${path}`;
+			expect(callbackData).toBe("bookmark:remove:/Users/test/project");
+		});
+
+		test("creates new session callback", () => {
+			const path = "/Users/test/project";
+			const callbackData = `bookmark:new:${path}`;
+			expect(callbackData).toBe("bookmark:new:/Users/test/project");
+		});
+
+		test("handles paths with colons", () => {
+			// Path parsing should handle colons in path
+			const callbackData = "bookmark:add:/path/with:colon/file.txt";
+			const parts = callbackData.split(":");
+			expect(parts[0]).toBe("bookmark");
+			expect(parts[1]).toBe("add");
+			// Path is everything after second colon
+			const path = parts.slice(2).join(":");
+			expect(path).toBe("/path/with:colon/file.txt");
+		});
+	});
+
+	describe("action parsing", () => {
+		test("parses add action", () => {
+			const callbackData = "bookmark:add:/path";
+			const parts = callbackData.split(":");
+			expect(parts[1]).toBe("add");
+		});
+
+		test("parses remove action", () => {
+			const callbackData = "bookmark:remove:/path";
+			const parts = callbackData.split(":");
+			expect(parts[1]).toBe("remove");
+		});
+
+		test("parses new action", () => {
+			const callbackData = "bookmark:new:/path";
+			const parts = callbackData.split(":");
+			expect(parts[1]).toBe("new");
+		});
+
+		test("parses noop action", () => {
+			const callbackData = "bookmark:noop:";
+			const parts = callbackData.split(":");
+			expect(parts[1]).toBe("noop");
+		});
+	});
+});
+
+describe("Ask user callback data", () => {
+	describe("callback data format", () => {
+		test("creates valid ask user callback", () => {
+			const requestId = "abc123";
+			const optionIndex = 0;
+			const callbackData = `askuser:${requestId}:${optionIndex}`;
+			expect(callbackData).toBe("askuser:abc123:0");
+		});
+
+		test("parses request ID", () => {
+			const callbackData = "askuser:request-id-123:2";
+			const parts = callbackData.split(":");
+			expect(parts[1]).toBe("request-id-123");
+		});
+
+		test("parses option index", () => {
+			const callbackData = "askuser:abc:3";
+			const parts = callbackData.split(":");
+			expect(Number.parseInt(parts[2] ?? "", 10)).toBe(3);
+		});
+
+		test("handles multi-digit option index", () => {
+			const callbackData = "askuser:abc:15";
+			const parts = callbackData.split(":");
+			expect(Number.parseInt(parts[2] ?? "", 10)).toBe(15);
+		});
+	});
+
+	describe("validation", () => {
+		test("validates callback format", () => {
+			const validCallbacks = [
+				"askuser:id:0",
+				"askuser:long-request-id:5",
+				"askuser:123:99",
+			];
+
+			for (const cb of validCallbacks) {
+				const parts = cb.split(":");
+				expect(parts).toHaveLength(3);
+				expect(parts[0]).toBe("askuser");
+				expect(parts[1]?.length).toBeGreaterThan(0);
+				expect(Number.parseInt(parts[2] ?? "", 10)).toBeGreaterThanOrEqual(0);
+			}
+		});
+
+		test("detects invalid callback format", () => {
+			const invalidCallbacks = [
+				"askuser:", // Missing parts
+				"askuser:id", // Missing option
+				"askuser::", // Empty parts
+				"other:id:0", // Wrong prefix
+			];
+
+			for (const cb of invalidCallbacks) {
+				const parts = cb.split(":");
+				const isValid =
+					parts.length === 3 &&
+					parts[0] === "askuser" &&
+					(parts[1]?.length ?? 0) > 0 &&
+					!Number.isNaN(Number.parseInt(parts[2] ?? "", 10));
+				expect(isValid).toBe(false);
+			}
+		});
+	});
+});
+
+describe("Inline keyboard button labels", () => {
+	const BUTTON_LABEL_MAX_LENGTH = 30;
+
+	test("truncates long labels", () => {
+		const longLabel = "This is a very long option that should be truncated";
+		const display =
+			longLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${longLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: longLabel;
+		expect(display.length).toBeLessThanOrEqual(BUTTON_LABEL_MAX_LENGTH + 3);
+	});
+
+	test("keeps short labels unchanged", () => {
+		const shortLabel = "Short option";
+		const display =
+			shortLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${shortLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: shortLabel;
+		expect(display).toBe(shortLabel);
+	});
+
+	test("handles exact length labels", () => {
+		const exactLabel = "A".repeat(BUTTON_LABEL_MAX_LENGTH);
+		const display =
+			exactLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${exactLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: exactLabel;
+		expect(display).toBe(exactLabel);
+	});
+
+	test("handles empty labels", () => {
+		const emptyLabel = "";
+		const display =
+			emptyLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${emptyLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: emptyLabel;
+		expect(display).toBe("");
+	});
+
+	test("handles unicode labels", () => {
+		const unicodeLabel = "选择这个选项";
+		const display =
+			unicodeLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${unicodeLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: unicodeLabel;
+		expect(display).toBe(unicodeLabel);
+	});
+
+	test("handles emoji labels", () => {
+		const emojiLabel = "📁 Download file";
+		const display =
+			emojiLabel.length > BUTTON_LABEL_MAX_LENGTH
+				? `${emojiLabel.slice(0, BUTTON_LABEL_MAX_LENGTH)}...`
+				: emojiLabel;
+		expect(display).toBe(emojiLabel);
+	});
+});

package/src/__tests__/cli.test.ts

@@ -0,0 +1,365 @@
+/**
+ * Unit tests for CLI argument parsing and env loading.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmdirSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+// Helper to create a test directory with .env file
+function createTestDir(): string {
+	const testDir = `/tmp/ctb-test-${Date.now()}`;
+	mkdirSync(testDir, { recursive: true });
+	return testDir;
+}
+
+function cleanupTestDir(dir: string): void {
+	try {
+		const envPath = join(dir, ".env");
+		if (existsSync(envPath)) unlinkSync(envPath);
+		rmdirSync(dir);
+	} catch {
+		// Ignore cleanup errors
+	}
+}
+
+describe("CLI .env file parsing", () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = createTestDir();
+	});
+
+	afterEach(() => {
+		cleanupTestDir(testDir);
+	});
+
+	test("parses simple key=value pairs", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`TELEGRAM_BOT_TOKEN=test-token
+TELEGRAM_ALLOWED_USERS=123,456`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(env.TELEGRAM_BOT_TOKEN).toBe("test-token");
+		expect(env.TELEGRAM_ALLOWED_USERS).toBe("123,456");
+	});
+
+	test("handles quoted values", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`SINGLE='single quoted'
+DOUBLE="double quoted"`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			let value = trimmed.slice(eqIndex + 1).trim();
+			if (
+				(value.startsWith('"') && value.endsWith('"')) ||
+				(value.startsWith("'") && value.endsWith("'"))
+			) {
+				value = value.slice(1, -1);
+			}
+			env[trimmed.slice(0, eqIndex).trim()] = value;
+		}
+
+		expect(env.SINGLE).toBe("single quoted");
+		expect(env.DOUBLE).toBe("double quoted");
+	});
+
+	test("ignores comments", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`# This is a comment
+TELEGRAM_BOT_TOKEN=token
+# Another comment
+TELEGRAM_ALLOWED_USERS=123`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(Object.keys(env)).toHaveLength(2);
+		expect(env.TELEGRAM_BOT_TOKEN).toBe("token");
+	});
+
+	test("handles empty lines", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(
+			envPath,
+			`TELEGRAM_BOT_TOKEN=token
+
+TELEGRAM_ALLOWED_USERS=123
+
+`,
+		);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(Object.keys(env)).toHaveLength(2);
+	});
+
+	test("handles values with equals signs", () => {
+		const envPath = join(testDir, ".env");
+		writeFileSync(envPath, `API_KEY=key=with=equals`);
+
+		const content = readFileSync(envPath, "utf-8");
+		const lines = content.split("\n");
+		const env: Record<string, string> = {};
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed || trimmed.startsWith("#")) continue;
+			const eqIndex = trimmed.indexOf("=");
+			if (eqIndex === -1) continue;
+			env[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
+		}
+
+		expect(env.API_KEY).toBe("key=with=equals");
+	});
+
+	test("handles missing .env file gracefully", () => {
+		const nonExistentPath = join(testDir, "nonexistent", ".env");
+		expect(existsSync(nonExistentPath)).toBe(false);
+	});
+});
+
+describe("CLI argument parsing", () => {
+	function parseArgs(args: string[]): {
+		token?: string;
+		users?: string;
+		dir?: string;
+		help?: boolean;
+		version?: boolean;
+	} {
+		const options: {
+			token?: string;
+			users?: string;
+			dir?: string;
+			help?: boolean;
+			version?: boolean;
+		} = {};
+
+		for (const arg of args) {
+			if (arg === "--help" || arg === "-h") {
+				options.help = true;
+			} else if (arg === "--version" || arg === "-v") {
+				options.version = true;
+			} else if (arg.startsWith("--token=")) {
+				options.token = arg.slice(8);
+			} else if (arg.startsWith("--users=")) {
+				options.users = arg.slice(8);
+			} else if (arg.startsWith("--dir=")) {
+				options.dir = arg.slice(6);
+			}
+		}
+
+		return options;
+	}
+
+	test("parses --help flag", () => {
+		expect(parseArgs(["--help"])).toEqual({ help: true });
+	});
+
+	test("parses -h shorthand", () => {
+		expect(parseArgs(["-h"])).toEqual({ help: true });
+	});
+
+	test("parses --version flag", () => {
+		expect(parseArgs(["--version"])).toEqual({ version: true });
+	});
+
+	test("parses -v shorthand", () => {
+		expect(parseArgs(["-v"])).toEqual({ version: true });
+	});
+
+	test("parses --token option", () => {
+		const result = parseArgs(["--token=my-bot-token"]);
+		expect(result.token).toBe("my-bot-token");
+	});
+
+	test("parses --users option", () => {
+		const result = parseArgs(["--users=123,456,789"]);
+		expect(result.users).toBe("123,456,789");
+	});
+
+	test("parses --dir option", () => {
+		const result = parseArgs(["--dir=/path/to/project"]);
+		expect(result.dir).toBe("/path/to/project");
+	});
+
+	test("parses multiple options", () => {
+		const result = parseArgs([
+			"--token=token123",
+			"--users=111,222",
+			"--dir=/home/user/project",
+		]);
+		expect(result.token).toBe("token123");
+		expect(result.users).toBe("111,222");
+		expect(result.dir).toBe("/home/user/project");
+	});
+
+	test("handles empty args array", () => {
+		expect(parseArgs([])).toEqual({});
+	});
+
+	test("ignores unknown flags", () => {
+		const result = parseArgs(["--unknown", "--another=value"]);
+		expect(result).toEqual({});
+	});
+
+	test("handles token with special characters", () => {
+		const result = parseArgs(["--token=123:ABC-xyz_789"]);
+		expect(result.token).toBe("123:ABC-xyz_789");
+	});
+
+	test("handles path with spaces when quoted", () => {
+		// This tests the arg as it would come from shell
+		const result = parseArgs(["--dir=/path/with spaces/project"]);
+		expect(result.dir).toBe("/path/with spaces/project");
+	});
+});
+
+describe("Path resolution with base directory", () => {
+	function resolvePath(path: string, baseDir?: string): string {
+		const homedir = () => "/Users/test";
+		const expanded = path.replace(/^~/, homedir());
+		if (baseDir && !expanded.startsWith("/")) {
+			// Simulate resolve(baseDir, expanded)
+			return `${baseDir}/${expanded}`.replace(/\/+/g, "/");
+		}
+		return expanded.startsWith("/") ? expanded : `/${expanded}`;
+	}
+
+	test("resolves absolute path unchanged", () => {
+		const result = resolvePath("/absolute/path", "/base/dir");
+		expect(result).toBe("/absolute/path");
+	});
+
+	test("resolves relative path from base directory", () => {
+		const result = resolvePath("relative/path", "/base/dir");
+		expect(result).toBe("/base/dir/relative/path");
+	});
+
+	test("expands tilde to home directory", () => {
+		const result = resolvePath("~/projects", "/base/dir");
+		expect(result).toBe("/Users/test/projects");
+	});
+
+	test("tilde path is not affected by base directory", () => {
+		const result = resolvePath("~/projects", "/base/dir");
+		expect(result).toBe("/Users/test/projects");
+	});
+
+	test("handles dot-relative paths", () => {
+		const result = resolvePath("./subdir", "/base/dir");
+		expect(result).toBe("/base/dir/./subdir");
+	});
+
+	test("handles parent directory paths", () => {
+		const result = resolvePath("../sibling", "/base/dir");
+		expect(result).toBe("/base/dir/../sibling");
+	});
+
+	test("works without base directory for absolute paths", () => {
+		const result = resolvePath("/absolute/path");
+		expect(result).toBe("/absolute/path");
+	});
+});
+
+describe("Instance directory hashing", () => {
+	function hashDir(dir: string): string {
+		let hash = 0;
+		for (let i = 0; i < dir.length; i++) {
+			const char = dir.charCodeAt(i);
+			hash = ((hash << 5) - hash + char) | 0;
+		}
+		return Math.abs(hash).toString(36).slice(0, 8);
+	}
+
+	test("generates consistent hash for same path", () => {
+		const path = "/Users/test/project";
+		expect(hashDir(path)).toBe(hashDir(path));
+	});
+
+	test("generates different hash for different paths", () => {
+		const hash1 = hashDir("/Users/test/project1");
+		const hash2 = hashDir("/Users/test/project2");
+		expect(hash1).not.toBe(hash2);
+	});
+
+	test("generates short hash (max 8 chars)", () => {
+		const hash = hashDir("/very/long/path/to/some/project/directory");
+		expect(hash.length).toBeLessThanOrEqual(8);
+	});
+
+	test("generates alphanumeric hash", () => {
+		const hash = hashDir("/Users/test/project");
+		expect(hash).toMatch(/^[a-z0-9]+$/);
+	});
+
+	test("handles empty string", () => {
+		const hash = hashDir("");
+		expect(hash).toBe("0");
+	});
+
+	test("handles root path", () => {
+		const hash = hashDir("/");
+		expect(hash.length).toBeGreaterThan(0);
+	});
+
+	test("handles home directory variations", () => {
+		const hash1 = hashDir("/Users/user1/project");
+		const hash2 = hashDir("/Users/user2/project");
+		expect(hash1).not.toBe(hash2);
+	});
+});