@mndrk/agx 2.0.42 → 2.0.45

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

@@ -2,6 +2,7 @@
 
 import { useState, useCallback, useRef } from "react";
 import type { GroupMessage } from "@/lib/types";
+import type { ComposerRoutingMetadata } from "@/lib/chat/composer-routing";
 
 export interface LogEntry {
   timestamp: number;
@@ -110,7 +111,8 @@ export function useGroupChat(threadId: string | null) {
       attachmentMetas?: import("@/lib/types").Attachment[],
       activeParticipantIds?: string[],
       projectSlug?: string,
-      promptPrefix?: string
+      promptPrefix?: string,
+      routing?: ComposerRoutingMetadata
     ) => {
       const activeThreadId = threadIdOverride?.trim() || threadIdRef.current?.trim();
       if (!activeThreadId) {
@@ -147,6 +149,7 @@ export function useGroupChat(threadId: string | null) {
             attachmentIds: attachmentIds?.length ? attachmentIds : undefined,
             activeParticipantIds: Array.isArray(activeParticipantIds) ? activeParticipantIds : undefined,
             projectSlug: projectSlug?.trim() || undefined,
+            routing,
           }),
         });
         const payload = await response.json().catch(() => null) as { chatRunId?: string } | null;

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

@@ -0,0 +1,128 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+interface CliStatus {
+  claude: boolean;
+  codex: boolean;
+  gemini: boolean;
+}
+
+type McpStatus = Record<string, boolean>;
+
+interface LinearConnectionState {
+  connected: boolean;
+  loading: boolean;
+  user: { name: string; email: string } | null;
+  clis: CliStatus;
+  mcpConfigured: McpStatus;
+  connect: () => void;
+  connectWithKey: (apiKey: string) => Promise<{ ok: boolean; error?: string }>;
+  disconnect: () => Promise<void>;
+  configureMcp: (cli: string) => Promise<{ ok: boolean; error?: string }>;
+  refresh: () => Promise<boolean>;
+}
+
+export function useLinearConnection(): LinearConnectionState {
+  const [connected, setConnected] = useState(false);
+  const [loading, setLoading] = useState(true);
+  const [user, setUser] = useState<{ name: string; email: string } | null>(null);
+  const [clis, setClis] = useState<CliStatus>({ claude: false, codex: false, gemini: false });
+  const [mcpConfigured, setMcpConfigured] = useState<McpStatus>({});
+  const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const refreshMcp = useCallback(async () => {
+    try {
+      const res = await fetch("/api/linear/mcp-setup");
+      const data = await res.json();
+      setMcpConfigured(data.configured ?? {});
+    } catch {
+      // ignore
+    }
+  }, []);
+
+  const refresh = useCallback(async () => {
+    try {
+      const [statusRes, mcpRes] = await Promise.all([
+        fetch("/api/linear/status"),
+        fetch("/api/linear/mcp-setup"),
+      ]);
+      const statusData = await statusRes.json();
+      const mcpData = await mcpRes.json();
+      setConnected(statusData.connected);
+      setUser(statusData.user ?? null);
+      setClis(statusData.clis ?? { claude: false, codex: false, gemini: false });
+      setMcpConfigured(mcpData.configured ?? {});
+      return statusData.connected as boolean;
+    } catch {
+      setConnected(false);
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    refresh();
+    return () => {
+      if (pollRef.current) clearInterval(pollRef.current);
+    };
+  }, [refresh]);
+
+  const connect = useCallback(() => {
+    // Open OAuth in a new tab
+    window.open("/api/linear/auth", "_blank", "noopener");
+
+    // Poll for connection until successful
+    if (pollRef.current) clearInterval(pollRef.current);
+    pollRef.current = setInterval(async () => {
+      const isConnected = await refresh();
+      if (isConnected && pollRef.current) {
+        clearInterval(pollRef.current);
+        pollRef.current = null;
+      }
+    }, 2000);
+  }, [refresh]);
+
+  const connectWithKey = useCallback(async (apiKey: string): Promise<{ ok: boolean; error?: string }> => {
+    try {
+      const res = await fetch("/api/linear/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ accessToken: apiKey }),
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        return { ok: false, error: data.error || "Failed to save token" };
+      }
+      await refresh();
+      return { ok: true };
+    } catch {
+      return { ok: false, error: "Failed to connect" };
+    }
+  }, [refresh]);
+
+  const disconnect = useCallback(async () => {
+    await fetch("/api/linear/status", { method: "DELETE" });
+    setConnected(false);
+    setUser(null);
+  }, []);
+
+  const configureMcp = useCallback(async (cli: string): Promise<{ ok: boolean; error?: string }> => {
+    try {
+      const res = await fetch("/api/linear/mcp-setup", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ cli }),
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        return { ok: false, error: data.error || "Failed to configure MCP" };
+      }
+      await refreshMcp();
+      return { ok: true };
+    } catch {
+      return { ok: false, error: "Failed to configure MCP" };
+    }
+  }, [refreshMcp]);
+
+  return { connected, loading, user, clis, mcpConfigured, connect, connectWithKey, disconnect, configureMcp, refresh };
+}

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

@@ -0,0 +1,64 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import type { LinearIssue } from "@/hooks/useLinearIssues";
+
+interface UseLinearIssueMentionsOptions {
+  projectSlug?: string;
+  enabled?: boolean;
+  limit?: number;
+}
+
+interface UseLinearIssueMentionsReturn {
+  issues: LinearIssue[];
+  loading: boolean;
+}
+
+export function useLinearIssueMentions({
+  projectSlug,
+  enabled = true,
+  limit = 500,
+}: UseLinearIssueMentionsOptions = {}): UseLinearIssueMentionsReturn {
+  const [issues, setIssues] = useState<LinearIssue[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (!enabled) {
+      setIssues([]);
+      setLoading(false);
+      return;
+    }
+
+    let cancelled = false;
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (projectSlug) {
+      params.set("projectSlug", projectSlug);
+    }
+
+    setLoading(true);
+    fetch(`/api/linear/issues?${params.toString()}`)
+      .then(async (response) => {
+        const data = await response.json().catch(() => ({}));
+        if (!cancelled) {
+          setIssues(Array.isArray(data.issues) ? data.issues : []);
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          setIssues([]);
+        }
+      })
+      .finally(() => {
+        if (!cancelled) {
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, limit, projectSlug]);
+
+  return { issues, loading };
+}

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

@@ -0,0 +1,98 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+
+export interface LinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  url: string | null;
+  status: string;
+  assignee: string | null;
+  updatedAt: string;
+}
+
+interface Filters {
+  teamId?: string;
+  status?: string;
+  search?: string;
+  assigneeId?: string;
+  assignedToMe?: boolean;
+  cycleId?: string;
+}
+
+interface UseLinearIssuesOptions {
+  projectSlug?: string;
+  limit?: number;
+}
+
+interface UseLinearIssuesReturn {
+  issues: LinearIssue[];
+  loading: boolean;
+  hasMore: boolean;
+  loadMore: () => Promise<void>;
+  refresh: () => Promise<void>;
+}
+
+export function useLinearIssues(
+  filters: Filters,
+  enabled = true,
+  options: UseLinearIssuesOptions = {}
+): UseLinearIssuesReturn {
+  const [issues, setIssues] = useState<LinearIssue[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [cursor, setCursor] = useState<string | null>(null);
+  const [hasMore, setHasMore] = useState(false);
+  const cursorRef = useRef(cursor);
+  const hydratedRef = useRef(false);
+  cursorRef.current = cursor;
+
+  useEffect(() => {
+    hydratedRef.current = false;
+  }, [options.projectSlug]);
+
+  const fetchPage = useCallback(
+    async (append: boolean, refresh = false) => {
+      if (!enabled) return;
+      setLoading(true);
+      try {
+        const params = new URLSearchParams();
+        if (filters.teamId) params.set("teamId", filters.teamId);
+        if (filters.status) params.set("status", filters.status);
+        if (filters.search) params.set("search", filters.search);
+        if (filters.assigneeId) params.set("assigneeId", filters.assigneeId);
+        else if (filters.assignedToMe) params.set("assignedToMe", "true");
+        if (filters.cycleId) params.set("cycleId", filters.cycleId);
+        if (append && cursorRef.current) params.set("cursor", cursorRef.current);
+        if (options.projectSlug) params.set("projectSlug", options.projectSlug);
+        if (options.limit) params.set("limit", String(options.limit));
+        if (refresh) params.set("refresh", "true");
+
+        const res = await fetch(`/api/linear/issues?${params.toString()}`);
+        const data = await res.json();
+        const newIssues: LinearIssue[] = data.issues ?? [];
+
+        setIssues((prev) => (append ? [...prev, ...newIssues] : newIssues));
+        setCursor(data.pageInfo?.endCursor ?? null);
+        setHasMore(data.pageInfo?.hasNextPage ?? false);
+        hydratedRef.current = true;
+      } catch {
+        if (!append) setIssues([]);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [filters.teamId, filters.status, filters.search, filters.assigneeId, filters.assignedToMe, filters.cycleId, enabled, options.projectSlug, options.limit],
+  );
+
+  useEffect(() => {
+    setCursor(null);
+    void fetchPage(false, !hydratedRef.current);
+  }, [fetchPage]);
+
+  const loadMore = useCallback(() => fetchPage(true), [fetchPage]);
+  const refresh = useCallback(() => {
+    setCursor(null);
+    return fetchPage(false, true);
+  }, [fetchPage]);
+
+  return { issues, loading, hasMore, loadMore, refresh };
+}

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

@@ -0,0 +1,137 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export type LinearRunStatus =
+  | "queued"
+  | "running"
+  | "success"
+  | "failed"
+  | "cancelled";
+
+export interface LinearRun {
+  id: string;
+  projectId: string | null;
+  projectSlug: string | null;
+  issueId: string;
+  issueIdentifier: string;
+  issueTitle: string;
+  issueStatus: string;
+  issueAssignee: string | null;
+  threadId: string;
+  rootMessageId: string | null;
+  chatRunId: string | null;
+  agentId: string;
+  agentName: string;
+  status: LinearRunStatus;
+  durationMs: number | null;
+  lastError: string | null;
+  startedAt: string;
+  updatedAt: string;
+  completedAt: string | null;
+}
+
+interface CreateLinearRunInput {
+  projectId?: string | null;
+  projectSlug?: string | null;
+  issueId: string;
+  issueIdentifier: string;
+  issueTitle: string;
+  issueStatus: string;
+  issueAssignee?: string | null;
+  agentId: string;
+  agentName: string;
+}
+
+interface UpdateLinearRunInput {
+  rootMessageId?: string | null;
+  chatRunId?: string | null;
+  status?: LinearRunStatus;
+  error?: string | null;
+}
+
+export function useLinearRuns(issueId?: string | null, projectId?: string | null) {
+  const [runs, setRuns] = useState<LinearRun[]>([]);
+  const [loading, setLoading] = useState(false);
+  const issueIdRef = useRef(issueId ?? null);
+  issueIdRef.current = issueId ?? null;
+
+  const refresh = useCallback(async () => {
+    const activeIssueId = issueIdRef.current?.trim();
+    if (!activeIssueId) {
+      setRuns([]);
+      return [];
+    }
+
+    setLoading(true);
+    try {
+      const params = new URLSearchParams({ issueId: activeIssueId });
+      if (projectId) params.set("projectId", projectId);
+      const response = await fetch(`/api/linear/runs?${params.toString()}`);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Linear runs: ${response.status}`);
+      }
+      const data = await response.json();
+      const nextRuns = Array.isArray(data.runs) ? (data.runs as LinearRun[]) : [];
+      setRuns(nextRuns);
+      return nextRuns;
+    } finally {
+      setLoading(false);
+    }
+  }, [projectId]);
+
+  useEffect(() => {
+    setRuns([]);
+    void refresh();
+  }, [refresh, issueId]);
+
+  useEffect(() => {
+    if (!issueId) return;
+    const intervalId = window.setInterval(() => {
+      void refresh();
+    }, 3000);
+    return () => window.clearInterval(intervalId);
+  }, [issueId, refresh]);
+
+  const createRun = useCallback(async (input: CreateLinearRunInput) => {
+    const response = await fetch("/api/linear/runs", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+    });
+    if (!response.ok) {
+      const payload = await response.json().catch(() => ({}));
+      throw new Error(payload.error || `Failed to create Linear run: ${response.status}`);
+    }
+    const data = await response.json();
+    const run = data.run as LinearRun;
+    setRuns((previous) => [run, ...previous.filter((entry) => entry.id !== run.id)]);
+    return run;
+  }, []);
+
+  const updateRun = useCallback(async (id: string, input: UpdateLinearRunInput) => {
+    const response = await fetch(`/api/linear/runs/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+    });
+    if (!response.ok) {
+      const payload = await response.json().catch(() => ({}));
+      throw new Error(payload.error || `Failed to update Linear run: ${response.status}`);
+    }
+    const data = await response.json();
+    const run = data.run as LinearRun;
+    setRuns((previous) =>
+      previous.map((entry) => (entry.id === run.id ? run : entry))
+    );
+    return run;
+  }, []);
+
+  return {
+    runs,
+    loading,
+    refresh,
+    createRun,
+    updateRun,
+  };
+}

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

@@ -25,10 +25,21 @@ export interface MentionProject {
   slug: string;
 }
 
+export interface MentionLinearIssue {
+  id: string;
+  identifier: string;
+  title: string;
+  status: string;
+  url: string | null;
+  assignee: string | null;
+  updatedAt: string;
+}
+
 export type MentionItem =
   | { kind: "agent"; participant: Participant; group: string }
   | { kind: "project-group"; project: ProjectWithAgents; group: string }
-  | { kind: "project"; project: MentionProject; group: string };
+  | { kind: "project"; project: MentionProject; group: string }
+  | { kind: "ticket"; issue: MentionLinearIssue; group: string };
 
 export type MentionSuggestion = MentionItem;
 
@@ -39,6 +50,8 @@ export interface UseMentionAutocompleteOptions {
   projectGroups?: ProjectWithAgents[];
   /** Mentionable projects */
   projects?: MentionProject[];
+  /** Cached Linear tickets available for @ mentions */
+  linearIssues?: MentionLinearIssue[];
   /** Maximum number of suggestions to show */
   maxSuggestions?: number;
 }
@@ -151,7 +164,8 @@ export function filterSuggestions(
   query: string,
   maxSuggestions: number,
   projectGroups: ProjectWithAgents[] = [],
-  projects: MentionProject[] = []
+  projects: MentionProject[] = [],
+  linearIssues: MentionLinearIssue[] = []
 ): MentionSuggestion[] {
   const lowerQuery = query.toLowerCase();
   const participantById = new Map(participants.map((p) => [p.id, p]));
@@ -216,7 +230,26 @@ export function filterSuggestions(
     }
   }
 
-  // 4. Ungrouped agents (not in any project)
+  // 4. Linear tickets (only once the user has started typing)
+  if (lowerQuery) {
+    linearIssues
+      .map((issue) => ({
+        issue,
+        score: scoreIssueMatch(issue, lowerQuery),
+      }))
+      .filter((entry): entry is { issue: MentionLinearIssue; score: number } => entry.score !== null)
+      .sort((left, right) => {
+        if (right.score !== left.score) {
+          return right.score - left.score;
+        }
+        return left.issue.identifier.localeCompare(right.issue.identifier);
+      })
+      .forEach(({ issue }) => {
+        result.push({ kind: "ticket", issue, group: "Tickets" });
+      });
+  }
+
+  // 5. Ungrouped agents (not in any project)
   const ungrouped: { participant: Participant; score: number }[] = [];
   for (const p of participants) {
     if (projectAgentIds.has(p.id)) continue;
@@ -236,6 +269,7 @@ export function useMentionAutocomplete({
   participants,
   projectGroups = [],
   projects = [],
+  linearIssues = [],
   maxSuggestions = 6,
 }: UseMentionAutocompleteOptions): UseMentionAutocompleteReturn {
   const [token, setToken] = useState<MentionToken | null>(null);
@@ -246,8 +280,8 @@ export function useMentionAutocomplete({
   const query = token?.query ?? "";
 
   const filteredSuggestions = useMemo(() => {
-    return filterSuggestions(participants, query, maxSuggestions, projectGroups, projects);
-  }, [participants, query, maxSuggestions, projectGroups, projects]);
+    return filterSuggestions(participants, query, maxSuggestions, projectGroups, projects, linearIssues);
+  }, [participants, query, maxSuggestions, projectGroups, projects, linearIssues]);
 
   const updateTokenFromInput = useCallback((text: string, cursorPos: number) => {
     const newToken = detectMentionToken(text, cursorPos);
@@ -320,7 +354,9 @@ export function useMentionAutocomplete({
           ? suggestion.project.name
           : suggestion.kind === "project"
             ? suggestion.project.name
-            : suggestion.participant.name;
+            : suggestion.kind === "ticket"
+              ? suggestion.issue.identifier
+              : suggestion.participant.name;
       const atPrefix = token.isParallel ? "@@" : "@";
       const replacement = `${atPrefix}${name} `;
 
@@ -362,3 +398,15 @@ export function useMentionAutocomplete({
     endComposition,
   };
 }
+
+function scoreIssueMatch(issue: MentionLinearIssue, lowerQuery: string): number | null {
+  const identifier = issue.identifier.toLowerCase();
+  const title = issue.title.toLowerCase();
+
+  if (identifier === lowerQuery) return 5;
+  if (identifier.startsWith(lowerQuery)) return 4;
+  if (title.startsWith(lowerQuery)) return 3;
+  if (identifier.includes(lowerQuery)) return 2;
+  if (title.includes(lowerQuery)) return 1;
+  return null;
+}

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

@@ -97,53 +97,3 @@ export function useProjectVariables(projectId: string | null) {
 
   return { variables, isLoading, setVariable, deleteVariable, refresh: fetchVariables };
 }
-
-// ── Project Memory ──────────────────────────────────────────────────────────
-
-export interface ProjectMemoryEntry {
-  id: string;
-  project_id: string;
-  content: string;
-  source?: string;
-  producer?: "human" | "system";
-  created_at: string;
-}
-
-export function useProjectMemory(projectId: string | null) {
-  const [memory, setMemory] = useState<ProjectMemoryEntry[]>([]);
-  const [isLoading, setIsLoading] = useState(true);
-
-  const fetchMemory = useCallback(async () => {
-    if (!projectId) { setMemory([]); setIsLoading(false); return; }
-    try {
-      const res = await fetch(`/api/projects/${projectId}/memory?producer=human`);
-      if (!res.ok) return;
-      const data = await res.json();
-      setMemory(data.memory ?? []);
-    } catch { /* silent */ } finally { setIsLoading(false); }
-  }, [projectId]);
-
-  useEffect(() => { void fetchMemory(); }, [fetchMemory]);
-
-  const addMemory = useCallback(async (content: string, source?: string) => {
-    if (!projectId) return;
-    try {
-      const res = await fetch(`/api/projects/${projectId}/memory`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ content, source, producer: "human" }),
-      });
-      if (res.ok) await fetchMemory();
-    } catch { /* silent */ }
-  }, [projectId, fetchMemory]);
-
-  const deleteMemory = useCallback(async (memoryId: string) => {
-    if (!projectId) return;
-    try {
-      const res = await fetch(`/api/projects/${projectId}/memory?memoryId=${memoryId}`, { method: "DELETE" });
-      if (res.ok) setMemory((prev) => prev.filter((m) => m.id !== memoryId));
-    } catch { /* silent */ }
-  }, [projectId]);
-
-  return { memory, isLoading, addMemory, deleteMemory, refresh: fetchMemory };
-}

package/cloud-runtime/standalone/instrumentation.ts

@@ -3,6 +3,7 @@ const PROMPT_JOB_POLL_INTERVAL_MS = 15_000;
 
 export async function register() {
   if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { getConfiguredLocalServerPort } = await import("./lib/app-config");
     await import("./lib/check-node-version");
     const { getQueue, QUEUE_NAMES } = await import('@/lib/queue/boss');
     const { taskProcessor } = await import('@/lib/orchestrator/processor');
@@ -22,7 +23,7 @@ export async function register() {
     const { GraphStore } = await import('@/src/graph/store');
 
     // Prompt job poller — drives recurring prompt-based scheduled tasks
-    const port = process.env.PORT || '3000';
+    const port = getConfiguredLocalServerPort();
     const baseUrl = `http://localhost:${port}`;
     let promptJobPollReady = false;
 

package/cloud-runtime/standalone/lib/app-config.ts

@@ -0,0 +1,55 @@
+const DEFAULT_LOCAL_APP_PORT = 41741;
+
+function normalizeBaseUrl(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  return trimmed.replace(/\/+$/, "");
+}
+
+export const LOCAL_APP_PORT = DEFAULT_LOCAL_APP_PORT;
+export const LOCAL_APP_URL = `http://localhost:${LOCAL_APP_PORT}`;
+
+export function getConfiguredAppBaseUrl(): string {
+  return (
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_APP_URL) ??
+    normalizeBaseUrl(process.env.AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_AGX_BOARD_URL) ??
+    LOCAL_APP_URL
+  );
+}
+
+export function getConfiguredBoardBaseUrl(): string {
+  return (
+    normalizeBaseUrl(process.env.AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_AGX_BOARD_URL) ??
+    normalizeBaseUrl(process.env.NEXT_PUBLIC_APP_URL) ??
+    LOCAL_APP_URL
+  );
+}
+
+export function getConfiguredLocalServerPort(): string {
+  return process.env.PORT?.trim() || String(LOCAL_APP_PORT);
+}
+
+export function getAllowedOrigins(): string[] {
+  const origins = new Set<string>([
+    LOCAL_APP_URL,
+    `http://127.0.0.1:${LOCAL_APP_PORT}`,
+  ]);
+
+  for (const value of [
+    process.env.NEXT_PUBLIC_APP_URL,
+    process.env.AGX_BOARD_URL,
+    process.env.NEXT_PUBLIC_AGX_BOARD_URL,
+  ]) {
+    const normalized = normalizeBaseUrl(value);
+    if (normalized) {
+      origins.add(normalized);
+    }
+  }
+
+  return Array.from(origins);
+}