@mndrk/agx 2.0.33 → 2.0.34

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 [];
+  }
+}

package/cloud-runtime/standalone/lib/db.ts

@@ -248,6 +248,7 @@ export interface Agent {
   id: string;
   user_id: string;
   name: string;
+  title?: string;
   style: AgentStyle;
   description?: string;
   voice?: string;
@@ -2308,6 +2309,7 @@ export async function createAgent(
   input: {
     id?: string;
     name: string;
+    title?: string;
     style: AgentStyle;
     description?: string;
     voice?: string;
@@ -2326,6 +2328,7 @@ export async function createAgent(
     description: input.description ?? null,
   };
   if (input.id !== undefined) payload.id = input.id;
+  if (input.title !== undefined) payload.title = input.title;
   if (input.voice !== undefined) payload.voice = input.voice;
   if (input.seed !== undefined) payload.seed = input.seed;
   if (input.model !== undefined) payload.model = input.model;
@@ -2352,6 +2355,7 @@ export async function updateAgent(
   userId: string,
   input: {
     name?: string;
+    title?: string;
     style?: AgentStyle;
     description?: string;
     voice?: string;
@@ -2365,6 +2369,7 @@ export async function updateAgent(
 
   const updatePayload: Record<string, unknown> = { updated_at: new Date().toISOString() };
   if (input.name !== undefined) updatePayload.name = input.name;
+  if (input.title !== undefined) updatePayload.title = input.title;
   if (input.style !== undefined) updatePayload.style = input.style;
   if (input.description !== undefined) updatePayload.description = input.description;
   if (input.voice !== undefined) updatePayload.voice = input.voice;

package/cloud-runtime/standalone/lib/history-store.ts

@@ -546,6 +546,11 @@ const withDatabase = async <T>(run: (db: Database.Database) => T): Promise<T> =>
         started_at INTEGER NOT NULL,
         completed_at INTEGER
       );
+      CREATE TABLE IF NOT EXISTS thread_repo_selections (
+        thread_id TEXT NOT NULL,
+        repo_id TEXT NOT NULL,
+        PRIMARY KEY (thread_id, repo_id)
+      );
     `);
     migrateLegacyTables(db);
     migrateThreadReplyColumns(db);
@@ -1879,3 +1884,36 @@ export async function deleteTaskDraft(
       .run(normalizedThreadId, messageId);
   });
 }
+
+// ── Thread repo selections ──────────────────────────────────────────────────
+
+export async function loadThreadRepoSelections(
+  rootMessageId: string,
+): Promise<string[]> {
+  const key = rootMessageId.trim() || LEGACY_THREAD_ID;
+  return withDatabase((db) => {
+    const rows = db
+      .prepare("SELECT repo_id FROM thread_repo_selections WHERE thread_id = ?")
+      .all(key) as Array<{ repo_id: string }>;
+    return rows.map((r) => r.repo_id);
+  });
+}
+
+export async function saveThreadRepoSelections(
+  rootMessageId: string,
+  repoIds: string[],
+): Promise<void> {
+  const key = rootMessageId.trim() || LEGACY_THREAD_ID;
+  return withDatabase((db) => {
+    db.prepare("DELETE FROM thread_repo_selections WHERE thread_id = ?")
+      .run(key);
+    if (repoIds.length > 0) {
+      const insert = db.prepare(
+        "INSERT INTO thread_repo_selections (thread_id, repo_id) VALUES (?, ?)"
+      );
+      for (const repoId of repoIds) {
+        insert.run(key, repoId);
+      }
+    }
+  });
+}