forgeos 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/forge/agent-memory/context-pack.ts

@@ -0,0 +1,151 @@
+import { DeltaStore } from "../delta/store.ts";
+import type { AgentMemoryContextEvent, AgentMemoryContextPack, AgentMemoryEventRecord } from "./types.ts";
+
+export async function buildAgentMemoryContext(input: {
+  workspaceRoot: string;
+  entry?: string;
+  limit?: number;
+}): Promise<AgentMemoryContextPack> {
+  const store = await DeltaStore.open(input.workspaceRoot, { access: "read" });
+  try {
+    const target = input.entry;
+    const events = await store.listAgentMemoryEvents({ target, limit: input.limit ?? 50 });
+    const timeline = target ? await store.semanticTimeline({ target, limit: input.limit ?? 50 }) : undefined;
+    const current = target ? timeline?.currentState ?? {} : await currentSessionState(store);
+    const goals = events
+      .filter((event) => event.normalizedKind === "agent.prompt.submitted")
+      .map((event) => ({
+        source: event.sourceName,
+        summary: event.summary ?? "Prompt submitted",
+        confidence: event.confidence,
+      }));
+    const calls = toolCalls(events);
+    const files = uniqueStrings(events.flatMap((event) => bindings(event).files));
+    const entries = uniqueStrings(events.flatMap((event) => bindings(event).entries));
+    const approvals = events
+      .filter((event) => event.normalizedKind.startsWith("approval."))
+      .map((event) => ({
+        source: event.sourceName,
+        status: event.normalizedKind.replace(/^approval\./, ""),
+        summary: event.summary,
+      }));
+    const proofs = uniqueStrings(events.flatMap((event) => bindings(event).proofs))
+      .map((kind) => ({ kind }));
+    const contextEventItems = contextEvents(events);
+    const openQuestions = timeline?.openQuestions ?? [];
+    return {
+      ok: true,
+      scope: target ? "entry" : "current",
+      entry: target,
+      currentState: current,
+      agentMemory: {
+        summary: {
+          events: contextEventItems.length,
+          goals: goals.length,
+          toolCalls: calls.length,
+          files: files.length,
+          entries: entries.length,
+          approvals: approvals.length,
+          proofs: proofs.length,
+          openQuestions: openQuestions.length,
+          sources: uniqueStrings(contextEventItems.map((event) => event.source)),
+          tools: uniqueStrings(calls.map((call) => call.tool)),
+          ...(contextEventItems.at(-1)?.capturedAt ? { latestEventAt: contextEventItems.at(-1)!.capturedAt } : {}),
+        },
+        goals,
+        toolCalls: calls,
+        files,
+        entries,
+        approvals,
+        proofs,
+        events: contextEventItems,
+        openQuestions,
+      },
+      exitCode: 0,
+    };
+  } finally {
+    await store.close();
+  }
+}
+
+function contextEvents(events: AgentMemoryEventRecord[]): AgentMemoryContextEvent[] {
+  return events.map((event) => {
+    const eventBindings = bindings(event);
+    return {
+      id: event.id,
+      source: event.sourceName,
+      integration: event.integrationKind,
+      trustLevel: event.trustLevel,
+      kind: event.normalizedKind,
+      capturedAt: event.capturedAt,
+      ...(event.summary ? { summary: event.summary } : {}),
+      ...(event.externalSessionId ? { sessionId: event.externalSessionId } : {}),
+      ...(event.externalTurnId ? { turnId: event.externalTurnId } : {}),
+      ...(eventBindings.toolName ? { tool: eventBindings.toolName } : {}),
+      ...(eventBindings.command ? { command: eventBindings.command } : {}),
+      ...(eventBindings.status ? { status: eventBindings.status } : {}),
+      files: eventBindings.files,
+      entries: eventBindings.entries,
+      proofs: eventBindings.proofs,
+      confidence: event.confidence,
+    };
+  });
+}
+
+async function currentSessionState(store: DeltaStore): Promise<Record<string, unknown>> {
+  const session = await store.currentWorkSession();
+  return session
+    ? {
+        sessionId: session.id,
+        title: session.title,
+        inferredIntent: session.inferredIntent,
+        confidence: session.confidence,
+        status: session.status,
+      }
+    : {};
+}
+
+function toolCalls(events: AgentMemoryEventRecord[]): AgentMemoryContextPack["agentMemory"]["toolCalls"] {
+  return events
+    .filter((event) => event.normalizedKind.startsWith("agent.tool"))
+    .map((event) => {
+      const eventBindings = bindings(event);
+      return {
+        source: event.sourceName,
+        tool: eventBindings.toolName ?? "unknown",
+        status: eventBindings.status,
+        summary: event.summary,
+      };
+    });
+}
+
+function bindings(event: AgentMemoryEventRecord): {
+  toolName?: string;
+  command?: string;
+  status?: string;
+  files: string[];
+  entries: string[];
+  proofs: string[];
+} {
+  const raw = event.data.bindings;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { files: [], entries: [], proofs: [] };
+  }
+  const record = raw as Record<string, unknown>;
+  return {
+    toolName: typeof record.toolName === "string" ? record.toolName : undefined,
+    command: typeof record.command === "string" ? record.command : undefined,
+    status: typeof record.status === "string" ? record.status : undefined,
+    files: arrayOfStrings(record.files),
+    entries: arrayOfStrings(record.entries),
+    proofs: arrayOfStrings(record.proofs),
+  };
+}
+
+function arrayOfStrings(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item.length > 0) : [];
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values)].sort();
+}

package/src/forge/agent-memory/hook-runner.ts

@@ -0,0 +1,312 @@
+import { existsSync, readFileSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { releaseManifest } from "../_generated/releaseManifest.ts";
+import {
+  CODEX_HOOK_META_RELATIVE,
+  CODEX_HOOK_QUEUE_RELATIVE,
+  CODEX_HOOK_RUNNER_RELATIVE,
+} from "./sources/codex.ts";
+
+export interface CodexHookMeta {
+  schema: string;
+  forgeVersion: string;
+  installedAt: string;
+  commandResolvedFrom: string;
+  workspaceRoot: string;
+  runner: string;
+  queueFile: string;
+  stdinTimeoutMs?: number;
+  hookTimeouts?: Record<string, number>;
+}
+
+export interface CodexHookCommandInspection {
+  hookCommands: string[];
+  usesLightweightRunner: boolean;
+  usesLegacyForgeCli: boolean;
+  maxHookTimeout?: number;
+  legacyCommands: string[];
+}
+
+export interface ForgePathResolution {
+  path: string;
+  version?: string;
+  source: "path" | "workspace-bin" | "unknown";
+}
+
+export interface CodexHookRunnerProbe {
+  ok: boolean;
+  durationMs: number;
+  exitCode: number | null;
+  queued: boolean;
+  stdinHangSafe: boolean;
+  stdinHangDurationMs?: number;
+  error?: string;
+}
+
+export function readCodexHookMeta(workspaceRoot: string): CodexHookMeta | null {
+  const path = join(workspaceRoot, CODEX_HOOK_META_RELATIVE);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const meta = parsed as Partial<CodexHookMeta>;
+    if (typeof meta.forgeVersion !== "string" || typeof meta.workspaceRoot !== "string") {
+      return null;
+    }
+    return meta as CodexHookMeta;
+  } catch {
+    return null;
+  }
+}
+
+export function inspectCodexHookCommands(workspaceRoot: string): CodexHookCommandInspection {
+  const hooksPath = join(workspaceRoot, ".codex", "hooks.json");
+  const empty: CodexHookCommandInspection = {
+    hookCommands: [],
+    usesLightweightRunner: false,
+    usesLegacyForgeCli: false,
+    legacyCommands: [],
+  };
+  if (!existsSync(hooksPath)) {
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(hooksPath, "utf8")) as {
+      hooks?: Record<string, Array<{ hooks?: Array<{ command?: string; timeout?: number }> }>>;
+    };
+    const commands: string[] = [];
+    const legacyCommands: string[] = [];
+    let maxHookTimeout: number | undefined;
+    for (const groups of Object.values(parsed.hooks ?? {})) {
+      for (const group of groups ?? []) {
+        for (const hook of group.hooks ?? []) {
+          if (typeof hook.command === "string") {
+            commands.push(hook.command);
+            if (/forge\s+agent\s+ingest/i.test(hook.command)) {
+              legacyCommands.push(hook.command);
+            }
+          }
+          if (typeof hook.timeout === "number") {
+            maxHookTimeout = maxHookTimeout === undefined ? hook.timeout : Math.max(maxHookTimeout, hook.timeout);
+          }
+        }
+      }
+    }
+    const usesLightweightRunner = commands.some((command) => command.includes("codex-hook.mjs"));
+    const usesLegacyForgeCli = legacyCommands.length > 0;
+    return {
+      hookCommands: commands,
+      usesLightweightRunner,
+      usesLegacyForgeCli,
+      maxHookTimeout,
+      legacyCommands,
+    };
+  } catch {
+    return empty;
+  }
+}
+
+export function resolveForgeOnPath(workspaceRoot?: string): ForgePathResolution | null {
+  const roots = [workspaceRoot, process.cwd()].filter((value): value is string => Boolean(value));
+  for (const root of roots) {
+    const localBin = join(root, "bin", "forge.mjs");
+    if (existsSync(localBin)) {
+      return { path: localBin, source: "workspace-bin", version: readForgeVersion(localBin) };
+    }
+  }
+  const command = process.platform === "win32" ? "where.exe" : "which";
+  const args = process.platform === "win32" ? ["forge"] : ["forge"];
+  const result = spawnSyncSafe(command, args);
+  if (!result.ok || !result.stdout.trim()) {
+    return null;
+  }
+  const firstLine = result.stdout.split(/\r?\n/).find((line) => line.trim())?.trim();
+  if (!firstLine) {
+    return null;
+  }
+  return {
+    path: firstLine,
+    source: "path",
+    version: readForgeVersion(firstLine),
+  };
+}
+
+export function compareHookForgeVersions(
+  meta: CodexHookMeta | null,
+  runtimeVersion: string = releaseManifest.packageVersion,
+): { matches: boolean; installedVersion?: string; runtimeVersion: string } {
+  if (!meta?.forgeVersion) {
+    return { matches: false, runtimeVersion };
+  }
+  return {
+    matches: meta.forgeVersion === runtimeVersion,
+    installedVersion: meta.forgeVersion,
+    runtimeVersion,
+  };
+}
+
+export async function probeCodexHookRunner(
+  workspaceRoot: string,
+  options?: { maxDurationMs?: number; stdinHangBudgetMs?: number },
+): Promise<CodexHookRunnerProbe> {
+  const maxDurationMs = options?.maxDurationMs ?? 5000;
+  const stdinHangBudgetMs = options?.stdinHangBudgetMs ?? 3000;
+  const runnerPath = join(workspaceRoot, CODEX_HOOK_RUNNER_RELATIVE);
+  if (!existsSync(runnerPath)) {
+    return {
+      ok: false,
+      durationMs: 0,
+      exitCode: null,
+      queued: false,
+      stdinHangSafe: false,
+      error: `missing hook runner: ${CODEX_HOOK_RUNNER_RELATIVE}`,
+    };
+  }
+
+  const queuePath = join(workspaceRoot, CODEX_HOOK_QUEUE_RELATIVE);
+  const queueBefore = existsSync(queuePath) ? readFileSync(queuePath, "utf8") : "";
+  const payload = JSON.stringify({
+    session_id: "forge-hook-probe",
+    hook_event_name: "SessionStart",
+    cwd: workspaceRoot,
+    forgeHookProbe: true,
+  });
+
+  const startedAt = Date.now();
+  const result = spawnSync(process.execPath, [runnerPath, "SessionStart"], {
+    cwd: workspaceRoot,
+    input: payload,
+    encoding: "utf8",
+    timeout: maxDurationMs + 1000,
+    windowsHide: true,
+  });
+  const durationMs = Date.now() - startedAt;
+
+  const queueAfter = existsSync(queuePath) ? readFileSync(queuePath, "utf8") : "";
+  const queued = queueAfter.length > queueBefore.length && queueAfter.includes("forge-hook-probe");
+
+  const hangStartedAt = Date.now();
+  const hangResult = await spawnNodeHook(runnerPath, ["SessionStart"], {
+    cwd: workspaceRoot,
+    keepStdinOpen: true,
+    timeoutMs: stdinHangBudgetMs,
+  });
+  const stdinHangDurationMs = Date.now() - hangStartedAt;
+  const stdinHangSafe = !hangResult.timedOut && hangResult.exitCode === 0 && stdinHangDurationMs <= stdinHangBudgetMs;
+
+  const exitCode = result.status;
+  const ok = exitCode === 0 && durationMs <= maxDurationMs && queued && stdinHangSafe;
+  const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+  return {
+    ok,
+    durationMs,
+    exitCode,
+    queued,
+    stdinHangSafe,
+    stdinHangDurationMs,
+    ...(ok ? {} : {
+      error: stderr ||
+        (!stdinHangSafe ? `hook runner did not exit safely with open stdin within ${stdinHangBudgetMs}ms` : undefined) ||
+        (exitCode !== 0 ? `hook runner exited with code ${exitCode ?? "unknown"}` : undefined) ||
+        (!queued ? "hook runner did not append NDJSON queue entry" : undefined) ||
+        (durationMs > maxDurationMs ? `hook runner took ${durationMs}ms (budget ${maxDurationMs}ms)` : undefined) ||
+        "hook probe failed",
+    }),
+  };
+}
+
+function readForgeVersion(commandPath: string): string | undefined {
+  if (commandPath.endsWith(".mjs") || commandPath.endsWith(".js")) {
+    try {
+      const pkgPath = join(commandPath, "..", "..", "package.json");
+      if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { version?: string };
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+      }
+    } catch {
+      return undefined;
+    }
+    return undefined;
+  }
+  const result = spawnSyncSafe(process.execPath, [commandPath, "--version"], { timeoutMs: 3000 });
+  return result.ok ? result.stdout.trim().split(/\r?\n/)[0]?.trim() : undefined;
+}
+
+function spawnSyncSafe(
+  command: string,
+  args: string[],
+  options?: { timeoutMs?: number },
+): { ok: boolean; stdout: string; stderr: string; status: number | null } {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: options?.timeoutMs,
+    windowsHide: true,
+  });
+  return {
+    ok: result.status === 0 && !result.error,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    status: result.status,
+  };
+}
+
+function spawnNodeHook(
+  runnerPath: string,
+  args: string[],
+  options: {
+    cwd: string;
+    input?: string;
+    keepStdinOpen?: boolean;
+    timeoutMs: number;
+  },
+): Promise<{ exitCode: number | null; timedOut: boolean; error?: string }> {
+  return new Promise((resolvePromise) => {
+    const child = spawn(process.execPath, [runnerPath, ...args], {
+      cwd: options.cwd,
+      stdio: ["pipe", "ignore", "ignore"],
+      windowsHide: true,
+    });
+    let settled = false;
+    let timedOut = false;
+    let killGraceTimer: ReturnType<typeof setTimeout> | undefined;
+    const finish = (value: { exitCode: number | null; timedOut: boolean; error?: string }) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      if (killGraceTimer) {
+        clearTimeout(killGraceTimer);
+      }
+      resolvePromise(value);
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+      killGraceTimer = setTimeout(() => {
+        finish({ exitCode: null, timedOut: true, error: "hook runner timed out" });
+      }, 1000);
+    }, options.timeoutMs);
+
+    child.on("error", (error) => {
+      finish({ exitCode: null, timedOut, error: error.message });
+    });
+    child.on("close", (code) => {
+      finish({ exitCode: code, timedOut });
+    });
+
+    if (options.keepStdinOpen) {
+      child.stdin?.write('{"session_id":"forge-hook-hang-probe"');
+      return;
+    }
+    if (options.input !== undefined) {
+      child.stdin?.write(options.input);
+    }
+    child.stdin?.end();
+  });
+}

package/src/forge/agent-memory/mcp.ts

@@ -0,0 +1,224 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DeltaStore } from "../delta/store.ts";
+import { buildAgentMemoryContext } from "./context-pack.ts";
+import { ingestEnvelope } from "./bridge.ts";
+import { normalizeAgentEvent } from "./normalize.ts";
+
+interface JsonRpcRequest {
+  jsonrpc?: "2.0";
+  id?: string | number | null;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export async function handleMcpRequest(workspaceRoot: string, request: JsonRpcRequest): Promise<Record<string, unknown> | null> {
+  if (request.method.startsWith("notifications/")) {
+    return null;
+  }
+  try {
+    if (request.method === "initialize") {
+      return response(request.id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "forgeos-agent-memory", version: "0.1.0" },
+      });
+    }
+    if (request.method === "tools/list") {
+      return response(request.id, {
+        tools: [
+          {
+            name: "agent_context",
+            description: "Read the ForgeOS Agent Memory context pack for the current work or a runtime entry.",
+            inputSchema: {
+              type: "object",
+              properties: { entry: { type: "string" } },
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "agent_memory",
+            description: "List recent redacted agent memory events.",
+            inputSchema: {
+              type: "object",
+              properties: { target: { type: "string" }, limit: { type: "number" } },
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "timeline",
+            description: "Read the semantic timeline for an entry, file, policy, service, tool, or agent.",
+            inputSchema: {
+              type: "object",
+              properties: { target: { type: "string" }, limit: { type: "number" } },
+              required: ["target"],
+              additionalProperties: false,
+            },
+          },
+          {
+            name: "inspect_all",
+            description: "Read the generated ForgeOS machine contract artifacts that are safe for agents.",
+            inputSchema: {
+              type: "object",
+              properties: {},
+              additionalProperties: false,
+            },
+          },
+        ],
+      });
+    }
+    if (request.method === "tools/call") {
+      const params = request.params ?? {};
+      const name = typeof params.name === "string" ? params.name : "";
+      const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments)
+        ? params.arguments as Record<string, unknown>
+        : {};
+      const result = await runTool(workspaceRoot, name, args);
+      await logMcpToolCall(workspaceRoot, name, args, "completed").catch(() => undefined);
+      return response(request.id, {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+      });
+    }
+    return response(request.id, null, { code: -32601, message: `unknown MCP method: ${request.method}` });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return response(request.id, null, { code: -32000, message });
+  }
+}
+
+export async function runMcpServe(workspaceRoot: string): Promise<number> {
+  let buffer = "";
+  let sawFramedMessage = false;
+  for await (const chunk of process.stdin) {
+    buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    const parsed = parseMcpFrames(buffer);
+    buffer = parsed.remainder;
+    if (parsed.requests.length > 0) {
+      sawFramedMessage = true;
+    }
+    for (const request of parsed.requests) {
+      const result = await handleMcpRequest(workspaceRoot, request);
+      if (result) {
+        writeMcpMessage(result);
+      }
+    }
+  }
+  const leftover = buffer.trim();
+  if (!sawFramedMessage && leftover.startsWith("{")) {
+    const result = await handleMcpRequest(workspaceRoot, JSON.parse(leftover) as JsonRpcRequest);
+    if (result) {
+      writeMcpMessage(result);
+    }
+  }
+  return 0;
+}
+
+async function runTool(workspaceRoot: string, name: string, args: Record<string, unknown>): Promise<unknown> {
+  if (name === "agent_context") {
+    return buildAgentMemoryContext({
+      workspaceRoot,
+      entry: typeof args.entry === "string" ? args.entry : undefined,
+    });
+  }
+  if (name === "agent_memory") {
+    const store = await DeltaStore.open(workspaceRoot, { access: "read" });
+    try {
+      return {
+        ok: true,
+        events: await store.listAgentMemoryEvents({
+          target: typeof args.target === "string" ? args.target : undefined,
+          limit: typeof args.limit === "number" ? args.limit : undefined,
+        }),
+      };
+    } finally {
+      await store.close();
+    }
+  }
+  if (name === "timeline") {
+    const target = typeof args.target === "string" ? args.target : undefined;
+    if (!target) {
+      throw new Error("timeline requires target");
+    }
+    const store = await DeltaStore.open(workspaceRoot, { access: "read" });
+    try {
+      return {
+        ok: true,
+        timeline: await store.semanticTimeline({
+          target,
+          limit: typeof args.limit === "number" ? args.limit : undefined,
+        }),
+      };
+    } finally {
+      await store.close();
+    }
+  }
+  if (name === "inspect_all") {
+    return readInspectAll(workspaceRoot);
+  }
+  throw new Error(`unknown ForgeOS MCP tool: ${name}`);
+}
+
+async function logMcpToolCall(workspaceRoot: string, toolName: string, args: Record<string, unknown>, status: string): Promise<void> {
+  const envelope = normalizeAgentEvent({
+    workspaceRoot,
+    source: "generic",
+    integration: "mcp",
+    eventName: "tool.call",
+    raw: {
+      toolName,
+      args,
+      status,
+      timestamp: new Date().toISOString(),
+    },
+  });
+  await ingestEnvelope(workspaceRoot, envelope);
+}
+
+function readInspectAll(workspaceRoot: string): Record<string, unknown> {
+  const generated = join(workspaceRoot, "src", "forge", "_generated");
+  const read = (name: string) => {
+    try {
+      return JSON.parse(readFileSync(join(generated, name), "utf8")) as unknown;
+    } catch {
+      return null;
+    }
+  };
+  return {
+    ok: true,
+    agentContract: read("agentContract.json"),
+    agentTools: read("agentTools.json"),
+    runtimeGraph: read("runtimeGraph.json"),
+    policyRegistry: read("policyRegistry.json"),
+  };
+}
+
+function response(id: JsonRpcRequest["id"], result: unknown, error?: Record<string, unknown>): Record<string, unknown> {
+  return error ? { jsonrpc: "2.0", id: id ?? null, error } : { jsonrpc: "2.0", id: id ?? null, result };
+}
+
+function parseMcpFrames(raw: string): { requests: JsonRpcRequest[]; remainder: string } {
+  const messages: JsonRpcRequest[] = [];
+  let cursor = 0;
+  while (cursor < raw.length) {
+    const headerEnd = raw.indexOf("\r\n\r\n", cursor);
+    if (headerEnd === -1) {
+      break;
+    }
+    const header = raw.slice(cursor, headerEnd);
+    const match = /Content-Length:\s*(\d+)/i.exec(header);
+    if (!match) {
+      break;
+    }
+    const length = Number(match[1]);
+    const bodyStart = headerEnd + 4;
+    const body = raw.slice(bodyStart, bodyStart + length);
+    messages.push(JSON.parse(body) as JsonRpcRequest);
+    cursor = bodyStart + length;
+  }
+  return { requests: messages, remainder: raw.slice(cursor) };
+}
+
+function writeMcpMessage(message: Record<string, unknown>): void {
+  const body = JSON.stringify(message);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+}