macro-agent 0.1.0 → 0.1.1

package/src/config/project-config.ts

@@ -1,12 +1,16 @@
 /**
- * Project Configuration Loader
+ * Configuration Loader
  *
- * Reads .macro-agent/config.json for project-level settings.
+ * Layered configuration system with priority (highest to lowest):
+ * 1. Environment variables (MACRO_*, OPENTASKS_*)
+ * 2. Project config: .multiagent/config.json
+ * 3. Global config: ~/.multiagent/config.json
  *
  * @module config/project-config
  */
 
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 
 // =============================================================================
@@ -14,9 +18,49 @@ import * as path from "path";
 // =============================================================================
 
 /**
- * Project-level configuration schema.
+ * Typed configuration schema for multiagent.
  *
- * Loaded from .macro-agent/config.json in the project root.
+ * Loaded from .multiagent/config.json (project or global).
+ * Environment variables override file-based config.
+ */
+export interface MultiagentConfig {
+  /** Team template name to load on startup */
+  team?: string;
+
+  /** Server port (default: 3001) */
+  port?: number;
+
+  /** Server host (default: "localhost") */
+  host?: string;
+
+  /** Authentication config */
+  auth?: {
+    /** Disable auth entirely */
+    disabled?: boolean;
+    /** Server secret token */
+    secret?: string;
+  };
+
+  /** Task backend config */
+  task?: {
+    /** Backend type: "memory" | "opentasks" */
+    backend?: string;
+    /** OpenTasks-specific config */
+    opentasks?: {
+      /** Path to OpenTasks daemon socket */
+      socket_path?: string;
+      /** Auto-start central daemon (default: true) */
+      auto_start?: boolean;
+      /** Central daemon location (default: ~/.multiagent/opentasks) */
+      central_path?: string;
+      /** Auto-connect project .opentasks/ on agent spawn (default: true) */
+      connect_on_spawn?: boolean;
+    };
+  };
+}
+
+/**
+ * Legacy project config interface (backwards compatibility).
  */
 export interface ProjectConfig {
   /** Team template name to load on startup */
@@ -31,38 +75,21 @@ export interface ProjectConfig {
 // =============================================================================
 
 /** Config directory name */
-export const CONFIG_DIR = ".macro-agent";
+export const CONFIG_DIR = ".multiagent";
 
 /** Config file name */
 export const CONFIG_FILE = "config.json";
 
 // =============================================================================
-// Loader
+// JSON Loader (shared)
 // =============================================================================
 
 /**
- * Get the project config file path.
- *
- * @param projectPath - Project root directory (default: process.cwd())
- * @returns Absolute path to .macro-agent/config.json
- */
-export function getProjectConfigPath(projectPath?: string): string {
-  const root = projectPath ?? process.cwd();
-  return path.join(root, CONFIG_DIR, CONFIG_FILE);
-}
-
-/**
- * Load project configuration from .macro-agent/config.json.
- *
- * Returns empty config if the file doesn't exist.
+ * Load and parse a JSON config file.
+ * Returns empty object if file doesn't exist.
  * Throws on invalid JSON.
- *
- * @param projectPath - Project root directory (default: process.cwd())
- * @returns Parsed ProjectConfig
  */
-export function loadProjectConfig(projectPath?: string): ProjectConfig {
-  const configPath = getProjectConfigPath(projectPath);
-
+function loadJsonConfig(configPath: string): Record<string, unknown> {
   if (!fs.existsSync(configPath)) {
     return {};
   }
@@ -78,7 +105,7 @@ export function loadProjectConfig(projectPath?: string): ProjectConfig {
         configPath
       );
     }
-    return parsed as ProjectConfig;
+    return parsed as Record<string, unknown>;
   } catch (error) {
     if (error instanceof ProjectConfigError) throw error;
     throw new ProjectConfigError(
@@ -89,6 +116,142 @@ export function loadProjectConfig(projectPath?: string): ProjectConfig {
   }
 }
 
+// =============================================================================
+// Path Resolution
+// =============================================================================
+
+/**
+ * Get the project config file path.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Absolute path to .multiagent/config.json
+ */
+export function getProjectConfigPath(projectPath?: string): string {
+  const root = projectPath ?? process.cwd();
+  return path.join(root, CONFIG_DIR, CONFIG_FILE);
+}
+
+/**
+ * Get the global config file path.
+ *
+ * @returns Absolute path to ~/.multiagent/config.json
+ */
+export function getGlobalConfigPath(): string {
+  return path.join(os.homedir(), CONFIG_DIR, CONFIG_FILE);
+}
+
+// =============================================================================
+// Individual Loaders
+// =============================================================================
+
+/**
+ * Load project configuration from .multiagent/config.json.
+ *
+ * Returns empty config if the file doesn't exist.
+ * Throws on invalid JSON.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Parsed ProjectConfig
+ */
+export function loadProjectConfig(projectPath?: string): ProjectConfig {
+  return loadJsonConfig(getProjectConfigPath(projectPath)) as ProjectConfig;
+}
+
+/**
+ * Load global configuration from ~/.multiagent/config.json.
+ *
+ * Returns empty config if the file doesn't exist.
+ * Throws on invalid JSON.
+ *
+ * @returns Parsed config
+ */
+export function loadGlobalConfig(): MultiagentConfig {
+  return loadJsonConfig(getGlobalConfigPath()) as MultiagentConfig;
+}
+
+// =============================================================================
+// Merged Config (layered)
+// =============================================================================
+
+/**
+ * Deep merge two objects. Source values override target values.
+ * Only merges plain objects recursively; arrays and primitives are replaced.
+ */
+function deepMerge<T extends Record<string, unknown>>(target: T, source: Record<string, unknown>): T {
+  const result = { ...target };
+
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = (result as Record<string, unknown>)[key];
+
+    if (
+      sourceVal !== undefined &&
+      sourceVal !== null &&
+      typeof sourceVal === "object" &&
+      !Array.isArray(sourceVal) &&
+      typeof targetVal === "object" &&
+      targetVal !== null &&
+      !Array.isArray(targetVal)
+    ) {
+      (result as Record<string, unknown>)[key] = deepMerge(
+        targetVal as Record<string, unknown>,
+        sourceVal as Record<string, unknown>
+      );
+    } else if (sourceVal !== undefined) {
+      (result as Record<string, unknown>)[key] = sourceVal;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Load merged configuration with layered priority:
+ * 1. Environment variables (highest)
+ * 2. Project .multiagent/config.json
+ * 3. Global ~/.multiagent/config.json (lowest)
+ *
+ * Only server-level settings are merged. Agent-level env vars
+ * (MACRO_AGENT_ID, MACRO_SERVER_URL, etc.) are internal wiring
+ * and not part of this config.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Fully merged MultiagentConfig
+ */
+export function loadMergedConfig(projectPath?: string): MultiagentConfig {
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig(projectPath);
+
+  // Layer 1: global (lowest priority)
+  // Layer 2: project overrides global
+  const merged: MultiagentConfig = deepMerge(
+    globalConfig as Record<string, unknown>,
+    projectConfig as Record<string, unknown>,
+  ) as MultiagentConfig;
+
+  // Layer 3: env vars override everything (server-level only)
+  if (process.env.MACRO_TASK_BACKEND) {
+    merged.task = { ...(merged.task ?? {}), backend: process.env.MACRO_TASK_BACKEND };
+  }
+  if (process.env.OPENTASKS_SOCKET_PATH) {
+    merged.task = {
+      ...(merged.task ?? {}),
+      opentasks: {
+        ...(merged.task?.opentasks ?? {}),
+        socket_path: process.env.OPENTASKS_SOCKET_PATH,
+      },
+    };
+  }
+  if (process.env.MACRO_SERVER_SECRET) {
+    merged.auth = { ...(merged.auth ?? {}), secret: process.env.MACRO_SERVER_SECRET };
+  }
+  if (process.env.MACRO_NO_AUTH === "true") {
+    merged.auth = { ...(merged.auth ?? {}), disabled: true };
+  }
+
+  return merged;
+}
+
 // =============================================================================
 // Errors
 // =============================================================================

package/src/lifecycle/__tests__/cascade-termination.test.ts

@@ -74,7 +74,7 @@ function createCascadeAdapter(harness: TestHarness): CascadeAgentManager {
       }
       // Update agent state in EventStore
       harness.eventStore.emit({
-        type: "terminate",
+        type: "stop",
         source: { agent_id: agentId },
         payload: { agent_id: agentId, reason },
       });

package/src/map/adapter/__tests__/acp-over-map-cancel.test.ts

@@ -742,8 +742,26 @@ describe("MAPAdapter handleStopAgent (map/agents/stop)", () => {
     ).rejects.toThrow("Failed to stop agent: Agent not found");
   });
 
-  it("should emit agent.state.changed event via emitEvent", async () => {
-    await setupAdapter();
+  it("should emit agent.state.changed event via lifecycle listener", async () => {
+    // Capture lifecycle callback so we can fire it from the mock terminate
+    let lifecycleCallback: ((event: unknown) => void) | undefined;
+
+    await setupAdapter({
+      onLifecycleEvent: vi.fn().mockImplementation((cb: (event: unknown) => void) => {
+        lifecycleCallback = cb;
+        return () => {};
+      }),
+      terminate: vi.fn().mockImplementation(async () => {
+        // Simulate what real agentManager.terminate() does: fire lifecycle
+        if (lifecycleCallback) {
+          lifecycleCallback({
+            type: "stopped",
+            agent: { id: "agent-1", name: "test-agent", role: "worker", state: "stopped" },
+            reason: "user stopped",
+          });
+        }
+      }),
+    } as unknown as Partial<AgentManager>);
 
     const impl = adapter as unknown as {
       handleStopAgent: (
@@ -761,10 +779,10 @@ describe("MAPAdapter handleStopAgent (map/agents/stop)", () => {
       { agentId: "agent-1" as AgentId, reason: "user stopped" },
     );
 
-    // Verify emitEvent was called with the right event shape
+    // Verify emitEvent was called with the right event shape via lifecycle
     expect(emitSpy).toHaveBeenCalledWith(
       expect.objectContaining({
-        type: "agent.state.changed",
+        type: "agent_state_changed",
         agentId: "agent-1",
         data: expect.objectContaining({
           agentId: "agent-1",

package/src/map/adapter/__tests__/acp-over-map-getmodels.test.ts

@@ -0,0 +1,355 @@
+/**
+ * ACP-over-MAP _macro/getModels Tests
+ *
+ * Verifies that the _macro/getModels extension method correctly returns
+ * model information from the agent's session via the ACP-over-MAP handler.
+ */
+
+import { describe, it, expect, afterEach, vi } from "vitest";
+import { ACPOverMAPHandler } from "../acp-over-map.js";
+import type { ACPEnvelope } from "../acp-over-map.js";
+import { createEventStore, type EventStore } from "../../../store/event-store.js";
+import type { AgentManager } from "../../../agent/agent-manager.js";
+import type { TaskManager } from "../../../task/task-manager.js";
+import type { Agent, Task } from "../../../store/types/index.js";
+import type { AgentId } from "../../../store/types/index.js";
+
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+function createMockAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: "agent-1" as AgentId,
+    session_id: "session-1",
+    state: "running",
+    task: "Test task",
+    task_id: "task-1",
+    parent: null,
+    lineage: [],
+    config: {},
+    cwd: "/test/cwd",
+    plan: [],
+    created_at: Date.now(),
+    started_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "task-1",
+    description: "Test task",
+    status: "in_progress",
+    created_by: "agent-1",
+    created_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockAgentManager(
+  sessionOverride?: unknown,
+): AgentManager {
+  const mockAgent = createMockAgent();
+
+  return {
+    spawn: vi.fn().mockResolvedValue({
+      id: "agent-new",
+      session_id: "session-new",
+      agent: createMockAgent({ id: "agent-new" as AgentId, session_id: "session-new" }),
+      session: {},
+    }),
+    get: vi.fn().mockReturnValue(mockAgent),
+    list: vi.fn().mockReturnValue([mockAgent]),
+    listHeadManagers: vi.fn().mockReturnValue([mockAgent]),
+    getChildren: vi.fn().mockReturnValue([]),
+    getHierarchy: vi.fn().mockReturnValue({
+      root: { agent: mockAgent, children: [] },
+      depth: 1,
+      totalAgents: 1,
+    }),
+    getOrCreateHeadManager: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    hasActiveSession: vi.fn().mockReturnValue(true),
+    resume: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    terminate: vi.fn().mockResolvedValue(undefined),
+    prompt: vi.fn().mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {},
+    }),
+    getSession: vi.fn().mockReturnValue(sessionOverride ?? null),
+    onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
+    close: vi.fn().mockResolvedValue(undefined),
+    respondToPermission: vi.fn().mockReturnValue(true),
+    cancelPermission: vi.fn().mockReturnValue(true),
+  } as unknown as AgentManager;
+}
+
+function createMockTaskManager(): TaskManager {
+  return {
+    get: vi.fn().mockReturnValue(createMockTask()),
+    list: vi.fn().mockReturnValue([createMockTask()]),
+    create: vi.fn().mockReturnValue(createMockTask()),
+  } as unknown as TaskManager;
+}
+
+/** Build an ACP envelope for processRequest */
+function envelope(
+  streamId: string,
+  method: string,
+  params?: unknown,
+  sessionId?: string,
+): ACPEnvelope {
+  return {
+    acp: {
+      jsonrpc: "2.0",
+      id: `${streamId}-${method}-${Date.now()}`,
+      method,
+      params,
+    },
+    acpContext: {
+      streamId,
+      sessionId,
+      direction: "client-to-agent",
+    },
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────
+
+describe("ACP-over-MAP _macro/getModels", () => {
+  let eventStore: EventStore;
+  let handler: ACPOverMAPHandler;
+
+  afterEach(async () => {
+    await eventStore.close();
+  });
+
+  async function setup(sessionOverride?: unknown) {
+    eventStore = await createEventStore({ inMemory: true });
+    const agentManager = createMockAgentManager(sessionOverride);
+    const taskManager = createMockTaskManager();
+
+    handler = new ACPOverMAPHandler({
+      agentManager,
+      eventStore,
+      taskManager,
+      defaultCwd: "/test/cwd",
+    });
+
+    return { agentManager, taskManager };
+  }
+
+  /** Register an agent in the EventStore so session mapper can resolve it */
+  function registerAgent(agentId: string, sessionId: string): void {
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        session_id: sessionId,
+        task: "Test task",
+        task_id: "task-1",
+        cwd: "/test/cwd",
+      },
+    });
+    eventStore.emit({
+      type: "lifecycle",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        action: "started",
+      },
+    });
+  }
+
+  /** Initialize a stream and create a session, returning the sessionId */
+  async function initAndCreateSession(
+    streamId: string,
+    targetAgentId: AgentId = "agent-1" as AgentId,
+  ): Promise<string> {
+    await handler.processRequest(
+      targetAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const sessionResult = await handler.processRequest(
+      targetAgentId,
+      envelope(streamId, "session/new", {
+        cwd: "/test",
+        mcpServers: [],
+      }),
+    );
+
+    const sessionId = (sessionResult.acp.result as { sessionId?: string })?.sessionId;
+    if (!sessionId) throw new Error("session/new did not return sessionId");
+
+    registerAgent(targetAgentId, sessionId);
+
+    return sessionId;
+  }
+
+  it("should return empty models when session is not found", async () => {
+    // getSession returns null — no session available
+    await setup(null);
+
+    const streamId = "test-stream-1";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBeNull();
+    expect(data.availableModels).toEqual([]);
+  });
+
+  it("should return models from session.models when available", async () => {
+    // Mock session with models array (like Claude Code returns)
+    const mockSession = {
+      id: "acp-session-123",
+      models: ["default", "sonnet"],
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-2";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBe("default");
+    expect(data.availableModels).toEqual([
+      { modelId: "default", name: "default" },
+      { modelId: "sonnet", name: "sonnet" },
+    ]);
+  });
+
+  it("should return models from clientHandler when available", async () => {
+    // Mock session with clientHandler.getSessionModelInfo
+    const mockSession = {
+      id: "acp-session-456",
+      models: ["fallback-model"],
+      clientHandler: {
+        getSessionModelInfo: (_id: string) => ({
+          currentModelId: "opus",
+          availableModels: [
+            { modelId: "opus", name: "Claude Opus 4" },
+            { modelId: "sonnet", name: "Claude Sonnet 4.5" },
+          ],
+        }),
+      },
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-3";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    // clientHandler should take priority over session.models
+    expect(data.currentModelId).toBe("opus");
+    expect(data.availableModels).toEqual([
+      { modelId: "opus", name: "Claude Opus 4" },
+      { modelId: "sonnet", name: "Claude Sonnet 4.5" },
+    ]);
+  });
+
+  it("should fall back to session.models when clientHandler returns empty", async () => {
+    // clientHandler returns empty, should fall back to session.models
+    const mockSession = {
+      id: "acp-session-789",
+      models: ["haiku"],
+      clientHandler: {
+        getSessionModelInfo: () => ({
+          currentModelId: null,
+          availableModels: [],
+        }),
+      },
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-4";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBe("haiku");
+    expect(data.availableModels).toEqual([
+      { modelId: "haiku", name: "haiku" },
+    ]);
+  });
+
+  it("should return empty when session has no models and no clientHandler", async () => {
+    // Session exists but has no models
+    const mockSession = {
+      id: "acp-session-empty",
+      models: [],
+    };
+    await setup(mockSession);
+
+    const streamId = "test-stream-5";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    const result = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getModels", { sessionId }),
+    );
+
+    expect(result.acp.error).toBeUndefined();
+    const data = result.acp.result as {
+      currentModelId: string | null;
+      availableModels: Array<{ modelId: string; name: string }>;
+    };
+    expect(data.currentModelId).toBeNull();
+    expect(data.availableModels).toEqual([]);
+  });
+});