@messenger-agent/claude-agent 0.24.0-alpha.2

package/dist/managed-task-mcp.d.ts

@@ -0,0 +1,7 @@
+import { type McpSdkServerConfigWithInstance } from "@anthropic-ai/claude-agent-sdk";
+import { type ManagedTaskExecutionContext } from "@messenger-agent/shared/managed-task-tools";
+export declare const MANAGED_TASK_MCP_SERVER_NAME = "managed_tasks";
+export declare function createManagedTaskMcpServer(options: {
+    workspaceRoot: string;
+    context?: ManagedTaskExecutionContext;
+}): McpSdkServerConfigWithInstance;

package/dist/managed-task-mcp.js

@@ -0,0 +1,41 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { executeManagedTaskTool, MANAGED_TASK_TOOL_DEFINITIONS, } from "@messenger-agent/shared/managed-task-tools";
+import { WorkspaceFileError } from "@messenger-agent/shared/workspace-files";
+export const MANAGED_TASK_MCP_SERVER_NAME = "managed_tasks";
+function jsonResult(data) {
+    const structuredContent = data && typeof data === "object" && !Array.isArray(data) ? data : undefined;
+    return {
+        content: [{ type: "text", text: JSON.stringify(data) }],
+        ...(structuredContent ? { structuredContent } : null),
+    };
+}
+function errorResult(err) {
+    const message = err instanceof WorkspaceFileError && err.code === "INVALID_PATH"
+        ? err.message
+        : err instanceof Error
+            ? err.message
+            : String(err);
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+export function createManagedTaskMcpServer(options) {
+    return createSdkMcpServer({
+        name: MANAGED_TASK_MCP_SERVER_NAME,
+        version: "0.1.0",
+        instructions: "Use these tools for managed task records in the current workspace. Do not read or write task storage files directly.",
+        alwaysLoad: true,
+        tools: MANAGED_TASK_TOOL_DEFINITIONS.map((definition) => tool(definition.name, definition.description, definition.schema.shape, async (args) => {
+            try {
+                return jsonResult(await executeManagedTaskTool(options.workspaceRoot, definition.name, args, options.context));
+            }
+            catch (err) {
+                return errorResult(err);
+            }
+        }, {
+            alwaysLoad: true,
+            searchHint: definition.name,
+        })),
+    });
+}

package/dist/pending-asks.d.ts

@@ -0,0 +1,85 @@
+/** SDK tool names whose permission request is satisfied by a later client response. */
+export declare const PENDING_ASK_TOOL_NAMES: readonly ["AskUserQuestion"];
+export declare const PENDING_APPROVAL_TOOL_NAMES: readonly ["ExitPlanMode"];
+export type PendingAskToolName = (typeof PENDING_ASK_TOOL_NAMES)[number];
+export type PendingApprovalToolName = (typeof PENDING_APPROVAL_TOOL_NAMES)[number];
+export type PendingToolKind = "ask_user" | "approval";
+export type PendingAskRecord = {
+    id: string;
+    kind: "ask_user";
+    conversationId: string;
+    toolCallId: string;
+    workdir: string;
+    model?: string;
+    agentMode?: string;
+    toolName: PendingAskToolName;
+    input: unknown;
+    createdAt: string;
+    updatedAt: string;
+};
+export type PendingApprovalRecord = {
+    id: string;
+    kind: "approval";
+    conversationId: string;
+    toolCallId: string;
+    workdir: string;
+    model?: string;
+    agentMode?: string;
+    toolName: PendingApprovalToolName;
+    input: unknown;
+    approveId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type PendingToolRecord = PendingAskRecord | PendingApprovalRecord;
+export type PendingAskAnswer = {
+    answers: Record<string, string> | string;
+    output?: unknown;
+} | {
+    interrupted: true;
+};
+export type PendingApprovalAnswer = {
+    approved: boolean;
+    reason?: string;
+} | {
+    interrupted: true;
+};
+export declare function savePendingAsk(params: {
+    conversationId: string;
+    toolCallId: string;
+    workdir: string;
+    model?: string;
+    agentMode?: string;
+    toolName: PendingAskToolName;
+    input: unknown;
+}): PendingAskRecord;
+export declare function loadPendingAsk(toolCallId: string): PendingAskRecord | undefined;
+export declare function findPendingAskByConversation(conversationId: string): PendingAskRecord | undefined;
+export declare function savePendingApproval(params: {
+    conversationId: string;
+    toolCallId: string;
+    workdir: string;
+    model?: string;
+    agentMode?: string;
+    toolName: PendingApprovalToolName;
+    input: unknown;
+}): PendingApprovalRecord;
+export declare function loadPendingApproval(toolCallId: string): PendingApprovalRecord | undefined;
+export declare function findPendingApprovalByConversation(conversationId: string): PendingApprovalRecord | undefined;
+export declare function loadPendingClientTool(toolCallId: string): PendingToolRecord | undefined;
+export declare function findPendingClientToolByConversation(conversationId: string): PendingToolRecord | undefined;
+export declare function updatePendingAskConversation(previousConversationId: string, conversationId: string): void;
+export declare function updatePendingClientToolConversation(previousConversationId: string, conversationId: string): void;
+export declare function waitPendingAsk(toolCallId: string): Promise<PendingAskAnswer> | undefined;
+export declare function answerPendingAsk(toolCallId: string, answer: PendingAskAnswer): boolean;
+export declare function waitPendingApproval(toolCallId: string): Promise<PendingApprovalAnswer> | undefined;
+export declare function answerPendingApproval(toolCallId: string, answer: PendingApprovalAnswer): boolean;
+export declare function deletePendingAsk(toolCallId: string, options?: {
+    rejectWait?: boolean;
+}): void;
+export declare function deletePendingClientTool(toolCallId: string, options?: {
+    rejectWait?: boolean;
+}): void;
+export declare function listPendingAsks(): PendingAskRecord[];
+export declare function listPendingClientTools(): PendingToolRecord[];
+export declare function closePendingToolsDatabaseForTest(): void;

package/dist/pending-asks.js

@@ -0,0 +1,283 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { appConfig } from "./config.js";
+/** SDK tool names whose permission request is satisfied by a later client response. */
+export const PENDING_ASK_TOOL_NAMES = ["AskUserQuestion"];
+export const PENDING_APPROVAL_TOOL_NAMES = ["ExitPlanMode"];
+const pendingTools = new Map();
+const DB_PATH = join(appConfig.dataDir, "pending-asks.sqlite");
+mkdirSync(dirname(DB_PATH), { recursive: true });
+const db = new DatabaseSync(DB_PATH);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS pending_tools (
+    tool_call_id   TEXT PRIMARY KEY,
+    id             TEXT NOT NULL,
+    kind           TEXT NOT NULL,
+    conversation_id TEXT NOT NULL,
+    workdir        TEXT NOT NULL,
+    model          TEXT,
+    agent_mode     TEXT,
+    tool_name      TEXT NOT NULL,
+    input_json     TEXT NOT NULL,
+    approval_json  TEXT,
+    created_at     TEXT NOT NULL,
+    updated_at     TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_pending_tools_conversation_updated
+    ON pending_tools (conversation_id, updated_at);
+`);
+const stmtUpsert = db.prepare(`
+  INSERT INTO pending_tools (
+    tool_call_id, id, kind, conversation_id, workdir, model, agent_mode, tool_name, input_json, approval_json, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT(tool_call_id) DO UPDATE SET
+    id = excluded.id,
+    kind = excluded.kind,
+    conversation_id = excluded.conversation_id,
+    workdir = excluded.workdir,
+    model = excluded.model,
+    agent_mode = excluded.agent_mode,
+    tool_name = excluded.tool_name,
+    input_json = excluded.input_json,
+    approval_json = excluded.approval_json,
+    updated_at = excluded.updated_at
+`);
+const stmtGetByToolCallId = db.prepare(`SELECT * FROM pending_tools WHERE tool_call_id = ?`);
+const stmtFindByConversation = db.prepare(`
+  SELECT * FROM pending_tools
+  WHERE conversation_id = ?
+  ORDER BY updated_at DESC, created_at DESC
+  LIMIT 1
+`);
+const stmtUpdateConversation = db.prepare(`
+  UPDATE pending_tools
+  SET conversation_id = ?, updated_at = ?
+  WHERE conversation_id = ?
+`);
+const stmtDelete = db.prepare(`DELETE FROM pending_tools WHERE tool_call_id = ?`);
+const stmtList = db.prepare(`SELECT * FROM pending_tools ORDER BY updated_at DESC, created_at DESC`);
+function createWait(record) {
+    let resolve;
+    let reject;
+    const promise = new Promise((promiseResolve, promiseReject) => {
+        resolve = promiseResolve;
+        reject = promiseReject;
+    });
+    return { record, resolve, reject, promise };
+}
+function rowToRecord(row) {
+    try {
+        const input = JSON.parse(row.input_json);
+        const base = {
+            id: row.id,
+            conversationId: row.conversation_id,
+            toolCallId: row.tool_call_id,
+            workdir: row.workdir,
+            model: row.model ?? undefined,
+            agentMode: row.agent_mode ?? undefined,
+            input,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+        if (row.kind === "approval") {
+            const approval = row.approval_json ? JSON.parse(row.approval_json) : {};
+            if (row.tool_name !== "ExitPlanMode" || typeof approval.approveId !== "string")
+                return undefined;
+            return {
+                ...base,
+                kind: "approval",
+                toolName: "ExitPlanMode",
+                approveId: approval.approveId,
+            };
+        }
+        if (row.kind !== "ask_user" || row.tool_name !== "AskUserQuestion")
+            return undefined;
+        return {
+            ...base,
+            kind: "ask_user",
+            toolName: "AskUserQuestion",
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function persistPendingTool(record) {
+    stmtUpsert.run(record.toolCallId, record.id, record.kind, record.conversationId, record.workdir, record.model ?? null, record.agentMode ?? null, record.toolName, JSON.stringify(record.input), record.kind === "approval" ? JSON.stringify({ approveId: record.approveId }) : null, record.createdAt, record.updatedAt);
+}
+function hydrateWait(record) {
+    const existing = pendingTools.get(record.toolCallId);
+    if (existing)
+        return existing;
+    const wait = createWait(record);
+    pendingTools.set(record.toolCallId, wait);
+    return wait;
+}
+function loadPendingTool(toolCallId) {
+    const existing = pendingTools.get(toolCallId)?.record;
+    if (existing)
+        return existing;
+    const row = stmtGetByToolCallId.get(toolCallId);
+    const record = row ? rowToRecord(row) : undefined;
+    if (!record)
+        return undefined;
+    hydrateWait(record);
+    return record;
+}
+function findPendingToolByConversation(conversationId) {
+    const existing = Array.from(pendingTools.values(), (wait) => wait.record)
+        .filter((record) => record.conversationId === conversationId)
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
+    if (existing)
+        return existing;
+    const row = stmtFindByConversation.get(conversationId);
+    const record = row ? rowToRecord(row) : undefined;
+    if (!record)
+        return undefined;
+    hydrateWait(record);
+    return record;
+}
+export function savePendingAsk(params) {
+    const existing = pendingTools.get(params.toolCallId);
+    if (existing?.record.kind === "ask_user")
+        return existing.record;
+    const now = new Date().toISOString();
+    const record = {
+        id: randomUUID(),
+        kind: "ask_user",
+        conversationId: params.conversationId,
+        toolCallId: params.toolCallId,
+        workdir: params.workdir,
+        model: params.model,
+        agentMode: params.agentMode,
+        toolName: params.toolName,
+        input: params.input,
+        createdAt: now,
+        updatedAt: now,
+    };
+    pendingTools.set(params.toolCallId, createWait(record));
+    persistPendingTool(record);
+    return record;
+}
+export function loadPendingAsk(toolCallId) {
+    const record = loadPendingTool(toolCallId);
+    return record?.kind === "ask_user" ? record : undefined;
+}
+export function findPendingAskByConversation(conversationId) {
+    const record = findPendingToolByConversation(conversationId);
+    return record?.kind === "ask_user" ? record : undefined;
+}
+export function savePendingApproval(params) {
+    const existing = pendingTools.get(params.toolCallId);
+    if (existing?.record.kind === "approval")
+        return existing.record;
+    const now = new Date().toISOString();
+    const record = {
+        id: randomUUID(),
+        kind: "approval",
+        conversationId: params.conversationId,
+        toolCallId: params.toolCallId,
+        workdir: params.workdir,
+        model: params.model,
+        agentMode: params.agentMode,
+        toolName: params.toolName,
+        input: params.input,
+        approveId: randomUUID(),
+        createdAt: now,
+        updatedAt: now,
+    };
+    pendingTools.set(params.toolCallId, createWait(record));
+    persistPendingTool(record);
+    return record;
+}
+export function loadPendingApproval(toolCallId) {
+    const record = loadPendingTool(toolCallId);
+    return record?.kind === "approval" ? record : undefined;
+}
+export function findPendingApprovalByConversation(conversationId) {
+    const record = findPendingToolByConversation(conversationId);
+    return record?.kind === "approval" ? record : undefined;
+}
+export function loadPendingClientTool(toolCallId) {
+    return loadPendingTool(toolCallId);
+}
+export function findPendingClientToolByConversation(conversationId) {
+    return findPendingToolByConversation(conversationId);
+}
+export function updatePendingAskConversation(previousConversationId, conversationId) {
+    updatePendingClientToolConversation(previousConversationId, conversationId);
+}
+export function updatePendingClientToolConversation(previousConversationId, conversationId) {
+    const now = new Date().toISOString();
+    let matched = false;
+    for (const wait of pendingTools.values()) {
+        if (wait.record.conversationId === previousConversationId) {
+            wait.record.conversationId = conversationId;
+            wait.record.updatedAt = now;
+            matched = true;
+        }
+    }
+    if (!matched)
+        return;
+    stmtUpdateConversation.run(conversationId, now, previousConversationId);
+}
+export function waitPendingAsk(toolCallId) {
+    return pendingTools.get(toolCallId)?.promise;
+}
+export function answerPendingAsk(toolCallId, answer) {
+    const wait = pendingTools.get(toolCallId) ?? (loadPendingAsk(toolCallId) ? pendingTools.get(toolCallId) : undefined);
+    if (!wait)
+        return false;
+    if (wait.record.kind !== "ask_user")
+        return false;
+    pendingTools.delete(toolCallId);
+    stmtDelete.run(toolCallId);
+    wait.resolve(answer);
+    return true;
+}
+export function waitPendingApproval(toolCallId) {
+    return pendingTools.get(toolCallId)?.promise;
+}
+export function answerPendingApproval(toolCallId, answer) {
+    const wait = pendingTools.get(toolCallId) ?? (loadPendingApproval(toolCallId) ? pendingTools.get(toolCallId) : undefined);
+    if (!wait)
+        return false;
+    if (wait.record.kind !== "approval")
+        return false;
+    pendingTools.delete(toolCallId);
+    stmtDelete.run(toolCallId);
+    wait.resolve(answer);
+    return true;
+}
+export function deletePendingAsk(toolCallId, options = {}) {
+    deletePendingClientTool(toolCallId, options);
+}
+export function deletePendingClientTool(toolCallId, options = {}) {
+    const wait = pendingTools.get(toolCallId);
+    pendingTools.delete(toolCallId);
+    stmtDelete.run(toolCallId);
+    if (wait && options.rejectWait) {
+        wait.reject(new Error(`Pending client tool was cancelled: ${toolCallId}`));
+    }
+}
+export function listPendingAsks() {
+    return listPendingClientTools().filter((record) => record.kind === "ask_user");
+}
+export function listPendingClientTools() {
+    const records = new Map();
+    for (const row of stmtList.all()) {
+        const record = rowToRecord(row);
+        if (record)
+            records.set(record.toolCallId, record);
+    }
+    for (const wait of pendingTools.values()) {
+        records.set(wait.record.toolCallId, wait.record);
+    }
+    return Array.from(records.values()).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+export function closePendingToolsDatabaseForTest() {
+    pendingTools.clear();
+    db.close();
+}

package/dist/platform-instructions.d.ts

@@ -0,0 +1,2 @@
+export declare function loadClaudePlatformInstructions(templatePath?: string): string;
+export declare const claudePlatformInstructions: string;

package/dist/platform-instructions.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { logger } from "@messenger-agent/shared/logger";
+const DEFAULT_TEMPLATE_PATHS = [
+    fileURLToPath(new URL("./assets/codex-home/AGENTS.md", import.meta.url)),
+    fileURLToPath(new URL("../../../assets/codex-home/AGENTS.md", import.meta.url)),
+    "/app/assets/codex-home/AGENTS.md",
+];
+const CLAUDE_MANAGED_TASK_TOOLS = [
+    "search_managed_tasks",
+    "get_managed_task",
+    "create_managed_task",
+    "update_managed_task",
+    "apply_managed_task_patch",
+    "delete_managed_task",
+];
+const CLAUDE_TASK_GUIDANCE = [
+    "## Claude Managed Task Tools",
+    "",
+    "When the user asks to create, update, inspect, continue, summarize, or delete managed tasks, use the managed task MCP tools. The available tool basenames are: " +
+        CLAUDE_MANAGED_TASK_TOOLS.map((name) => `\`${name}\``).join(", ") +
+        ". Claude may expose them with an MCP namespace such as `mcp__managed_tasks__<tool>`.",
+    "",
+].join("\n");
+const CLAUDE_RESPONSE_STYLE_GUIDANCE = [
+    "## Response Style",
+    "",
+    "Do not use emoji in responses.",
+    "Use Markdown headings, bold, and italic formatting sparingly.",
+    "Other Markdown formatting, such as lists, inline code, links, and code blocks, may be used as needed.",
+    "",
+].join("\n");
+const CLAUDE_PLATFORM_GUIDANCE = `${CLAUDE_TASK_GUIDANCE}\n${CLAUDE_RESPONSE_STYLE_GUIDANCE}`;
+export function loadClaudePlatformInstructions(templatePath) {
+    const path = [templatePath ?? process.env.CLAUDE_MEMORY_TEMPLATE_PATH, ...DEFAULT_TEMPLATE_PATHS].find((candidate) => Boolean(candidate && existsSync(candidate)));
+    if (!path) {
+        logger.warn("Claude platform instructions template not found");
+        return CLAUDE_PLATFORM_GUIDANCE;
+    }
+    return `${readFileSync(path, "utf-8").trimEnd()}\n\n${CLAUDE_PLATFORM_GUIDANCE}`;
+}
+export const claudePlatformInstructions = loadClaudePlatformInstructions();

package/dist/routes/chat.d.ts

@@ -0,0 +1,27 @@
+import { Hono } from "hono";
+import { type ChatBody } from "../schemas.js";
+declare const chat: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function claudeActivitySnapshot(): {
+    active: number;
+    waiting: number;
+};
+export declare class ChatRequestError extends Error {
+    readonly status: 400 | 409;
+    constructor(status: 400 | 409, message: string);
+}
+export type ChatStreamRequest = {
+    body: ChatBody;
+    headers?: Headers;
+    signal?: AbortSignal;
+};
+export type ChatStreamWriter = {
+    writeData(data: unknown): Promise<void>;
+    writeDone(): Promise<void>;
+};
+export type PreparedChatStream = {
+    run(writer: ChatStreamWriter, signal?: AbortSignal): Promise<void>;
+};
+export declare function cancelClaudeConversation(conversationId: string): boolean;
+export declare function prepareClaudeChatStream({ body, headers }: ChatStreamRequest): Promise<PreparedChatStream>;
+export declare function handleClaudeChatStream(request: ChatStreamRequest, writer: ChatStreamWriter): Promise<void>;
+export default chat;