@fcannizzaro/exocommand 1.0.10 → 1.1.0

package/dist/index.js

@@ -2,20 +2,122 @@
 import { watch } from "node:fs";
 import { createServer as createHttpServer } from "node:http";
 import { createRequire } from "node:module";
+import { resolve, join, dirname, basename } from "node:path";
+import { stat } from "node:fs/promises";
 import { getRequestListener } from "@hono/node-server";
 import {} from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { createServer } from "./server.js";
+import { parseArgs } from "./cli.js";
 import { loadConfig, configExists, createSampleConfig } from "./config.js";
-import { logger } from "./logger.js";
+import { logger, createTuiLogger } from "./logger.js";
+import { addProject, removeProject, removeProjectByPath, listProjects, resolveProject, getRegistryPath, } from "./registry.js";
+import { createServer } from "./server.js";
+import { createTui } from "./tui.js";
 const _require = createRequire(import.meta.url);
 const { version } = _require("../package.json");
-const CONFIG_PATH = process.env.EXO_COMMAND_FILE || "./.exocommand";
+// ANSI styling for CLI output
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const MAGENTA = "\x1b[35m";
 const transports = new Map();
 const servers = new Set();
+// Session -> accessKey mapping
+const sessionProject = new Map();
+// AccessKey -> Set<McpServer> (for targeted config-change notifications)
+const projectServers = new Map();
+// Per-project .exocommand file watchers
+const configWatchers = new Map();
+const configTimers = new Map();
 let nextAgentId = 0;
 let taskMode = false;
+let tui = null;
+let activeLogger = logger;
+// -- Per-project config file watchers -------------------------------------
+function ensureConfigWatcher(accessKey, configPath) {
+    if (configWatchers.has(accessKey))
+        return;
+    const watcher = watch(configPath, (eventType) => {
+        if (eventType !== "change")
+            return;
+        const existing = configTimers.get(accessKey);
+        if (existing)
+            clearTimeout(existing);
+        configTimers.set(accessKey, setTimeout(() => {
+            configTimers.delete(accessKey);
+            activeLogger.info("watcher", `${configPath} changed, notifying project ${accessKey}`);
+            const projectSet = projectServers.get(accessKey);
+            if (projectSet) {
+                for (const server of projectSet) {
+                    try {
+                        server.sendToolListChanged();
+                    }
+                    catch {
+                        // client may have disconnected
+                    }
+                }
+            }
+        }, 200));
+    });
+    configWatchers.set(accessKey, watcher);
+    activeLogger.info("watcher", `watching ${configPath} (project: ${accessKey})`);
+}
+function stopConfigWatcher(accessKey) {
+    const watcher = configWatchers.get(accessKey);
+    if (watcher) {
+        watcher.close();
+        configWatchers.delete(accessKey);
+    }
+    const timer = configTimers.get(accessKey);
+    if (timer) {
+        clearTimeout(timer);
+        configTimers.delete(accessKey);
+    }
+    activeLogger.info("watcher", `stopped watching project ${accessKey}`);
+}
+// Sync config watchers with the current registry state
+async function syncConfigWatchers() {
+    const registry = await listProjects();
+    const registeredKeys = new Set(Object.keys(registry));
+    // Start watchers for newly registered projects
+    for (const [accessKey, configPath] of Object.entries(registry)) {
+        ensureConfigWatcher(accessKey, configPath);
+    }
+    // Stop watchers for projects no longer in the registry
+    for (const accessKey of configWatchers.keys()) {
+        if (!registeredKeys.has(accessKey)) {
+            stopConfigWatcher(accessKey);
+        }
+    }
+}
+// -- Registry file watcher (detect add/rm from other processes) -----------
+function watchRegistry() {
+    const registryPath = getRegistryPath();
+    let debounceTimer = null;
+    try {
+        watch(registryPath, (eventType) => {
+            if (eventType !== "change")
+                return;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            debounceTimer = setTimeout(async () => {
+                debounceTimer = null;
+                activeLogger.info("registry", "registry changed, reloading project list");
+                await syncConfigWatchers();
+            }, 200);
+        });
+        activeLogger.info("registry", "watching exocommand.db.json for changes");
+    }
+    catch {
+        // registry file may not exist yet; it will be created on first add
+        activeLogger.warn("registry", "registry file not found, skipping watch");
+    }
+}
+// -- MCP request handler --------------------------------------------------
 async function handleMcp(req) {
     const url = new URL(req.url);
     if (url.pathname !== "/mcp") {
@@ -35,33 +137,103 @@ async function handleMcp(req) {
         return transports.get(sessionId).handleRequest(req);
     }
     if (req.method === "POST") {
-        // reuse existing session
+        // Reuse existing session
         if (sessionId && transports.has(sessionId)) {
             return transports.get(sessionId).handleRequest(req);
         }
-        // parse body to check if it's an initialize request
+        // Parse body to check if it's an initialize request
         const body = await req.json();
         if (!sessionId && isInitializeRequest(body)) {
+            // Extract project access key from header
+            const accessKey = req.headers.get("exocommand-project");
+            if (!accessKey) {
+                return Response.json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Missing exocommand-project header",
+                    },
+                    id: null,
+                }, { status: 400 });
+            }
+            // Resolve config path from registry
+            let configPath;
+            try {
+                configPath = await resolveProject(accessKey);
+            }
+            catch {
+                return Response.json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: `Unknown project key: ${accessKey}`,
+                    },
+                    id: null,
+                }, { status: 400 });
+            }
+            // Verify the .exocommand file still exists
+            if (!(await configExists(configPath))) {
+                return Response.json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: `Config file not found: ${configPath} (project may have been moved or deleted)`,
+                    },
+                    id: null,
+                }, { status: 400 });
+            }
             const agentId = ++nextAgentId;
-            const agentLogger = logger.withAgent(agentId);
+            const agentLogger = activeLogger.withAgent(agentId);
+            const projectLabel = basename(dirname(configPath));
             const transport = new WebStandardStreamableHTTPServerTransport({
                 sessionIdGenerator: () => crypto.randomUUID(),
                 onsessioninitialized: (sid) => {
                     transports.set(sid, transport);
-                    agentLogger.info("session", `created ${sid}`);
+                    sessionProject.set(sid, accessKey);
+                    // Track this server under the project
+                    if (!projectServers.has(accessKey)) {
+                        projectServers.set(accessKey, new Set());
+                    }
+                    const isFirstSession = projectServers.get(accessKey).size === 0;
+                    projectServers.get(accessKey).add(server);
+                    // Notify TUI about new project on first session
+                    if (isFirstSession) {
+                        tui?.addProject(accessKey, projectLabel);
+                    }
+                    // Start watching this project's config if not already watched
+                    ensureConfigWatcher(accessKey, configPath);
+                    agentLogger.info("session", `created ${sid} (project: ${accessKey})`);
                 },
                 onsessionclosed: (sid) => {
                     transports.delete(sid);
+                    sessionProject.delete(sid);
                     agentLogger.warn("session", `closed ${sid}`);
                 },
             });
-            const server = createServer(agentLogger, { taskMode });
+            const server = createServer(agentLogger, {
+                configPath,
+                taskMode,
+                tui,
+                agentId,
+                projectKey: accessKey,
+            });
             servers.add(server);
             transport.onclose = () => {
                 if (transport.sessionId) {
                     transports.delete(transport.sessionId);
+                    sessionProject.delete(transport.sessionId);
                 }
                 servers.delete(server);
+                // Remove from project tracking
+                const projectSet = projectServers.get(accessKey);
+                if (projectSet) {
+                    projectSet.delete(server);
+                    if (projectSet.size === 0) {
+                        projectServers.delete(accessKey);
+                        stopConfigWatcher(accessKey);
+                        tui?.removeProject(accessKey);
+                    }
+                }
             };
             await server.connect(transport);
             return transport.handleRequest(req, { parsedBody: body });
@@ -77,29 +249,96 @@ async function handleMcp(req) {
     }
     return new Response("Method Not Allowed", { status: 405 });
 }
-async function main() {
-    logger.banner(version);
-    if (!(await configExists(CONFIG_PATH))) {
-        await createSampleConfig(CONFIG_PATH);
-        logger.info("setup", `created sample config at ${CONFIG_PATH}`);
-        logger.info("setup", "edit the file with your commands, then restart the server");
-        process.exit(0);
-    }
-    let config;
+// -- CLI command handlers -------------------------------------------------
+async function handleAdd(rawPath) {
+    let resolved = resolve(rawPath);
+    const fileStat = await stat(resolved).catch(() => null);
+    if (fileStat?.isDirectory()) {
+        resolved = join(resolved, ".exocommand");
+    }
+    if (!(await configExists(resolved))) {
+        console.error(`\n  ${RED}${BOLD}✗${RESET} Config file not found: ${DIM}${resolved}${RESET}\n`);
+        process.exit(1);
+    }
     try {
-        config = await loadConfig(CONFIG_PATH);
+        await loadConfig(resolved);
     }
     catch (err) {
-        logger.error("startup", `Failed to load config from ${CONFIG_PATH}: ${err.message}`);
+        console.error(`\n  ${RED}${BOLD}✗${RESET} Invalid config: ${err.message}\n`);
         process.exit(1);
     }
-    const PORT = parseInt(process.env.EXO_PORT || String(config.port ?? 5555), 10);
-    // Resolve task mode: env var overrides config
+    const accessKey = await addProject(resolved);
+    console.log(`
+  ${GREEN}${BOLD}✓${RESET} Project registered
+
+    ${DIM}Key${RESET}     ${CYAN}${BOLD}${accessKey}${RESET}
+    ${DIM}Header${RESET}  ${DIM}exocommand-project: ${accessKey}${RESET}
+    ${DIM}Config${RESET}  ${DIM}${resolved}${RESET}
+`);
+}
+async function handleLs() {
+    const registry = await listProjects();
+    const entries = Object.entries(registry);
+    if (entries.length === 0) {
+        console.log(`\n  ${DIM}No projects registered.${RESET}\n`);
+        return;
+    }
+    const keyWidth = 14;
+    console.log(`\n  ${BOLD}${MAGENTA}KEY${RESET}${" ".repeat(keyWidth - 3)}${BOLD}${MAGENTA}PATH${RESET}`);
+    console.log(`  ${DIM}${"─".repeat(keyWidth)}${"─".repeat(40)}${RESET}`);
+    for (const [key, filePath] of entries) {
+        const exists = await configExists(filePath);
+        const pathDisplay = exists
+            ? `${DIM}${filePath}${RESET}`
+            : `${DIM}${filePath} ${RED}(missing)${RESET}`;
+        console.log(`  ${CYAN}${BOLD}${key}${RESET}${" ".repeat(keyWidth - key.length)}${pathDisplay}`);
+    }
+    console.log();
+}
+async function handleRm(target) {
+    // Detect if target is a path (contains / or . or \) vs an access key
+    const isPath = target.includes("/") || target.includes("\\") || target === ".";
+    try {
+        if (isPath) {
+            let resolved = resolve(target);
+            const fileStat = await stat(resolved).catch(() => null);
+            if (fileStat?.isDirectory()) {
+                resolved = join(resolved, ".exocommand");
+            }
+            await removeProjectByPath(resolved);
+            console.log(`\n  ${GREEN}${BOLD}✓${RESET} Project removed ${DIM}(${resolved})${RESET}\n`);
+        }
+        else {
+            await removeProject(target);
+            console.log(`\n  ${GREEN}${BOLD}✓${RESET} Project ${CYAN}${BOLD}${target}${RESET} removed\n`);
+        }
+    }
+    catch (err) {
+        console.error(`\n  ${RED}${BOLD}✗${RESET} ${err.message}\n`);
+        process.exit(1);
+    }
+}
+async function handleInit() {
+    const configPath = resolve(".exocommand");
+    if (await configExists(configPath)) {
+        console.error(`\n  ${RED}${BOLD}✗${RESET} Config file already exists: ${DIM}${configPath}${RESET}\n`);
+        process.exit(1);
+    }
+    await createSampleConfig(configPath);
+    console.log(`\n  ${GREEN}${BOLD}✓${RESET} Created ${DIM}${configPath}${RESET}\n`);
+}
+// -- Server startup -------------------------------------------------------
+async function startServer() {
+    if (process.stdout.isTTY) {
+        tui = await createTui(version);
+        activeLogger = createTuiLogger(tui);
+    }
+    const PORT = parseInt(process.env.EXO_PORT || "5555", 10);
+    tui?.setPort(PORT);
+    // Resolve task mode from env
     const envTaskMode = process.env.EXO_TASK_MODE;
-    taskMode = envTaskMode !== undefined
-        ? envTaskMode === "true" || envTaskMode === "1"
-        : config.taskMode ?? false;
-    logger.info("startup", `execution mode: ${taskMode ? "task" : "streaming"}`);
+    taskMode = envTaskMode === "true" || envTaskMode === "1";
+    activeLogger.info("startup", `execution mode: ${taskMode ? "task" : "streaming"}`);
     try {
         const listener = getRequestListener(handleMcp, {
             overrideGlobalObjects: false,
@@ -110,33 +349,39 @@ async function main() {
         httpServer.listen(PORT, "127.0.0.1");
     }
     catch (err) {
-        logger.error("startup", `Failed to start server on port ${PORT}: ${err.message}`);
+        activeLogger.error("startup", `Failed to start server on port ${PORT}: ${err.message}`);
+        tui?.destroy();
         process.exit(1);
     }
-    logger.info("server", `listening on http://127.0.0.1:${PORT}/mcp`);
-    // Watch .exocommand for changes and notify connected clients
-    let debounceTimer = null;
-    watch(CONFIG_PATH, (eventType) => {
-        if (eventType !== "change")
+    activeLogger.info("server", `listening on http://127.0.0.1:${PORT}/mcp`);
+    // Watch the registry file for changes from other CLI processes
+    watchRegistry();
+    // Start watching all currently registered project configs
+    await syncConfigWatchers();
+}
+// -- Main entry point -----------------------------------------------------
+async function main() {
+    const action = parseArgs(process.argv);
+    switch (action.kind) {
+        case "add":
+            await handleAdd(action.path);
             return;
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-            debounceTimer = null;
-            logger.info("watcher", ".exocommand changed, notifying clients");
-            for (const server of servers) {
-                try {
-                    server.sendToolListChanged();
-                }
-                catch {
-                    // client may have disconnected
-                }
-            }
-        }, 200);
-    });
-    logger.info("watcher", `watching ${CONFIG_PATH} for changes`);
+        case "init":
+            await handleInit();
+            return;
+        case "ls":
+            await handleLs();
+            return;
+        case "rm":
+            await handleRm(action.target);
+            return;
+        case "serve":
+            await startServer();
+            return;
+    }
 }
 main().catch((err) => {
+    tui?.destroy();
     logger.error("fatal", `Unexpected error: ${err.message}`);
     process.exit(1);
 });

package/dist/logger.js

@@ -36,23 +36,36 @@ function createLogger(agentId) {
 }
 export const logger = {
     ...createLogger(),
-    banner(version) {
-        const v = `v${version}`;
-        // 32-char wide interior: "  ● ○ ○" (7 chars) + padding + version + "  " (2 trailing)
-        const dotsLeft = "  ● ○ ○";
-        const padLen = 32 - dotsLeft.length - v.length - 2;
-        const pad = " ".repeat(Math.max(padLen, 1));
-        const lines = [
-            `${DIM}  ╭────────────────────────────────╮${RESET}`,
-            `${DIM}  │${RESET}  ${RED}●${RESET} ${DIM}○ ○${pad}${v}${RESET}  ${DIM}│${RESET}`,
-            `${DIM}  │${RESET}  ${GREEN}>${RESET} ${BOLD}${CYAN}EXOCOMMAND${RESET}${GREEN}_${RESET}                 ${DIM}├══════╗${RESET}`,
-            `${DIM}  ╰────────────────────────────────╯ ┌════╝${RESET}`,
-            `${DIM}                                     └══╗${RESET}`,
-            `${DIM}                                        ╹${RESET}`,
-        ];
-        console.log(lines.join("\n"));
-    },
     withAgent(id) {
         return createLogger(id);
     },
 };
+// TUI-aware logger that delegates to TuiManager instead of console
+export function createTuiLogger(tui) {
+    function makeLogger(agentId) {
+        return {
+            info(event, message) {
+                const msg = agentId !== undefined ? `[agent ${agentId}] ${message}` : message;
+                tui.logMessage("info", event, msg);
+            },
+            success(event, message) {
+                const msg = agentId !== undefined ? `[agent ${agentId}] ${message}` : message;
+                tui.logMessage("success", event, msg);
+            },
+            warn(event, message) {
+                const msg = agentId !== undefined ? `[agent ${agentId}] ${message}` : message;
+                tui.logMessage("warn", event, msg);
+            },
+            error(event, message) {
+                const msg = agentId !== undefined ? `[agent ${agentId}] ${message}` : message;
+                tui.logMessage("error", event, msg);
+            },
+        };
+    }
+    return {
+        ...makeLogger(),
+        withAgent(id) {
+            return makeLogger(id);
+        },
+    };
+}

package/dist/registry.js

@@ -0,0 +1,80 @@
+import { createHash, randomUUID } from "node:crypto";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+const REGISTRY_DIR = join(homedir(), ".exocommand");
+const REGISTRY_PATH = join(REGISTRY_DIR, "exocommand.db.json");
+export function getRegistryPath() {
+    return REGISTRY_PATH;
+}
+export async function loadRegistry() {
+    try {
+        await access(REGISTRY_PATH);
+    }
+    catch {
+        return {};
+    }
+    const content = await readFile(REGISTRY_PATH, "utf-8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("Invalid registry format: expected a JSON object");
+    }
+    return parsed;
+}
+export async function saveRegistry(registry) {
+    await mkdir(REGISTRY_DIR, { recursive: true });
+    await writeFile(REGISTRY_PATH, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+}
+export function generateAccessKey() {
+    return createHash("sha256").update(randomUUID()).digest("hex").slice(0, 12);
+}
+export async function addProject(filePath) {
+    const absolute = resolve(filePath);
+    await access(absolute);
+    const registry = await loadRegistry();
+    // Check for duplicate path — return existing key
+    for (const [key, existingPath] of Object.entries(registry)) {
+        if (existingPath === absolute) {
+            return key;
+        }
+    }
+    // Generate a unique key (handle unlikely collisions)
+    let accessKey = generateAccessKey();
+    while (registry[accessKey] !== undefined) {
+        accessKey = generateAccessKey();
+    }
+    registry[accessKey] = absolute;
+    await saveRegistry(registry);
+    return accessKey;
+}
+export async function removeProject(accessKey) {
+    const registry = await loadRegistry();
+    if (registry[accessKey] === undefined) {
+        throw new Error(`Project "${accessKey}" not found in registry`);
+    }
+    delete registry[accessKey];
+    await saveRegistry(registry);
+}
+export async function removeProjectByPath(filePath) {
+    const absolute = resolve(filePath);
+    const registry = await loadRegistry();
+    for (const [key, existingPath] of Object.entries(registry)) {
+        if (existingPath === absolute) {
+            delete registry[key];
+            await saveRegistry(registry);
+            return;
+        }
+    }
+    throw new Error(`No project registered for path: ${absolute}`);
+}
+export async function listProjects() {
+    return loadRegistry();
+}
+export async function resolveProject(accessKey) {
+    const registry = await loadRegistry();
+    const path = registry[accessKey];
+    if (path === undefined) {
+        throw new Error(`Project "${accessKey}" not found in registry`);
+    }
+    return path;
+}

package/dist/registry.test.js

@@ -0,0 +1,107 @@
+import { test, expect, describe, beforeAll, afterAll } from "bun:test";
+import { join } from "node:path";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { loadRegistry, saveRegistry, generateAccessKey, addProject, removeProject, removeProjectByPath, listProjects, resolveProject, } from "./registry";
+// Override the registry path for testing by monkey-patching the module internals.
+// Instead, we test using temp .exocommand files and the real registry functions
+// operating on the actual registry path. To isolate tests, we save/restore.
+let tmpDir;
+let sampleConfigPath;
+let sampleConfigPath2;
+beforeAll(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "exocommand-registry-test-"));
+    sampleConfigPath = join(tmpDir, ".exocommand");
+    sampleConfigPath2 = join(tmpDir, ".exocommand2");
+    await writeFile(sampleConfigPath, 'hello:\n  description: "hi"\n  command: "echo hi"\n');
+    await writeFile(sampleConfigPath2, 'build:\n  description: "build"\n  command: "bun run build"\n');
+});
+afterAll(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+});
+describe("generateAccessKey", () => {
+    test("returns a 12-char hex string", () => {
+        const key = generateAccessKey();
+        expect(key).toHaveLength(12);
+        expect(key).toMatch(/^[0-9a-f]{12}$/);
+    });
+    test("returns unique keys on successive calls", () => {
+        const keys = new Set(Array.from({ length: 100 }, () => generateAccessKey()));
+        expect(keys.size).toBe(100);
+    });
+});
+describe("registry CRUD", () => {
+    test("loadRegistry returns empty object when file does not exist", async () => {
+        // The real registry file may or may not exist, so we test the function's behavior
+        // by checking it returns a valid object
+        const registry = await loadRegistry();
+        expect(typeof registry).toBe("object");
+        expect(registry).not.toBeNull();
+    });
+    test("saveRegistry creates directory and writes file", async () => {
+        const registry = await loadRegistry();
+        // Saving the same registry should not throw
+        await saveRegistry(registry);
+        const reloaded = await loadRegistry();
+        expect(reloaded).toEqual(registry);
+    });
+    test("addProject registers a new project and returns 12-char key", async () => {
+        const key = await addProject(sampleConfigPath);
+        expect(key).toHaveLength(12);
+        expect(key).toMatch(/^[0-9a-f]{12}$/);
+        // Verify it's in the registry
+        const registry = await loadRegistry();
+        expect(registry[key]).toBe(sampleConfigPath);
+    });
+    test("addProject returns existing key for duplicate path", async () => {
+        const key1 = await addProject(sampleConfigPath);
+        const key2 = await addProject(sampleConfigPath);
+        expect(key1).toBe(key2);
+    });
+    test("addProject throws for non-existent file", async () => {
+        await expect(addProject(join(tmpDir, "nonexistent"))).rejects.toThrow();
+    });
+    test("resolveProject returns path for valid key", async () => {
+        const key = await addProject(sampleConfigPath);
+        const resolved = await resolveProject(key);
+        expect(resolved).toBe(sampleConfigPath);
+    });
+    test("resolveProject throws for unknown key", async () => {
+        await expect(resolveProject("zzzzzzzz")).rejects.toThrow('Project "zzzzzzzz" not found in registry');
+    });
+    test("listProjects returns all registered projects", async () => {
+        const key1 = await addProject(sampleConfigPath);
+        const key2 = await addProject(sampleConfigPath2);
+        const projects = await listProjects();
+        expect(projects[key1]).toBe(sampleConfigPath);
+        expect(projects[key2]).toBe(sampleConfigPath2);
+    });
+    test("removeProject deletes the key", async () => {
+        const key = await addProject(sampleConfigPath2);
+        await removeProject(key);
+        const registry = await loadRegistry();
+        expect(registry[key]).toBeUndefined();
+    });
+    test("removeProject throws for unknown key", async () => {
+        await expect(removeProject("zzzzzzzzzzzz")).rejects.toThrow('Project "zzzzzzzzzzzz" not found in registry');
+    });
+    test("removeProjectByPath removes by config file path", async () => {
+        const key = await addProject(sampleConfigPath2);
+        await removeProjectByPath(sampleConfigPath2);
+        const registry = await loadRegistry();
+        expect(registry[key]).toBeUndefined();
+    });
+    test("removeProjectByPath throws for unknown path", async () => {
+        await expect(removeProjectByPath("/nonexistent/.exocommand")).rejects.toThrow("No project registered for path: /nonexistent/.exocommand");
+    });
+    test("full lifecycle: add, list, resolve, remove", async () => {
+        const key = await addProject(sampleConfigPath);
+        expect(key).toHaveLength(12);
+        const projects = await listProjects();
+        expect(projects[key]).toBe(sampleConfigPath);
+        const resolved = await resolveProject(key);
+        expect(resolved).toBe(sampleConfigPath);
+        await removeProject(key);
+        await expect(resolveProject(key)).rejects.toThrow();
+    });
+});