@agent-native/dispatch 0.0.0-beta-20260819155526

package/src/lib/simple-agent-profile.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildSimpleAgentContent,
+  normalizeImportedAgent,
+  slugifyAgentName,
+  validateImportedAgentTools,
+} from "./simple-agent-profile.js";
+
+describe("simple agent profiles", () => {
+  it("normalizes a Claude-style Markdown agent", () => {
+    const result = normalizeImportedAgent(
+      `---\nname: Research Partner\ndescription: Synthesizes research\nmodel: sonnet\ntools: Read, WebSearch\n---\n\n# Role\n\nResearch carefully.`,
+      ".claude/agents/research.md",
+    );
+
+    expect(result).toMatchObject({
+      name: "Research Partner",
+      description: "Synthesizes research",
+      model: "sonnet",
+      tools: "Read, WebSearch",
+      source: "claude",
+      sourcePath: ".claude/agents/research.md",
+    });
+    expect(result.instructions).toContain("Research carefully.");
+  });
+
+  it("normalizes a generic JSON agent and reports unsafe fields", () => {
+    const result = normalizeImportedAgent(
+      JSON.stringify({
+        name: "Launch Reviewer",
+        systemPrompt: "Review launch plans.",
+        tools: ["Read", "Search"],
+        hooks: { afterRun: "rm -rf ./tmp" },
+      }),
+      "agent.json",
+    );
+
+    expect(result).toMatchObject({
+      name: "Launch Reviewer",
+      tools: "Read, Search",
+      source: "json",
+    });
+    expect(result.warnings).toContain("Skipped unsafe capability: hooks");
+  });
+
+  it("builds the canonical runtime profile content", () => {
+    expect(
+      buildSimpleAgentContent({
+        name: "Research Partner",
+        description: "Synthesizes research",
+        instructions: "Ask for evidence before making claims.",
+        source: "claude",
+        sourcePath: ".claude/agents/research.md",
+        sourceHash: "abc123",
+      }),
+    ).toContain("source-hash: abc123");
+  });
+
+  it("keeps resolvable imported tools and warns for the rest", () => {
+    expect(
+      validateImportedAgentTools(
+        "Read, Bash, WebSearch",
+        new Set(["bash", "web-search"]),
+      ),
+    ).toEqual({
+      tools: "bash, web-search",
+      warnings: ["Skipped unmapped tool: Read"],
+    });
+  });
+
+  it("creates stable slugs for names", () => {
+    expect(slugifyAgentName("  User Research / KPMG  ")).toBe(
+      "user-research-kpmg",
+    );
+  });
+});

package/src/lib/simple-agent-profile.ts

@@ -0,0 +1,247 @@
+import {
+  frontmatterFieldsToObject,
+  parseFrontmatter,
+  serializeFrontmatter,
+} from "@agent-native/core/resources/metadata";
+
+export interface SimpleAgentProfileInput {
+  name: string;
+  description?: string;
+  model?: string;
+  tools?: string;
+  instructions: string;
+  source?: string;
+  sourcePath?: string;
+  sourceHash?: string;
+  importedAt?: string;
+}
+
+export interface ImportedAgentProfile {
+  name: string;
+  description?: string;
+  model?: string;
+  tools?: string;
+  instructions: string;
+  slug: string;
+  source: "markdown" | "claude" | "json";
+  sourcePath?: string;
+  warnings: string[];
+}
+
+export interface ImportedAgentToolValidation {
+  tools?: string;
+  warnings: string[];
+}
+
+const SUPPORTED_FIELDS = new Set([
+  "name",
+  "description",
+  "model",
+  "tools",
+  "color",
+  "delegate-default",
+  "source",
+  "source-path",
+  "source-hash",
+  "imported-at",
+]);
+
+export function slugifyAgentName(value: string): string {
+  return (
+    value
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "agent"
+  );
+}
+
+function deriveName(fileName?: string): string {
+  const baseName = fileName?.replaceAll("\\", "/").split("/").pop();
+  const name = baseName?.replace(/\.(md|markdown|json|txt)$/i, "");
+  return name?.trim() || "Imported agent";
+}
+
+function stringValue(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function toolsValue(value: unknown): string | undefined {
+  if (Array.isArray(value)) {
+    const tools = value.filter(
+      (item): item is string => typeof item === "string",
+    );
+    return tools.length > 0 ? tools.join(", ") : undefined;
+  }
+  return stringValue(value);
+}
+
+function normalizeToolKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+
+function importedToolNames(value: string): string[] {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.toLowerCase() === "inherit") return [];
+  const unwrapped = trimmed.replace(/^\[|\]$/g, "");
+  return unwrapped
+    .split(/[\n,]/)
+    .map((tool) => tool.trim().replace(/^['"]|['"]$/g, ""))
+    .filter(Boolean);
+}
+
+/**
+ * Imported tool names are descriptive input, not a permission grant. Keep only
+ * names the current Dispatch surface can resolve and make every omission
+ * visible to the caller instead of persisting a misleading tool list.
+ */
+export function validateImportedAgentTools(
+  tools: string | undefined,
+  availableToolNames: ReadonlySet<string>,
+): ImportedAgentToolValidation {
+  const names = importedToolNames(tools ?? "");
+  if (names.length === 0) return { warnings: [] };
+
+  const resolvable = new Map<string, string>();
+  for (const name of availableToolNames) {
+    resolvable.set(normalizeToolKey(name), name);
+  }
+
+  const mapped: string[] = [];
+  const warnings: string[] = [];
+  for (const name of names) {
+    const resolved = resolvable.get(normalizeToolKey(name));
+    if (resolved) {
+      if (!mapped.includes(resolved)) mapped.push(resolved);
+    } else {
+      warnings.push(`Skipped unmapped tool: ${name}`);
+    }
+  }
+
+  return {
+    tools: mapped.length > 0 ? mapped.join(", ") : undefined,
+    warnings,
+  };
+}
+
+function markdownProfile(
+  source: string,
+  fileName?: string,
+): Omit<ImportedAgentProfile, "source"> & {
+  source: "markdown" | "claude";
+} {
+  const frontmatter = parseFrontmatter(source);
+  const values = frontmatterFieldsToObject(frontmatter);
+  const body = (frontmatter?.body ?? source).trim();
+  const heading = body.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  const name = stringValue(values.name) || heading || deriveName(fileName);
+  const warnings = Object.keys(values)
+    .filter((key) => !SUPPORTED_FIELDS.has(key))
+    .map((key) => `Ignored unsupported field: ${key}`);
+  if (!body) warnings.push("The imported agent has no instructions yet.");
+
+  return {
+    name,
+    description: stringValue(values.description),
+    model: stringValue(values.model),
+    tools: toolsValue(values.tools),
+    instructions: body,
+    slug: slugifyAgentName(name),
+    source: fileName?.includes(".claude/") ? "claude" : "markdown",
+    sourcePath: fileName,
+    warnings,
+  };
+}
+
+function jsonProfile(source: string, fileName?: string): ImportedAgentProfile {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new Error("This file looks like JSON, but it is not valid JSON.");
+  }
+
+  const record =
+    parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  const candidate =
+    record?.agent &&
+    typeof record.agent === "object" &&
+    !Array.isArray(record.agent)
+      ? (record.agent as Record<string, unknown>)
+      : record;
+  if (!candidate) {
+    throw new Error("Import a single agent definition, not a JSON list.");
+  }
+
+  const name =
+    stringValue(candidate.name) ||
+    stringValue(candidate.title) ||
+    deriveName(fileName);
+  const instructions =
+    stringValue(candidate.instructions) ||
+    stringValue(candidate.systemPrompt) ||
+    stringValue(candidate.prompt) ||
+    stringValue(candidate.content) ||
+    "";
+  const warnings: string[] = [];
+  for (const key of ["hooks", "env", "environment", "command", "args", "cwd"]) {
+    if (candidate[key] !== undefined) {
+      warnings.push(`Skipped unsafe capability: ${key}`);
+    }
+  }
+  if (!instructions)
+    warnings.push("The imported agent has no instructions yet.");
+
+  return {
+    name,
+    description: stringValue(candidate.description),
+    model: stringValue(candidate.model),
+    tools: toolsValue(candidate.tools),
+    instructions,
+    slug: slugifyAgentName(name),
+    source: "json",
+    sourcePath: fileName,
+    warnings,
+  };
+}
+
+export function normalizeImportedAgent(
+  source: string,
+  fileName?: string,
+): ImportedAgentProfile {
+  const trimmed = source.trim();
+  if (!trimmed) throw new Error("Paste an agent definition or choose a file.");
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return jsonProfile(trimmed, fileName);
+  }
+  return markdownProfile(trimmed, fileName);
+}
+
+export function buildSimpleAgentContent(
+  input: SimpleAgentProfileInput,
+): string {
+  const fields = [
+    { key: "name", value: input.name.trim() },
+    ...(input.description?.trim()
+      ? [{ key: "description", value: input.description.trim() }]
+      : []),
+    { key: "model", value: input.model?.trim() || "inherit" },
+    { key: "tools", value: input.tools?.trim() || "inherit" },
+    { key: "delegate-default", value: "false" },
+    ...(input.source ? [{ key: "source", value: input.source }] : []),
+    ...(input.sourcePath
+      ? [{ key: "source-path", value: input.sourcePath }]
+      : []),
+    ...(input.sourceHash
+      ? [{ key: "source-hash", value: input.sourceHash }]
+      : []),
+    ...(input.importedAt
+      ? [{ key: "imported-at", value: input.importedAt }]
+      : []),
+  ];
+  return `${serializeFrontmatter(fields)}${input.instructions.trim()}\n`;
+}

package/src/lib/task-queue.spec.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  formatQueueAgeSeconds,
+  normalizeTaskQueueStats,
+  ZERO_TASK_QUEUE_STATS,
+} from "./task-queue";
+
+describe("normalizeTaskQueueStats", () => {
+  it("returns zeros for invalid payloads", () => {
+    expect(normalizeTaskQueueStats(null)).toEqual(ZERO_TASK_QUEUE_STATS);
+    expect(normalizeTaskQueueStats("bad")).toEqual(ZERO_TASK_QUEUE_STATS);
+  });
+
+  it("normalizes numeric fields and recent failures", () => {
+    expect(
+      normalizeTaskQueueStats({
+        pending: "2",
+        processing: 1,
+        completed_last_hour: 4,
+        failed_last_hour: "1",
+        oldest_pending_age_seconds: 90,
+        recent_failures: [
+          {
+            id: "f1",
+            platform: "slack",
+            error: "rate limited",
+            attempts: "3",
+          },
+        ],
+      }),
+    ).toEqual({
+      pending: 2,
+      processing: 1,
+      completed_last_hour: 4,
+      failed_last_hour: 1,
+      oldest_pending_age_seconds: 90,
+      recent_failures: [
+        {
+          id: "f1",
+          platform: "slack",
+          error: "rate limited",
+          attempts: 3,
+        },
+      ],
+    });
+  });
+});
+
+describe("formatQueueAgeSeconds", () => {
+  it("formats common ages", () => {
+    expect(formatQueueAgeSeconds(0)).toBe("none");
+    expect(formatQueueAgeSeconds(12)).toBe("12s");
+    expect(formatQueueAgeSeconds(120)).toBe("2m");
+    expect(formatQueueAgeSeconds(7200)).toBe("2.0h");
+  });
+});

package/src/lib/task-queue.ts

@@ -0,0 +1,72 @@
+import { agentNativePath } from "@agent-native/core/client/api-path";
+
+export interface TaskQueueFailure {
+  id: string;
+  platform: string;
+  error: string;
+  attempts: number;
+}
+
+export interface TaskQueueStats {
+  pending: number;
+  processing: number;
+  completed_last_hour: number;
+  failed_last_hour: number;
+  oldest_pending_age_seconds: number;
+  recent_failures: TaskQueueFailure[];
+}
+
+export const ZERO_TASK_QUEUE_STATS: TaskQueueStats = {
+  pending: 0,
+  processing: 0,
+  completed_last_hour: 0,
+  failed_last_hour: 0,
+  oldest_pending_age_seconds: 0,
+  recent_failures: [],
+};
+
+function asNumber(value: unknown): number {
+  const n = Number(value ?? 0);
+  return Number.isFinite(n) ? n : 0;
+}
+
+export function normalizeTaskQueueStats(value: unknown): TaskQueueStats {
+  if (!value || typeof value !== "object") return ZERO_TASK_QUEUE_STATS;
+  const stats = value as Record<string, unknown>;
+  return {
+    pending: asNumber(stats.pending),
+    processing: asNumber(stats.processing),
+    completed_last_hour: asNumber(stats.completed_last_hour),
+    failed_last_hour: asNumber(stats.failed_last_hour),
+    oldest_pending_age_seconds: asNumber(stats.oldest_pending_age_seconds),
+    recent_failures: Array.isArray(stats.recent_failures)
+      ? stats.recent_failures.map((failure, index) => {
+          const row =
+            failure && typeof failure === "object"
+              ? (failure as Record<string, unknown>)
+              : {};
+          return {
+            id: String(row.id ?? `failure-${index}`),
+            platform: String(row.platform ?? ""),
+            error: String(row.error ?? ""),
+            attempts: asNumber(row.attempts),
+          };
+        })
+      : [],
+  };
+}
+
+export async function getDispatchTaskQueueStats(): Promise<TaskQueueStats> {
+  const response = await fetch(
+    agentNativePath("/_agent-native/integrations/task-queue/status"),
+  );
+  if (!response.ok) return ZERO_TASK_QUEUE_STATS;
+  return normalizeTaskQueueStats(await response.json().catch(() => null));
+}
+
+export function formatQueueAgeSeconds(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds <= 0) return "none";
+  if (seconds < 60) return `${Math.round(seconds)}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  return `${(seconds / 3600).toFixed(1)}h`;
+}

package/src/lib/thread-link-preview.ts

@@ -0,0 +1,160 @@
+export interface ThreadLinkPreview {
+  title: string;
+  description: string;
+  imageUrl: string | null;
+}
+
+const IMAGE_URL_KEYS = new Set([
+  "previewUrl",
+  "thumbnailUrl",
+  "imageUrl",
+  "image",
+  "downloadUrl",
+]);
+
+const GENERATION_TOOL_NAMES = new Set([
+  "generate-image",
+  "generate-image-batch",
+  "refine-image",
+  "rerun-generation-run",
+]);
+
+function safeJsonParse(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function cleanUrlCandidate(value: string): string {
+  return value
+    .trim()
+    .replace(/[),.;\]}]+$/g, "")
+    .replace(/^["'(<]+/g, "");
+}
+
+function isAbsoluteHttpUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+
+function isImageLikeUrl(value: string): boolean {
+  try {
+    const url = new URL(value);
+    return (
+      /\.(?:png|jpe?g|webp|gif|avif)(?:$|[?#])/i.test(url.pathname) ||
+      /\/api\/assets\/[^/]+\/content(?:$|[?#])/i.test(url.pathname)
+    );
+  } catch {
+    return false;
+  }
+}
+
+function validPreviewImageUrl(value: unknown, key?: string): string | null {
+  if (typeof value !== "string") return null;
+  const candidate = cleanUrlCandidate(value);
+  if (!isAbsoluteHttpUrl(candidate)) return null;
+  if (key && IMAGE_URL_KEYS.has(key)) return candidate;
+  return isImageLikeUrl(candidate) ? candidate : null;
+}
+
+function imageUrlFromStructuredValue(value: unknown): string | null {
+  if (!value || typeof value !== "object") return null;
+  if (Array.isArray(value)) {
+    for (let i = value.length - 1; i >= 0; i--) {
+      const found = imageUrlFromStructuredValue(value[i]);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  const record = value as Record<string, unknown>;
+  for (const key of IMAGE_URL_KEYS) {
+    const found = validPreviewImageUrl(record[key], key);
+    if (found) return found;
+  }
+  for (const [key, child] of Object.entries(record).reverse()) {
+    const direct = validPreviewImageUrl(child, key);
+    if (direct) return direct;
+    if (child && typeof child === "object") {
+      const nested = imageUrlFromStructuredValue(child);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function imageUrlFromText(value: string): string | null {
+  const matches = value.match(/https?:\/\/[^\s<>"']+/g);
+  if (!matches) return null;
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const candidate = validPreviewImageUrl(matches[i]);
+    if (candidate) return candidate;
+  }
+  return null;
+}
+
+export function extractThreadPreviewImageUrl(
+  threadData: string,
+): string | null {
+  const parsed = safeJsonParse(threadData);
+  if (!parsed || typeof parsed !== "object") return null;
+  const messages = (parsed as { messages?: unknown }).messages;
+  if (!Array.isArray(messages)) return null;
+
+  for (
+    let messageIndex = messages.length - 1;
+    messageIndex >= 0;
+    messageIndex--
+  ) {
+    const entry = messages[messageIndex] as any;
+    const message = entry?.message ?? entry;
+    const content = message?.content;
+    if (!Array.isArray(content)) continue;
+
+    for (let partIndex = content.length - 1; partIndex >= 0; partIndex--) {
+      const part = content[partIndex] as Record<string, unknown>;
+      const result = typeof part.result === "string" ? part.result : "";
+      if (!result.trim()) continue;
+
+      const toolName = typeof part.toolName === "string" ? part.toolName : "";
+      const parsedResult = safeJsonParse(result);
+      if (parsedResult && GENERATION_TOOL_NAMES.has(toolName)) {
+        const structured = imageUrlFromStructuredValue(parsedResult);
+        if (structured) return structured;
+      }
+
+      const fromText = imageUrlFromText(result);
+      if (fromText) return fromText;
+    }
+  }
+  return null;
+}
+
+export function buildThreadLinkPreviewMeta(preview: ThreadLinkPreview | null) {
+  const title = preview?.title ? `${preview.title} - Dispatch` : "Dispatch";
+  const description =
+    preview?.description ||
+    "Open this Agent-Native thread in the Dispatch workspace.";
+  const image = preview?.imageUrl ?? null;
+  return [
+    { title },
+    { name: "description", content: description },
+    { property: "og:title", content: title },
+    { property: "og:description", content: description },
+    { property: "og:type", content: "website" },
+    ...(image ? [{ property: "og:image", content: image }] : []),
+    {
+      name: "twitter:card",
+      content: image ? "summary_large_image" : "summary",
+    },
+    { name: "twitter:title", content: title },
+    { name: "twitter:description", content: description },
+    ...(image ? [{ name: "twitter:image", content: image }] : []),
+  ];
+}

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/lib/workspace-app-layout.spec.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  normalizeWorkspaceAppLayout,
+  orderWorkspaceApps,
+  toggleWorkspaceAppPinned,
+  workspaceAppMatchesQuery,
+} from "./workspace-app-layout";
+
+describe("workspace app layout", () => {
+  it("keeps pinned apps first without changing the remaining catalog order", () => {
+    const apps = [
+      { id: "mail", name: "Mail" },
+      { id: "analytics", name: "Analytics" },
+      { id: "calendar", name: "Calendar" },
+    ];
+
+    expect(
+      orderWorkspaceApps(apps, {
+        pinnedIds: ["calendar", "calendar"],
+        orderedIds: ["mail", "analytics", "calendar"],
+      }).map((app) => app.id),
+    ).toEqual(["calendar", "mail", "analytics"]);
+  });
+
+  it("matches app names and descriptions case-insensitively", () => {
+    expect(
+      workspaceAppMatchesQuery(
+        { name: "Analytics", description: "Explore product health" },
+        "PRODUCT",
+      ),
+    ).toBe(true);
+    expect(workspaceAppMatchesQuery({ name: "Mail" }, "calendar")).toBe(false);
+  });
+
+  it("normalizes persisted layout ids and toggles pin state", () => {
+    const layout = normalizeWorkspaceAppLayout({
+      pinnedIds: ["mail", "mail", 42],
+      orderedIds: ["calendar", "", "calendar"],
+    });
+
+    expect(toggleWorkspaceAppPinned(layout, "calendar")).toEqual({
+      pinnedIds: ["calendar", "mail"],
+      orderedIds: ["calendar"],
+    });
+  });
+});