@mndrk/agx 2.0.32 → 2.0.34

package/cloud-runtime/standalone/hooks/useGroupChat.ts

@@ -28,6 +28,8 @@ export interface ChatRunInfo {
   threadId: string;
   rootMessageId: string | null;
   status: "queued" | "running" | "awaiting_user" | "blocked" | "completed" | "failed" | "cancelled";
+  optimistic?: boolean;
+  enqueuedAt?: number;
 }
 
 export function useGroupChat(threadId: string | null) {
@@ -107,13 +109,15 @@ export function useGroupChat(threadId: string | null) {
       attachmentIds?: string[],
       attachmentMetas?: import("@/lib/types").Attachment[],
       activeParticipantIds?: string[],
-      projectSlug?: string
+      projectSlug?: string,
+      promptPrefix?: string
     ) => {
       const activeThreadId = threadIdOverride?.trim() || threadIdRef.current?.trim();
       if (!activeThreadId) {
         return;
       }
 
+      // Display the clean user text in the chat thread
       const now = Date.now();
       const userMessageId = crypto.randomUUID();
       const userMsg: GroupMessage = {
@@ -136,6 +140,7 @@ export function useGroupChat(threadId: string | null) {
           body: JSON.stringify({
             threadId: activeThreadId,
             prompt,
+            promptPrefix: promptPrefix || undefined,
             maxRounds,
             userMessageId,
             rootMessageId: rootMessageId || undefined,
@@ -152,6 +157,8 @@ export function useGroupChat(threadId: string | null) {
               threadId: activeThreadId,
               rootMessageId: rootMessageId || userMessageId,
               status: "queued",
+              optimistic: true,
+              enqueuedAt: Date.now(),
             },
             ...prev.filter((run) => run.chatRunId !== payload.chatRunId),
           ]);

package/cloud-runtime/standalone/hooks/useProcessPolling.ts

@@ -11,7 +11,7 @@ const ACTIVE_STATES = new Set(["spawning", "running"]);
 function normalizeChatRuns(value: unknown): ChatRunInfo[] {
   if (!Array.isArray(value)) return [];
   return value
-    .map((entry) => {
+    .map<ChatRunInfo | null>((entry) => {
       if (!entry || typeof entry !== "object") return null;
       const row = entry as Record<string, unknown>;
       const chatRunId =
@@ -47,7 +47,8 @@ function normalizeChatRuns(value: unknown): ChatRunInfo[] {
         threadId,
         rootMessageId,
         status,
-      } satisfies ChatRunInfo;
+        optimistic: false,
+      };
     })
     .filter((entry): entry is ChatRunInfo => Boolean(entry));
 }
@@ -124,7 +125,7 @@ export function useProcessPolling(
         : null;
 
       const chatRunsUrl = historyThreadId
-        ? `/api/chat-runs?threadId=${encodeURIComponent(historyThreadId)}&status=active&limit=20`
+        ? `/api/chat-runs?threadId=${encodeURIComponent(historyThreadId)}&limit=20`
         : null;
 
       const fetches: Promise<Response>[] = [fetch(processUrl)];

package/cloud-runtime/standalone/hooks/usePromptJobs.ts

@@ -0,0 +1,111 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import type { PromptJob, PromptRun } from '@/src/prompt-scheduler/types';
+
+export function usePromptJobs(projectId?: string) {
+  const [jobs, setJobs] = useState<PromptJob[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchJobs = useCallback(async () => {
+    try {
+      setLoading(true);
+      const params = projectId ? `?projectId=${encodeURIComponent(projectId)}` : '';
+      const res = await fetch(`/api/prompt-jobs${params}`);
+      if (!res.ok) throw new Error(`Failed to fetch: ${res.status}`);
+      const data = await res.json();
+      setJobs(data.jobs ?? []);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setLoading(false);
+    }
+  }, [projectId]);
+
+  useEffect(() => {
+    fetchJobs();
+    const interval = setInterval(fetchJobs, 10_000);
+    return () => clearInterval(interval);
+  }, [fetchJobs]);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const createJob = useCallback(async (input: any) => {
+    const res = await fetch('/api/prompt-jobs', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const updateJob = useCallback(async (id: string, updates: Partial<PromptJob>) => {
+    const res = await fetch(`/api/prompt-jobs/${id}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(updates),
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const deleteJob = useCallback(async (id: string) => {
+    const res = await fetch(`/api/prompt-jobs/${id}`, {
+      method: 'DELETE',
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const toggleJob = useCallback(async (job: PromptJob) => {
+    const newState = job.state === 'active' ? 'paused' : 'active';
+    const res = await fetch(`/api/prompt-jobs/${job.id}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ state: newState }),
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const runNow = useCallback(async (id: string) => {
+    const res = await fetch('/api/prompt-jobs/poll', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jobId: id }),
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const cancelRun = useCallback(async (id: string) => {
+    const res = await fetch(`/api/prompt-jobs/${id}/cancel`, {
+      method: 'POST',
+    });
+    if (res.ok) await fetchJobs();
+    return res.ok;
+  }, [fetchJobs]);
+
+  const fetchRuns = useCallback(async (jobId: string): Promise<PromptRun[]> => {
+    const res = await fetch(`/api/prompt-jobs/${jobId}/runs`);
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.runs ?? [];
+  }, []);
+
+  return {
+    jobs,
+    loading,
+    error,
+    refresh: fetchJobs,
+    createJob,
+    updateJob,
+    deleteJob,
+    toggleJob,
+    runNow,
+    cancelRun,
+    fetchRuns,
+  };
+}

package/cloud-runtime/standalone/hooks/useThreadState.ts

@@ -41,10 +41,18 @@ export function useThreadState(initialThreadId?: string) {
 
     (async () => {
       try {
-        const fetched = await threadService.listThreads();
+        const routeThreadId = (initialThreadId || searchParams.get("thread") || "").trim() || null;
+        let fetched = await threadService.listThreads();
+        if (routeThreadId && !fetched.some((thread) => thread.id === routeThreadId)) {
+          const placeholder = await threadService.createThread({ id: routeThreadId });
+          fetched = sortByCreatedAt([
+            ...fetched.filter((thread) => thread.id !== placeholder.id),
+            placeholder,
+          ]);
+        }
         if (cancelled || !isMounted.current) return;
         setThreads(fetched);
-        const urlThreadId = initialThreadId || searchParams.get("thread");
+        const urlThreadId = routeThreadId;
         const savedThreadId = urlThreadId || loadLastThreadId();
         const { threadId: resolvedThreadId, shouldClearSavedId, restoredFromStorage } =
           resolveInitialThreadSelection(fetched, savedThreadId);

package/cloud-runtime/standalone/lib/agent-participants.ts

@@ -1,23 +1,29 @@
 import { getAgents, getAgentSkills } from "@/lib/db";
+import { getAgentSkillBindings } from "@/lib/agent-skill-bindings";
 import { LOCAL_USER } from "@/lib/auth-mode";
 import type { ChatProvider, Participant } from "@/lib/types";
 
 export async function loadDbParticipants(): Promise<Participant[]> {
   const agents = await getAgents(LOCAL_USER.id);
   const skillsByAgent = new Map<string, Awaited<ReturnType<typeof getAgentSkills>>>();
+  const bindingsByAgent = new Map<string, Awaited<ReturnType<typeof getAgentSkillBindings>>>();
   await Promise.all(
     agents.map(async (agent) => {
       skillsByAgent.set(agent.id, await getAgentSkills(agent.id));
+      bindingsByAgent.set(agent.id, await getAgentSkillBindings(agent.id));
     })
   );
 
   return agents.map((agent) => ({
     id: agent.id,
     name: agent.name,
+    ...(agent.title ? { title: agent.title } : {}),
     provider: (agent.provider || "claude") as ChatProvider,
     model: agent.model || null,
     color: agent.color || "#6B7280",
     ...(agent.description ? { identity: agent.description } : {}),
+    ...(agent.voice ? { voice: agent.voice } : {}),
+    ...(agent.seed ? { seed: agent.seed } : {}),
     ...(skillsByAgent.get(agent.id)?.length
       ? {
         skills: skillsByAgent.get(agent.id)!.map((skill) => ({
@@ -26,6 +32,7 @@ export async function loadDbParticipants(): Promise<Participant[]> {
         })),
       }
       : {}),
+    ...(bindingsByAgent.get(agent.id)?.length ? { skillBindings: bindingsByAgent.get(agent.id) } : {}),
   }));
 }
 

package/cloud-runtime/standalone/lib/agent-skill-bindings.ts

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import { getSQLiteDb } from "./sqlite-query-adapter";
+import { installSkill, installedSkillPath } from "./skills-library";
+import type { ChatProvider, SkillBinding } from "./types";
+
+export type AgentSkillBindingRow = {
+  agent_id: string;
+  repo: string;
+  skill_id: string;
+  condition: string | null;
+  created_at: string;
+};
+
+export async function getAgentSkillBindings(agentId: string): Promise<SkillBinding[]> {
+  const db = getSQLiteDb();
+  const rows = db
+    .prepare("SELECT agent_id, repo, skill_id, condition, created_at FROM agent_skill_bindings WHERE agent_id = ? ORDER BY created_at ASC")
+    .all(agentId) as AgentSkillBindingRow[];
+  return rows.map((row) => ({
+    repo: row.repo,
+    skillId: row.skill_id,
+    ...(row.condition ? { condition: row.condition } : {}),
+  }));
+}
+
+export async function setAgentSkillBindings(agentId: string, bindings: SkillBinding[]): Promise<SkillBinding[]> {
+  const db = getSQLiteDb();
+  const normalized = new Map<string, { repo: string; skillId: string; condition: string | null }>();
+  for (const binding of bindings) {
+    const repo = binding.repo.trim();
+    const skillId = binding.skillId.trim();
+    if (!repo || !skillId) continue;
+    normalized.set(`${repo}::${skillId}`, {
+      repo,
+      skillId,
+      condition: binding.condition?.trim() || null,
+    });
+  }
+
+  const existing = await getAgentSkillBindings(agentId);
+  for (const binding of existing) {
+    const key = `${binding.repo}::${binding.skillId}`;
+    if (!normalized.has(key)) {
+      db.prepare("DELETE FROM agent_skill_bindings WHERE agent_id = ? AND repo = ? AND skill_id = ?").run(agentId, binding.repo, binding.skillId);
+    }
+  }
+
+  for (const entry of normalized.values()) {
+    db.prepare(
+      `INSERT INTO agent_skill_bindings (agent_id, repo, skill_id, condition)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(agent_id, repo, skill_id) DO UPDATE SET condition = excluded.condition`
+    ).run(agentId, entry.repo, entry.skillId, entry.condition);
+  }
+
+  return getAgentSkillBindings(agentId);
+}
+
+function normalizeText(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function uniqueTerms(input: string): string[] {
+  const seen = new Set<string>();
+  const terms: string[] = [];
+  for (const piece of normalizeText(input).split(" ")) {
+    if (piece.length < 4 || seen.has(piece)) continue;
+    seen.add(piece);
+    terms.push(piece);
+  }
+  return terms;
+}
+
+function isBindingRelevant(binding: SkillBinding, prompt: string): boolean {
+  const normalizedPrompt = normalizeText(prompt);
+  if (!normalizedPrompt) return false;
+
+  const explicitHints = binding.condition
+    ? binding.condition.split(/\n|,|;|\|/g).map((item) => normalizeText(item)).filter((item) => item.length >= 4)
+    : [];
+  if (explicitHints.some((hint) => normalizedPrompt.includes(hint))) {
+    return true;
+  }
+
+  const repoTail = binding.repo.split("/").filter(Boolean).pop() ?? binding.repo;
+  const inferredTerms = [
+    ...uniqueTerms(binding.skillId),
+    ...uniqueTerms(repoTail),
+  ];
+  return inferredTerms.some((term) => normalizedPrompt.includes(term));
+}
+
+export function resolveBoundSkillFiles(
+  bindings: SkillBinding[],
+  prompt: string,
+  provider: ChatProvider
+): Array<{ file: string; condition?: string }> {
+  const resolved: Array<{ file: string; condition?: string }> = [];
+
+  for (const binding of bindings) {
+    if (!isBindingRelevant(binding, prompt)) continue;
+    const file = installedSkillPath(binding.skillId);
+    if (!fs.existsSync(file)) {
+      const installResult = installSkill({
+        repo: binding.repo,
+        skillId: binding.skillId,
+        providers: [provider],
+      });
+      if (!installResult.ok) continue;
+    }
+    resolved.push({
+      file,
+      ...(binding.condition ? { condition: binding.condition } : {}),
+    });
+  }
+
+  return resolved;
+}

package/cloud-runtime/standalone/lib/chat/paste-attachments.ts

@@ -0,0 +1,152 @@
+const TEXT_PASTE_LENGTH_THRESHOLD = 200;
+
+const MIME_EXTENSION_MAP: Record<string, string> = {
+  "image/jpeg": "jpg",
+  "image/png": "png",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "application/pdf": "pdf",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "text/markdown": "md",
+  "application/json": "json",
+  "application/zip": "zip",
+  "application/gzip": "gz",
+};
+
+type ClipboardLike = Pick<DataTransfer, "files" | "items" | "getData">;
+
+interface ClipboardBlobLike {
+  size: number;
+  type: string;
+  arrayBuffer?(): Promise<ArrayBuffer>;
+}
+
+interface ClipboardItemLike {
+  readonly types: readonly string[];
+  getType(type: string): Promise<ClipboardBlobLike>;
+}
+
+interface ClipboardReaderLike {
+  read(): Promise<ClipboardItemLike[]>;
+}
+
+function shouldLetEditorHandleTextPaste(text: string): boolean {
+  const plainText = text.trim();
+  if (!plainText) return false;
+  return plainText.length >= TEXT_PASTE_LENGTH_THRESHOLD || plainText.includes("\n");
+}
+
+function buildFallbackFilename(file: File, index: number): string {
+  const extension = MIME_EXTENSION_MAP[file.type] ?? "bin";
+  const prefix = file.type.startsWith("image/") ? "pasted-image" : "attachment";
+  return `${prefix}-${index + 1}.${extension}`;
+}
+
+function ensureFileName(file: File, index: number): File {
+  const name = file.name.trim();
+  if (name) return file;
+  return new File([file], buildFallbackFilename(file, index), {
+    type: file.type,
+    lastModified: file.lastModified,
+  });
+}
+
+export function normalizeAttachmentFiles(files: File[]): File[] {
+  return files.map((file, index) => ensureFileName(file, index));
+}
+
+function isClipboardItemImageType(type: string): boolean {
+  return type.startsWith("image/");
+}
+
+function getClipboardText(clipboardData: ClipboardLike | null): string {
+  if (!clipboardData) return "";
+  return clipboardData.getData("text/plain");
+}
+
+function shouldReadAttachmentsFromClipboard(clipboardData: ClipboardLike | null): boolean {
+  const plainText = getClipboardText(clipboardData);
+  if (shouldLetEditorHandleTextPaste(plainText)) {
+    return false;
+  }
+
+  const itemTypes = Array.from(clipboardData?.items ?? []).map((item) => item.type);
+  return (
+    Array.from(clipboardData?.files ?? []).length > 0 ||
+    Array.from(clipboardData?.items ?? []).some((item) => item.kind === "file") ||
+    itemTypes.some(isClipboardItemImageType)
+  );
+}
+
+export function getClipboardAttachmentFiles(clipboardData: ClipboardLike | null): File[] {
+  if (!clipboardData) return [];
+
+  // Some apps place both rich-text clipboard metadata and an image blob on the clipboard.
+  // When the payload is clearly text-heavy, let the editor handle the paste instead of
+  // hijacking it as an attachment upload.
+  if (!shouldReadAttachmentsFromClipboard(clipboardData)) {
+    return [];
+  }
+
+  const itemFiles = Array.from(clipboardData.items ?? [])
+    .filter((item) => item.kind === "file")
+    .map((item) => item.getAsFile())
+    .filter((file): file is File => Boolean(file));
+
+  const files = itemFiles.length > 0
+    ? itemFiles
+    : Array.from(clipboardData.files ?? []);
+
+  if (files.length === 0) return [];
+
+  return normalizeAttachmentFiles(files);
+}
+
+export function clipboardMayContainImageAttachments(clipboardData: ClipboardLike | null): boolean {
+  return shouldReadAttachmentsFromClipboard(clipboardData);
+}
+
+export async function readClipboardAttachmentFiles(
+  clipboardData: ClipboardLike | null,
+  clipboardReader?: ClipboardReaderLike | null
+): Promise<File[]> {
+  const directFiles = getClipboardAttachmentFiles(clipboardData);
+  if (directFiles.length > 0) {
+    return directFiles;
+  }
+
+  if (!shouldReadAttachmentsFromClipboard(clipboardData) || !clipboardReader?.read) {
+    return [];
+  }
+
+  try {
+    const clipboardItems = await clipboardReader.read();
+    const files: File[] = [];
+
+    for (const item of clipboardItems) {
+      const imageTypes = item.types.filter(isClipboardItemImageType);
+      for (const type of imageTypes) {
+        const blob = await item.getType(type);
+        const filePart =
+          blob instanceof Blob
+            ? blob
+            : blob.arrayBuffer
+              ? await blob.arrayBuffer()
+              : null;
+        if (!filePart) continue;
+        files.push(
+          new File([filePart], "", {
+            type: blob.type || type,
+            lastModified: Date.now(),
+          })
+        );
+      }
+    }
+
+    return normalizeAttachmentFiles(files);
+  } catch {
+    return [];
+  }
+}