@tonyclaw/agent-inspector 4.0.1 → 4.0.2

package/src/knowledge/openclawClient.ts

@@ -1,161 +0,0 @@
-import { z } from "zod";
-import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../lib/resourceLimits";
-import { safeFetch } from "../lib/safeFetch";
-import type { KnowledgeCandidate, KnowledgeSearchResponse, OpenClawMemoryPayload } from "./types";
-import { KnowledgeSearchResponseSchema, KnowledgeSearchResultSchema } from "./types";
-import { isOpenClawGatewayConfigured, searchOpenClawGateway } from "./openclawGatewayClient";
-import { isOpenClawFileBridgeConfigured, writeCandidateToOpenClawMemory } from "./openclawMarkdown";
-import { redactCandidate } from "./redactor";
-
-const OpenClawWriteResponseSchema = z.object({
-  id: z.string().optional(),
-  memoryId: z.string().optional(),
-});
-
-export type PromoteResult =
-  | {
-      success: true;
-      memoryId: string | null;
-    }
-  | {
-      success: false;
-      error: string;
-    };
-
-function getLegacyEndpoint(): string | null {
-  const endpoint = process.env["OPENCLAW_MEMORY_URL"] ?? process.env["OPENCLAW_API_URL"];
-  if (endpoint === undefined || endpoint.trim() === "") return null;
-  return endpoint.trim();
-}
-
-function buildMemoryUrl(endpoint: string): string {
-  return endpoint.endsWith("/memories") ? endpoint : `${endpoint.replace(/\/$/, "")}/memories`;
-}
-
-function buildSearchUrl(endpoint: string, query: string, project?: string): string {
-  const url = new URL(`${endpoint.replace(/\/$/, "")}/search`);
-  url.searchParams.set("q", query);
-  if (project !== undefined && project !== "") {
-    url.searchParams.set("project", project);
-  }
-  return url.toString();
-}
-
-function authHeaders(): Headers {
-  const headers = new Headers({ "content-type": "application/json" });
-  const token = process.env["OPENCLAW_API_KEY"];
-  if (token !== undefined && token !== "") {
-    headers.set("authorization", `Bearer ${token}`);
-  }
-  return headers;
-}
-
-export function buildOpenClawPayload(candidate: KnowledgeCandidate): OpenClawMemoryPayload {
-  const sanitized = redactCandidate(candidate);
-  return {
-    idempotencyKey: `inspector:session:${sanitized.sessionId}:candidate:${sanitized.id}`,
-    type: sanitized.type,
-    title: sanitized.title,
-    content: sanitized.content,
-    tags: sanitized.tags,
-    source: "agent-inspector",
-    project: sanitized.evidence.project,
-    evidence: sanitized.evidence,
-  };
-}
-
-export async function promoteToOpenClaw(candidate: KnowledgeCandidate): Promise<PromoteResult> {
-  if (isOpenClawFileBridgeConfigured()) {
-    const result = await writeCandidateToOpenClawMemory(candidate);
-    if (result.success) {
-      return { success: true, memoryId: result.memoryId };
-    }
-    return { success: false, error: result.error };
-  }
-
-  const endpoint = getLegacyEndpoint();
-  if (endpoint === null) {
-    return {
-      success: false,
-      error:
-        "OpenClaw memory backend is not configured. Set OPENCLAW_WORKSPACE_DIR " +
-        "for file-backed memory or OPENCLAW_MEMORY_URL for a legacy HTTP backend.",
-    };
-  }
-
-  const fetchResult = await safeFetch(
-    buildMemoryUrl(endpoint),
-    {
-      method: "POST",
-      headers: authHeaders(),
-      body: JSON.stringify(buildOpenClawPayload(candidate)),
-    },
-    {
-      bypass: true,
-      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
-      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
-    },
-  );
-  if (!fetchResult.ok) return { success: false, error: fetchResult.reason };
-  const response = fetchResult.response;
-
-  if (!response.ok) {
-    return { success: false, error: `OpenClaw memory write failed with ${response.status}` };
-  }
-
-  const raw: unknown = await response.json().catch(() => ({}));
-  const parsed = OpenClawWriteResponseSchema.safeParse(raw);
-  if (!parsed.success) {
-    return { success: true, memoryId: null };
-  }
-  return { success: true, memoryId: parsed.data.memoryId ?? parsed.data.id ?? null };
-}
-
-export async function searchOpenClaw(
-  query: string,
-  project?: string,
-): Promise<KnowledgeSearchResponse> {
-  if (isOpenClawGatewayConfigured()) {
-    return await searchOpenClawGateway(query, project);
-  }
-
-  const endpoint = getLegacyEndpoint();
-  if (endpoint === null) {
-    const workspaceHint = isOpenClawFileBridgeConfigured()
-      ? " OPENCLAW_WORKSPACE_DIR is configured for writes, but search requires OPENCLAW_GATEWAY_URL."
-      : "";
-    return {
-      results: [],
-      warning:
-        "OpenClaw search backend is not configured. Set OPENCLAW_GATEWAY_URL " +
-        `or OPENCLAW_MEMORY_URL.${workspaceHint}`,
-    };
-  }
-
-  const fetchResult = await safeFetch(
-    buildSearchUrl(endpoint, query, project),
-    {
-      method: "GET",
-      headers: authHeaders(),
-    },
-    {
-      bypass: true,
-      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
-      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
-    },
-  );
-  if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
-  const response = fetchResult.response;
-  if (!response.ok) {
-    return { results: [], warning: `OpenClaw search failed with ${response.status}` };
-  }
-
-  const raw: unknown = await response.json().catch(() => ({ results: [] }));
-  const parsed = KnowledgeSearchResponseSchema.safeParse(raw);
-  if (parsed.success) return parsed.data;
-  const arrayParsed = z.array(KnowledgeSearchResultSchema).safeParse(raw);
-  if (arrayParsed.success) {
-    return { results: arrayParsed.data, warning: null };
-  }
-  return { results: [], warning: "OpenClaw search returned an unparseable response." };
-}

package/src/knowledge/openclawGatewayClient.ts

@@ -1,249 +0,0 @@
-import { z } from "zod";
-import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../lib/resourceLimits";
-import { safeFetch } from "../lib/safeFetch";
-import type { KnowledgeSearchResponse, KnowledgeSearchResult } from "./types";
-
-const OpenClawGatewayErrorSchema = z
-  .object({
-    type: z.string().optional(),
-    message: z.string().optional(),
-  })
-  .passthrough();
-
-const OpenClawGatewayInvokeResponseSchema = z
-  .object({
-    ok: z.boolean().optional(),
-    result: z.unknown().optional(),
-    error: OpenClawGatewayErrorSchema.optional(),
-  })
-  .passthrough();
-
-const OpenClawGatewayContentItemSchema = z
-  .object({
-    type: z.string().optional(),
-    text: z.string().optional(),
-  })
-  .passthrough();
-
-const OpenClawMemoryHitSchema = z
-  .object({
-    id: z.string().optional(),
-    path: z.string().optional(),
-    title: z.string().optional(),
-    kind: z.string().optional(),
-    corpus: z.string().optional(),
-    score: z.number().nullable().optional(),
-    snippet: z.string().optional(),
-    content: z.string().optional(),
-    source: z.string().nullable().optional(),
-    startLine: z.number().optional(),
-    endLine: z.number().optional(),
-  })
-  .passthrough();
-
-const OpenClawToolResultDetailsSchema = z
-  .object({
-    results: z.array(OpenClawMemoryHitSchema).optional(),
-  })
-  .passthrough();
-
-const OpenClawToolResultSchema = z
-  .object({
-    results: z.array(OpenClawMemoryHitSchema).optional(),
-    details: OpenClawToolResultDetailsSchema.optional(),
-    content: z.array(OpenClawGatewayContentItemSchema).optional(),
-  })
-  .passthrough();
-
-type OpenClawMemoryHit = z.infer<typeof OpenClawMemoryHitSchema>;
-
-export function getOpenClawGatewayUrl(): string | null {
-  const value = process.env["OPENCLAW_GATEWAY_URL"];
-  if (value === undefined || value.trim() === "") {
-    return null;
-  }
-  return value.trim();
-}
-
-export function isOpenClawGatewayConfigured(): boolean {
-  return getOpenClawGatewayUrl() !== null;
-}
-
-function buildToolInvokeUrl(gatewayUrl: string): string {
-  return `${gatewayUrl.replace(/\/$/, "")}/tools/invoke`;
-}
-
-function getOpenClawSessionKey(): string {
-  const value = process.env["OPENCLAW_SESSION_KEY"];
-  return value === undefined || value.trim() === "" ? "main" : value.trim();
-}
-
-function getGatewayToken(): string | null {
-  const token =
-    process.env["OPENCLAW_GATEWAY_TOKEN"] ??
-    process.env["OPENCLAW_GATEWAY_PASSWORD"] ??
-    process.env["OPENCLAW_API_KEY"];
-  if (token === undefined || token.trim() === "") {
-    return null;
-  }
-  return token.trim();
-}
-
-function gatewayHeaders(): Headers {
-  const headers = new Headers({ "content-type": "application/json" });
-  const token = getGatewayToken();
-  if (token !== null) {
-    headers.set("authorization", `Bearer ${token}`);
-  }
-  return headers;
-}
-
-function buildSearchQuery(query: string, project?: string): string {
-  if (project === undefined || project === "") {
-    return query;
-  }
-  return `${query}\nProject: ${project}`;
-}
-
-function formatHitTitle(hit: OpenClawMemoryHit, index: number): string {
-  if (hit.title !== undefined && hit.title !== "") {
-    return hit.title;
-  }
-  if (hit.path !== undefined && hit.path !== "") {
-    return hit.path;
-  }
-  if (hit.id !== undefined && hit.id !== "") {
-    return hit.id;
-  }
-  return `OpenClaw memory result ${String(index + 1)}`;
-}
-
-function formatHitId(hit: OpenClawMemoryHit, index: number): string {
-  const base = hit.id ?? hit.path ?? `result-${String(index + 1)}`;
-  const start = hit.startLine === undefined ? "" : `:${String(hit.startLine)}`;
-  const end = hit.endLine === undefined ? "" : `-${String(hit.endLine)}`;
-  return `openclaw:${base}${start}${end}`;
-}
-
-function formatHitContent(hit: OpenClawMemoryHit): string {
-  if (hit.snippet !== undefined && hit.snippet !== "") {
-    return hit.snippet;
-  }
-  if (hit.content !== undefined && hit.content !== "") {
-    return hit.content;
-  }
-  return "";
-}
-
-function formatHitType(hit: OpenClawMemoryHit): string {
-  if (hit.kind !== undefined && hit.kind !== "") {
-    return hit.kind;
-  }
-  if (hit.corpus !== undefined && hit.corpus !== "") {
-    return hit.corpus;
-  }
-  return "openclaw-memory";
-}
-
-function mapGatewayHit(
-  hit: OpenClawMemoryHit,
-  index: number,
-  project?: string,
-): KnowledgeSearchResult {
-  return {
-    id: formatHitId(hit, index),
-    type: formatHitType(hit),
-    title: formatHitTitle(hit, index),
-    content: formatHitContent(hit),
-    score: hit.score ?? null,
-    source: hit.source ?? "openclaw",
-    project: project ?? null,
-    evidence: hit,
-  };
-}
-
-function extractGatewayHits(result: unknown): OpenClawMemoryHit[] | null {
-  const parsed = OpenClawToolResultSchema.safeParse(result);
-  if (!parsed.success) {
-    return null;
-  }
-  return parsed.data.details?.results ?? parsed.data.results ?? [];
-}
-
-function formatGatewayError(raw: unknown): string {
-  const parsed = OpenClawGatewayInvokeResponseSchema.safeParse(raw);
-  if (!parsed.success) {
-    return "OpenClaw Gateway returned an unparseable response.";
-  }
-  const message = parsed.data.error?.message;
-  if (message !== undefined && message !== "") {
-    return message;
-  }
-  return "OpenClaw Gateway tool invocation failed.";
-}
-
-export async function searchOpenClawGateway(
-  query: string,
-  project?: string,
-): Promise<KnowledgeSearchResponse> {
-  const gatewayUrl = getOpenClawGatewayUrl();
-  if (gatewayUrl === null) {
-    return {
-      results: [],
-      warning: "OpenClaw Gateway is not configured. Set OPENCLAW_GATEWAY_URL.",
-    };
-  }
-
-  const fetchResult = await safeFetch(
-    buildToolInvokeUrl(gatewayUrl),
-    {
-      method: "POST",
-      headers: gatewayHeaders(),
-      body: JSON.stringify({
-        tool: "memory_search",
-        args: {
-          query: buildSearchQuery(query, project),
-          maxResults: 10,
-          corpus: "all",
-        },
-        sessionKey: getOpenClawSessionKey(),
-      }),
-    },
-    {
-      bypass: true,
-      deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataDeadlineMs,
-      responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.metadataResponseBytes,
-    },
-  );
-  if (!fetchResult.ok) return { results: [], warning: fetchResult.reason };
-  const response = fetchResult.response;
-
-  const raw: unknown = await response.json().catch(() => null);
-  if (!response.ok) {
-    return {
-      results: [],
-      warning: `OpenClaw Gateway search failed with ${response.status}: ${formatGatewayError(raw)}`,
-    };
-  }
-
-  const parsed = OpenClawGatewayInvokeResponseSchema.safeParse(raw);
-  if (!parsed.success) {
-    return { results: [], warning: "OpenClaw Gateway returned an unparseable response." };
-  }
-  if (parsed.data.ok === false) {
-    return { results: [], warning: formatGatewayError(raw) };
-  }
-
-  const hits = extractGatewayHits(parsed.data.result);
-  if (hits === null) {
-    return {
-      results: [],
-      warning: "OpenClaw memory_search returned an unparseable tool result.",
-    };
-  }
-
-  return {
-    results: hits.map((hit, index) => mapGatewayHit(hit, index, project)),
-    warning: null,
-  };
-}

package/src/knowledge/openclawMarkdown.ts

@@ -1,146 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import type { KnowledgeCandidate } from "./types";
-import { redactCandidate } from "./redactor";
-
-export type OpenClawFilePromotionResult =
-  | {
-      success: true;
-      memoryId: string;
-      relativePath: string;
-      absolutePath: string;
-    }
-  | {
-      success: false;
-      error: string;
-    };
-
-export function getOpenClawWorkspaceDir(): string | null {
-  const value = process.env["OPENCLAW_WORKSPACE_DIR"];
-  if (value === undefined || value.trim() === "") {
-    return null;
-  }
-  return value.trim();
-}
-
-export function isOpenClawFileBridgeConfigured(): boolean {
-  return getOpenClawWorkspaceDir() !== null;
-}
-
-function normalizeDatePrefix(value: string): string {
-  const date = value.slice(0, 10);
-  return /^\d{4}-\d{2}-\d{2}$/.test(date) ? date : "undated";
-}
-
-function normalizePathSegment(value: string, fallback: string): string {
-  const segment = value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 96);
-  return segment === "" ? fallback : segment;
-}
-
-function formatNullable(value: string | null): string {
-  return value === null || value === "" ? "unknown" : value;
-}
-
-function formatList(values: string[]): string {
-  return values.length === 0 ? "none" : values.join(", ");
-}
-
-function buildEvidenceLink(candidate: KnowledgeCandidate): string {
-  return `agent-inspector:session:${candidate.sessionId}:candidate:${candidate.id}`;
-}
-
-export function buildOpenClawMemoryRelativePath(candidate: KnowledgeCandidate): string {
-  const date = normalizeDatePrefix(candidate.updatedAt);
-  const slug = normalizePathSegment(candidate.id, "candidate");
-  return path.join("memory", "agent-inspector", date, `${slug}.md`).replace(/\\/g, "/");
-}
-
-export function buildOpenClawMemoryMarkdown(candidate: KnowledgeCandidate): string {
-  const sanitized = redactCandidate(candidate);
-  return [
-    "# Agent Inspector Memory Candidate",
-    "",
-    "Layer: L3 memory candidate for OpenClaw L4 durable recall",
-    "Source: agent-inspector",
-    "",
-    "## Metadata",
-    "",
-    `- Type: ${sanitized.type}`,
-    `- Status: ${sanitized.status}`,
-    `- Project: ${formatNullable(sanitized.evidence.project)}`,
-    `- Session: ${sanitized.sessionId}`,
-    `- Log IDs: ${sanitized.logIds.join(", ")}`,
-    `- Models: ${formatList(sanitized.evidence.models)}`,
-    `- Tags: ${formatList(sanitized.tags)}`,
-    `- Created: ${sanitized.createdAt}`,
-    `- Updated: ${sanitized.updatedAt}`,
-    `- Evidence: ${buildEvidenceLink(sanitized)}`,
-    `- Redacted: ${String(sanitized.redaction.redacted)}`,
-    `- Redaction patterns: ${formatList(sanitized.redaction.patterns)}`,
-    "",
-    "## Durable Knowledge Candidate",
-    "",
-    sanitized.content,
-    "",
-    "## Recall Guidance",
-    "",
-    [
-      "- Treat this as reviewed Agent Inspector knowledge extracted from LLM interaction traces.",
-      "- Use the evidence id to return to Agent Inspector when raw proof is needed.",
-      "- Do not treat this file as raw logs; sensitive values were redacted before export.",
-    ].join("\n"),
-    "",
-  ].join("\n");
-}
-
-function resolveTargetPath(workspaceDir: string, relativePath: string): string | null {
-  const root = path.resolve(workspaceDir);
-  const target = path.resolve(root, relativePath);
-  const relative = path.relative(root, target);
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    return null;
-  }
-  return target;
-}
-
-export async function writeCandidateToOpenClawMemory(
-  candidate: KnowledgeCandidate,
-): Promise<OpenClawFilePromotionResult> {
-  const workspaceDir = getOpenClawWorkspaceDir();
-  if (workspaceDir === null) {
-    return {
-      success: false,
-      error: "OpenClaw workspace is not configured. Set OPENCLAW_WORKSPACE_DIR.",
-    };
-  }
-
-  const relativePath = buildOpenClawMemoryRelativePath(candidate);
-  const target = resolveTargetPath(workspaceDir, relativePath);
-  if (target === null) {
-    return {
-      success: false,
-      error: "OpenClaw memory target resolved outside OPENCLAW_WORKSPACE_DIR.",
-    };
-  }
-
-  try {
-    await fs.mkdir(path.dirname(target), { recursive: true });
-    await fs.writeFile(target, buildOpenClawMemoryMarkdown(candidate), "utf8");
-  } catch (error) {
-    return {
-      success: false,
-      error: `OpenClaw memory file write failed: ${String(error)}`,
-    };
-  }
-
-  return {
-    success: true,
-    memoryId: `openclaw-file:${relativePath}`,
-    relativePath,
-    absolutePath: target,
-  };
-}

package/src/knowledge/redactor.ts

@@ -1,80 +0,0 @@
-import type { KnowledgeCandidate, RedactionMetadata } from "./types";
-
-type RedactionPattern = {
-  name: string;
-  pattern: RegExp;
-};
-
-const REDACTION_PATTERNS: RedactionPattern[] = [
-  { name: "authorization-header", pattern: /\bAuthorization\s*:\s*[^\s,;]+/gi },
-  { name: "bearer-token", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi },
-  { name: "api-key", pattern: /\b(?:sk|ak)-[A-Za-z0-9_-]{12,}\b/gi },
-  { name: "cookie", pattern: /\bCookie\s*:\s*[^;\n]+(?:;[^\n]+)?/gi },
-  {
-    name: "secret-assignment",
-    pattern: /\b(?:api[_-]?key|token|secret|password)\s*=\s*["']?[^"'\s,;]{8,}["']?/gi,
-  },
-];
-
-type RedactedText = {
-  text: string;
-  patterns: string[];
-};
-
-function unique(values: string[]): string[] {
-  return [...new Set(values)];
-}
-
-export function redactText(input: string): RedactedText {
-  let text = input;
-  const patterns: string[] = [];
-  for (const item of REDACTION_PATTERNS) {
-    let matched = false;
-    text = text.replace(item.pattern, () => {
-      matched = true;
-      return `[REDACTED:${item.name}]`;
-    });
-    if (matched) {
-      patterns.push(item.name);
-    }
-  }
-  return { text, patterns: unique(patterns) };
-}
-
-function combineRedaction(patterns: string[]): RedactionMetadata {
-  const uniquePatterns = unique(patterns);
-  return {
-    redacted: uniquePatterns.length > 0,
-    patterns: uniquePatterns,
-  };
-}
-
-export function redactCandidate(candidate: KnowledgeCandidate): KnowledgeCandidate {
-  const title = redactText(candidate.title);
-  const content = redactText(candidate.content);
-  const tagResults = candidate.tags.map(redactText);
-  const evidenceProject =
-    candidate.evidence.project === null ? null : redactText(candidate.evidence.project);
-  const evidenceModels = candidate.evidence.models.map(redactText);
-  const patterns = [
-    ...title.patterns,
-    ...content.patterns,
-    ...tagResults.flatMap((result) => result.patterns),
-    ...(evidenceProject === null ? [] : evidenceProject.patterns),
-    ...evidenceModels.flatMap((result) => result.patterns),
-    ...candidate.redaction.patterns,
-  ];
-
-  return {
-    ...candidate,
-    title: title.text,
-    content: content.text,
-    tags: tagResults.map((result) => result.text),
-    evidence: {
-      ...candidate.evidence,
-      project: evidenceProject === null ? null : evidenceProject.text,
-      models: evidenceModels.map((result) => result.text),
-    },
-    redaction: combineRedaction(patterns),
-  };
-}