macro-agent 0.0.11 → 0.0.12

package/src/map/adapter/acp-over-map.ts

@@ -235,11 +235,29 @@ export class ACPOverMAPHandler {
       throw new Error("Must call initialize before loadSession");
     }
 
-    const { sessionId, cwd } = (params as { sessionId: string; cwd?: string }) ?? {};
-    if (!sessionId) {
+    const { sessionId: rawSessionId, cwd, _meta } = (params as {
+      sessionId: string;
+      cwd?: string;
+      _meta?: Record<string, unknown>;
+    }) ?? {};
+    if (!rawSessionId) {
       throw new Error("sessionId required");
     }
 
+    // Extension: If _meta.agentId provided, look up session from agent record
+    let sessionId = rawSessionId;
+    const metaAgentId = _meta?.agentId as string | undefined;
+    if (metaAgentId) {
+      const agent = this.eventStore.getAgent(metaAgentId as AgentId);
+      if (!agent) {
+        throw new Error(`Agent not found: ${metaAgentId}`);
+      }
+      sessionId = agent.session_id;
+      console.error(
+        `[ACP-over-MAP] loadSession: Resolved agentId ${metaAgentId} to session ${sessionId}`
+      );
+    }
+
     const workingDir = cwd ?? this.defaultCwd;
 
     // Try to find an existing head manager with this session ID
@@ -484,6 +502,31 @@ export class ACPOverMAPHandler {
         return { task };
       }
 
+      case "_macro/resume": {
+        const { agentId } = methodParams as { agentId: string };
+        if (!agentId) {
+          throw new Error("agentId is required");
+        }
+
+        const agent = this.eventStore.getAgent(agentId as AgentId);
+        if (!agent) {
+          throw new Error(`Agent not found: ${agentId}`);
+        }
+
+        if (agent.state !== "stopped" && agent.state !== "failed") {
+          throw new Error(
+            `Agent ${agentId} is ${agent.state} — only stopped or failed agents can be resumed`
+          );
+        }
+
+        const spawned = await this.agentManager.resume(agentId as AgentId);
+        return {
+          success: true,
+          agentId: spawned.id,
+          sessionId: spawned.session_id,
+        };
+      }
+
       default:
         throw new Error(`Unknown extension method: ${method}`);
     }

package/src/map/adapter/event-translator.ts

@@ -57,6 +57,7 @@ const EVENT_TYPE_MAP: Record<EventType, MAPEventType | MAPEventType[] | null> =
   conversation: null, // Mail: handled by mail module
   turn: null, // Mail: handled by mail module
   thread: null, // Mail: handled by mail module
+  session: null, // Internal session tracking
 };
 
 /**

package/src/map/adapter/extensions/agent-detection.ts

@@ -0,0 +1,201 @@
+/**
+ * Agent Detection Extension Methods
+ *
+ * Exposes CLI agent auto-detection to external MAP clients:
+ * - `_macro/agents/available` — List detected CLI agents (cached)
+ * - `_macro/agents/refresh` — Force a fresh detection scan
+ *
+ * Both methods are read-only queries gated by `canQuery`.
+ */
+
+import type { MAPAdapter, ExtensionHandler, ExtensionContext } from "../interface.js";
+import type {
+  DetectedAgent,
+  DetectionResult,
+} from "../../../agent-detection/types.js";
+
+// =============================================================================
+// Request/Response Types
+// =============================================================================
+
+interface AvailableParams {
+  /** Include agents that are not installed (default: false) */
+  includeNotInstalled?: boolean;
+}
+
+interface AvailableResult {
+  /** Detected agents */
+  agents: PublicDetectedAgent[];
+  /** Number of agent definitions scanned */
+  scanned: number;
+  /** Detection duration in milliseconds */
+  durationMs: number;
+  /** Whether results came from cache */
+  cached: boolean;
+}
+
+interface RefreshResult {
+  /** Detected agents (fresh scan) */
+  agents: PublicDetectedAgent[];
+  /** Number of agent definitions scanned */
+  scanned: number;
+  /** Detection duration in milliseconds */
+  durationMs: number;
+}
+
+/**
+ * Public agent info returned to MAP clients.
+ * Strips internal details (binary path) for security.
+ */
+interface PublicDetectedAgent {
+  /** Agent definition ID (e.g., "claude-code") */
+  id: string;
+  /** Human-readable name */
+  name: string;
+  /** Whether the binary was found on PATH */
+  installed: boolean;
+  /** Parsed version string (e.g., "1.2.3") */
+  version?: string;
+  /** Provider/vendor name */
+  vendor: string;
+  /** Short description */
+  description: string;
+}
+
+// =============================================================================
+// Extension Services
+// =============================================================================
+
+/**
+ * Services required for agent detection extensions.
+ *
+ * Uses narrow method signatures rather than exposing the full AgentDetector
+ * to keep the contract minimal and testable.
+ */
+export interface AgentDetectionExtensionServices {
+  /**
+   * Get available agents, returning cached results when possible.
+   */
+  getAvailableAgents: (options?: {
+    refresh?: boolean;
+    includeNotInstalled?: boolean;
+  }) => Promise<DetectionResult>;
+
+  /**
+   * Whether a detection scan is currently running.
+   */
+  isDetecting: () => boolean;
+
+  /**
+   * Get cached result without triggering a new scan.
+   * Returns null if no results are available yet.
+   */
+  getCachedResult: () => DetectionResult | null;
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/**
+ * Convert internal DetectedAgent to public format.
+ * Strips filesystem paths for security.
+ */
+function toPublicAgent(agent: DetectedAgent): PublicDetectedAgent {
+  return {
+    id: agent.id,
+    name: agent.name,
+    installed: agent.installed,
+    version: agent.version,
+    vendor: agent.definition.vendor,
+    description: agent.definition.description,
+  };
+}
+
+// =============================================================================
+// Handler Implementations
+// =============================================================================
+
+function createAvailableHandler(
+  services: AgentDetectionExtensionServices,
+): ExtensionHandler {
+  return async (_context: ExtensionContext, params: unknown) => {
+    const { includeNotInstalled = false } = (params ?? {}) as AvailableParams;
+
+    // Try cached result first
+    const cached = services.getCachedResult();
+    if (cached) {
+      const agents = includeNotInstalled
+        ? cached.agents
+        : cached.agents.filter((a) => a.installed);
+
+      return {
+        agents: agents.map(toPublicAgent),
+        scanned: cached.scanned,
+        durationMs: cached.durationMs,
+        cached: true,
+      } satisfies AvailableResult;
+    }
+
+    // No cache — run detection
+    const result = await services.getAvailableAgents({ includeNotInstalled });
+
+    return {
+      agents: result.agents.map(toPublicAgent),
+      scanned: result.scanned,
+      durationMs: result.durationMs,
+      cached: false,
+    } satisfies AvailableResult;
+  };
+}
+
+function createRefreshHandler(
+  services: AgentDetectionExtensionServices,
+): ExtensionHandler {
+  return async (_context: ExtensionContext, _params: unknown) => {
+    const result = await services.getAvailableAgents({
+      refresh: true,
+      includeNotInstalled: true,
+    });
+
+    return {
+      agents: result.agents.map(toPublicAgent),
+      scanned: result.scanned,
+      durationMs: result.durationMs,
+    } satisfies RefreshResult;
+  };
+}
+
+// =============================================================================
+// Registration
+// =============================================================================
+
+/**
+ * Register agent detection extension methods with the MAPAdapter.
+ *
+ * @param adapter - MAPAdapter instance
+ * @param services - Agent detection services
+ */
+export function registerAgentDetectionExtensions(
+  adapter: MAPAdapter,
+  services: AgentDetectionExtensionServices,
+): void {
+  adapter.registerExtension(
+    "_macro/agents/available",
+    createAvailableHandler(services),
+  );
+  adapter.registerExtension(
+    "_macro/agents/refresh",
+    createRefreshHandler(services),
+  );
+}
+
+/**
+ * Unregister agent detection extension methods.
+ *
+ * @param adapter - MAPAdapter instance
+ */
+export function unregisterAgentDetectionExtensions(adapter: MAPAdapter): void {
+  adapter.unregisterExtension("_macro/agents/available");
+  adapter.unregisterExtension("_macro/agents/refresh");
+}

package/src/map/adapter/extensions/index.ts

@@ -31,13 +31,40 @@ export {
   type InternalWorkspace,
 } from "./workspace.js";
 
+// Workspace file search extension
+export {
+  registerWorkspaceFileExtensions,
+  unregisterWorkspaceFileExtensions,
+  type WorkspaceFileServices,
+} from "./workspace-files.js";
+
+// Resume extension
+export {
+  registerResumeExtension,
+  unregisterResumeExtension,
+  type ResumeExtensionServices,
+} from "./resume.js";
+
+// Agent detection extensions
+export {
+  registerAgentDetectionExtensions,
+  unregisterAgentDetectionExtensions,
+  type AgentDetectionExtensionServices,
+} from "./agent-detection.js";
+
 import type { MAPAdapter } from "../interface.js";
 import type { TaskExtensionServices } from "./task.js";
 import type { WakeExtensionServices } from "./wake.js";
 import type { WorkspaceExtensionServices } from "./workspace.js";
+import type { WorkspaceFileServices } from "./workspace-files.js";
+import type { ResumeExtensionServices } from "./resume.js";
+import type { AgentDetectionExtensionServices } from "./agent-detection.js";
 import { registerTaskExtensions } from "./task.js";
 import { registerWakeExtension } from "./wake.js";
 import { registerWorkspaceExtension } from "./workspace.js";
+import { registerWorkspaceFileExtensions } from "./workspace-files.js";
+import { registerResumeExtension } from "./resume.js";
+import { registerAgentDetectionExtensions } from "./agent-detection.js";
 
 // =============================================================================
 // Combined Registration
@@ -50,6 +77,9 @@ export interface MacroExtensionServices {
   task?: TaskExtensionServices;
   wake?: WakeExtensionServices;
   workspace?: WorkspaceExtensionServices;
+  workspaceFiles?: WorkspaceFileServices;
+  resume?: ResumeExtensionServices;
+  agentDetection?: AgentDetectionExtensionServices;
 }
 
 /**
@@ -98,6 +128,18 @@ export function registerMacroExtensions(
   if (services.workspace) {
     registerWorkspaceExtension(adapter, services.workspace);
   }
+
+  if (services.workspaceFiles) {
+    registerWorkspaceFileExtensions(adapter, services.workspaceFiles);
+  }
+
+  if (services.resume) {
+    registerResumeExtension(adapter, services.resume);
+  }
+
+  if (services.agentDetection) {
+    registerAgentDetectionExtensions(adapter, services.agentDetection);
+  }
 }
 
 /**
@@ -116,6 +158,12 @@ export function unregisterMacroExtensions(adapter: MAPAdapter): void {
     adapter.unregisterExtension("_macro/task/send");
     adapter.unregisterExtension("_macro/wake");
     adapter.unregisterExtension("_macro/workspace/info");
+    adapter.unregisterExtension("_macro/workspace/files/search");
+    adapter.unregisterExtension("_macro/workspace/files/list");
+    adapter.unregisterExtension("_macro/workspace/files/read");
+    adapter.unregisterExtension("_macro/resume");
+    adapter.unregisterExtension("_macro/agents/available");
+    adapter.unregisterExtension("_macro/agents/refresh");
   } catch {
     // Ignore errors from unregistering non-existent extensions
   }
@@ -140,6 +188,15 @@ export const MACRO_EXTENSION_METHODS = [
   "_macro/wake",
   // Workspace extension
   "_macro/workspace/info",
+  // Workspace file search extensions
+  "_macro/workspace/files/search",
+  "_macro/workspace/files/list",
+  "_macro/workspace/files/read",
+  // Resume extension
+  "_macro/resume",
+  // Agent detection extensions
+  "_macro/agents/available",
+  "_macro/agents/refresh",
 ] as const;
 
 /**
@@ -154,4 +211,10 @@ export const EXTENSION_CAPABILITIES: Record<string, string> = {
   "_macro/task/send": "canMessage",
   "_macro/wake": "canMessage", // Wake requires messaging capability
   "_macro/workspace/info": "canQuery",
+  "_macro/workspace/files/search": "canQuery",
+  "_macro/workspace/files/list": "canQuery",
+  "_macro/workspace/files/read": "canQuery",
+  "_macro/resume": "canManageLifecycle",
+  "_macro/agents/available": "canQuery",
+  "_macro/agents/refresh": "canQuery",
 };

package/src/map/adapter/extensions/resume.ts

@@ -0,0 +1,114 @@
+/**
+ * Resume Extension Method (_macro/resume)
+ *
+ * Resumes a stopped agent by spawning a new process and loading
+ * the existing ACP session. This is a lifecycle management operation
+ * independent from session loading.
+ *
+ * Unlike _macro/wake (which handles sleeping/idle agents), this extension
+ * handles agents whose process has terminated (state: "stopped" or "failed").
+ */
+
+import type { MAPAdapter, ExtensionHandler, ExtensionContext } from "../interface.js";
+import type { AgentId } from "../../../store/types/index.js";
+import { RPCError } from "../rpc-handler.js";
+
+// =============================================================================
+// Request/Response Types
+// =============================================================================
+
+interface ResumeParams {
+  /** Agent ID to resume */
+  agentId: string;
+}
+
+interface ResumeResult {
+  /** Whether the resume was successful */
+  success: boolean;
+  /** The resumed agent's ID */
+  agentId: string;
+  /** The agent's ACP session ID */
+  sessionId?: string;
+}
+
+// =============================================================================
+// Extension Services
+// =============================================================================
+
+/**
+ * Services required for resume extension
+ */
+export interface ResumeExtensionServices {
+  /**
+   * Get agent by ID. Returns agent record or undefined if not found.
+   */
+  getAgent: (agentId: AgentId) => { id: AgentId; state: string; session_id?: string } | undefined;
+
+  /**
+   * Resume a stopped agent — spawns a new process and loads the existing session.
+   * Returns the spawned agent record.
+   */
+  resume: (agentId: AgentId) => Promise<{ id: AgentId; session_id: string }>;
+}
+
+// =============================================================================
+// Handler Implementation
+// =============================================================================
+
+function createResumeHandler(services: ResumeExtensionServices): ExtensionHandler {
+  return async (_context: ExtensionContext, params: unknown) => {
+    const { agentId } = (params ?? {}) as ResumeParams;
+
+    if (!agentId) {
+      throw RPCError.invalidParams("agentId is required");
+    }
+
+    // Check agent exists
+    const agent = services.getAgent(agentId as AgentId);
+    if (!agent) {
+      throw RPCError.notFound("agent", agentId);
+    }
+
+    // Only resume stopped/failed agents
+    if (agent.state !== "stopped" && agent.state !== "failed") {
+      throw RPCError.invalidParams(
+        `Agent ${agentId} is ${agent.state} — only stopped or failed agents can be resumed`
+      );
+    }
+
+    // Resume the agent
+    const spawned = await services.resume(agentId as AgentId);
+
+    return {
+      success: true,
+      agentId: spawned.id,
+      sessionId: spawned.session_id,
+    } satisfies ResumeResult;
+  };
+}
+
+// =============================================================================
+// Registration
+// =============================================================================
+
+/**
+ * Register resume extension method with the MAPAdapter.
+ *
+ * @param adapter - MAPAdapter instance
+ * @param services - Resume extension services
+ */
+export function registerResumeExtension(
+  adapter: MAPAdapter,
+  services: ResumeExtensionServices
+): void {
+  adapter.registerExtension("_macro/resume", createResumeHandler(services));
+}
+
+/**
+ * Unregister resume extension method.
+ *
+ * @param adapter - MAPAdapter instance
+ */
+export function unregisterResumeExtension(adapter: MAPAdapter): void {
+  adapter.unregisterExtension("_macro/resume");
+}