mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-22 11:54:35 +01:00
## Thinking Path
> - Paperclip is the open source app people use to manage AI agents for
work
> - The board UI reads the company project list in many places: the
sidebar, starred projects, the command palette, the new-task dialog, and
archive-aware pages such as the Mine inbox
> - Active-only consumers read `GET /projects`, and archive-aware ones
read `GET /projects?includeArchived=true`, under two React Query keys
> - A Mine load therefore fetched the same large payload twice (580–590
KB each on our dev instance)
> - The two responses differ only by archived rows; the server's active
list is exactly the rows where `archivedAt` is null
> - This pull request makes every consumer share the
`includeArchived=true` query, and active-only consumers filter it with
`select`
> - The benefit is one project read per page instead of two
## Linked Issues or Issue Description
**What existing behavior does this improve?**
Duplicate project list reads on page load.
**Subsystem affected**
Board UI project queries (`ui/src/lib/company-projects-query.ts` and its
consumers).
**Current behavior**
A cold Mine load sends both `/companies/:id/projects` (sidebar) and
`/companies/:id/projects?includeArchived=true` (inbox).
**Proposed behavior**
One `includeArchived=true` read serves both. Active-only consumers apply
`selectActiveProjects`.
**Reason and benefit**
The project list is one of the largest shell payloads. Reading it once
saves a large response on every page that has both kinds of consumer.
## What Changed
- New `companyProjectsQuery(companyId, { includeArchived? })` in
`ui/src/lib/company-projects-query.ts`. It always uses the
`includeArchived: true` key and fetch. For active-only use it adds a
stable, module-level `select` that keeps rows without `archivedAt`.
- 22 files that read the active list now spread
`companyProjectsQuery(...)`, and so do the plugin SDK project picker and
16 archive-aware pages that wrote the shared key and fetcher inline.
Their `enabled` and other options are unchanged. `OnboardingWizard`'s
one imperative read is unchanged. `pages/Inbox.tsx` already reads the
same key and fetcher, so it shares the entry without an edit.
- Invalidation: project mutations and live events invalidate
`queryKeys.projects.all(companyId)`, which matches the shared key. The
onboarding wizard invalidated the old active-only key; it now
invalidates `projects.all`.
- Tests: new `company-projects-query.test.tsx` (one request for both
consumers, correct filtering, and one refetch after `projects.all`
invalidation). Three existing tests (`CommandPalette`, `CompanyExport`,
`GitHubBotManagement`) now seed or expect the shared key.
- New browser check
`tests/perf/collections/shared-project-list.spec.ts`: after the Mine
inbox read completes, the page has sent no active-only project request.
## Verification
- `pnpm verify` passes.
- `ui`: the consumer suites (`CoordinatorSidebar`, `SidebarProjects`,
`SidebarStarredProjects`, `CommandPalette`, `NewIssueDialog`,
`AgentWorkPanels`, `CoordinatorNeedsYou`, `IssueDetail`,
`ProjectDetail`, `Projects`, `CompanyExport`, `ChatExecutionDefaults`,
`GatewaysList`, `Search`, `IssueProperties`, `persisted-query-cache`)
pass.
- Browser check:
`PAPERCLIP_COLLECTION_PERF_BASE_URL=http://127.0.0.1:<port> pnpm exec
playwright test --config tests/perf/collections/playwright.config.ts
shared-project-list.spec.ts`. It passes on this branch and fails on
`master`.
## Risks
- A page that needs only active projects now downloads archived rows
too. For most companies that is a small difference; the duplicate read
it removes is a full copy.
- The server does not order either list, and consumers sort for display,
so filtering on the client keeps behavior.
## Model Used
- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, via Claude Code with
tool use (shell, file edits, browser). 1M-token context window. Extended
thinking was off.
## Checklist
- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
3442 lines
139 KiB
TypeScript
3442 lines
139 KiB
TypeScript
import { companyProjectsQuery } from "@/lib/company-projects-query";
|
||
import { describeError } from "../api/errors";
|
||
import { useSelectedHeartbeatRun } from "../hooks/useSelectedHeartbeatRun";
|
||
import { AgentCharacter } from "../components/AgentCharacter";
|
||
import { characterStateForAgent } from "@paperclipai/shared";
|
||
import { useCallback, useEffect, useMemo, useState, useRef } from "react";
|
||
import { useParams, useNavigate, useLocation, Link, Navigate, useBeforeUnload, type NavigateFunction } from "@/lib/router";
|
||
import { useQuery, useMutation, useQueryClient, type QueryClient } from "@tanstack/react-query";
|
||
import {
|
||
agentsApi,
|
||
type AgentKey,
|
||
type ClaudeLoginResult,
|
||
type AgentPermissionUpdate,
|
||
} from "../api/agents";
|
||
import { builtInAgentsApi, type BuiltInManagedResourceKind } from "../api/builtInAgents";
|
||
import { companySkillsApi } from "../api/companySkills";
|
||
import { budgetsApi } from "../api/budgets";
|
||
import { heartbeatsApi } from "../api/heartbeats";
|
||
import { runCancellationLabel } from "../lib/run-cancellation-label";
|
||
import { stopFailedNativeRun } from "../lib/native-run-stop";
|
||
import { instanceSettingsApi } from "../api/instanceSettings";
|
||
import { ApiError } from "../api/client";
|
||
import { ChartCard, RunActivityChart, PriorityChart, IssueStatusChart, SuccessRateChart } from "../components/ActivityCharts";
|
||
import { SHOW_TASK_PRIORITY_UI } from "../lib/ui-flags";
|
||
import { activityApi } from "../api/activity";
|
||
import { accessApi } from "../api/access";
|
||
import { issuesApi } from "../api/issues";
|
||
import { usePanel } from "../context/PanelContext";
|
||
import { useSidebar } from "../context/SidebarContext";
|
||
import { useCompany } from "../context/CompanyContext";
|
||
import { useToastActions } from "../context/ToastContext";
|
||
import { useBreadcrumbs } from "../context/BreadcrumbContext";
|
||
import { queryKeys } from "../lib/queryKeys";
|
||
import { copyTextToClipboard } from "../lib/clipboard";
|
||
import { AgentSkillsTab } from "./agent-skills/AgentSkillsTab";
|
||
import { AgentConfigForm } from "../components/AgentConfigForm";
|
||
import { PageTabBar } from "../components/PageTabBar";
|
||
import { adapterLabels, roleLabels, help } from "../components/agent-config-primitives";
|
||
import { ToggleSwitch } from "@/components/ui/toggle-switch";
|
||
import { useAdapterCapabilities } from "@/adapters/use-adapter-capabilities";
|
||
import { MarkdownEditor } from "../components/MarkdownEditor";
|
||
import { assetsApi } from "../api/assets";
|
||
import { StatusBadge } from "../components/StatusBadge";
|
||
import { MarkdownBody } from "../components/MarkdownBody";
|
||
import { CopyText } from "../components/CopyText";
|
||
import { EntityRow } from "../components/EntityRow";
|
||
import { StatusGlyph } from "../components/StatusGlyph";
|
||
import { MembershipAction } from "../components/MembershipAction";
|
||
import { StarToggle } from "../components/StarToggle";
|
||
import { Identity } from "../components/Identity";
|
||
import { AuditFeed } from "./audit/AuditFeed.production";
|
||
import { PageSkeleton } from "../components/PageSkeleton";
|
||
import { QueryErrorState, useQueryView } from "../components/QueryView";
|
||
import { AgentActionButtons } from "../components/AgentActionButtons";
|
||
import { InlineBanner } from "../components/InlineBanner";
|
||
import { BuiltInBundlePanel } from "../components/BuiltInBundlePanel";
|
||
import { ConfigureBuiltInAgentModal } from "../components/ConfigureBuiltInAgentModal";
|
||
import { BudgetPolicyCard } from "../components/BudgetPolicyCard";
|
||
import { TrustPresetSection } from "../components/TrustPresetSection";
|
||
import { AgentProjectAccessSettings } from "../components/AgentProjectAccessSettings";
|
||
import { FileTree, buildFileTree } from "../components/FileTree";
|
||
import { ScrollToBottom } from "../components/ScrollToBottom";
|
||
import { SourceResolvedFoldCallout } from "../components/SourceResolvedFoldCallout";
|
||
import { SourceResolvedFoldBadge } from "../components/SourceResolvedFoldBadge";
|
||
import { readSourceResolvedWatchdogFold } from "../lib/source-resolved-watchdog-fold";
|
||
import { formatCents, formatDate, relativeTime, formatTokens, visibleRunCostUsd, visibleRunTokenTotal } from "../lib/utils";
|
||
import { cn } from "../lib/utils";
|
||
import { describeRunRetryState } from "../lib/runRetryState";
|
||
import { Button } from "@/components/ui/button";
|
||
import { Skeleton } from "@/components/ui/skeleton";
|
||
import { Tabs } from "@/components/ui/tabs";
|
||
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
|
||
import {
|
||
CheckCircle2,
|
||
XCircle,
|
||
Clock,
|
||
Timer,
|
||
Loader2,
|
||
Slash,
|
||
RotateCcw,
|
||
Plus,
|
||
Key,
|
||
Eye,
|
||
EyeOff,
|
||
Copy,
|
||
ChevronRight,
|
||
ChevronDown,
|
||
ArrowLeft,
|
||
HelpCircle,
|
||
FolderOpen,
|
||
AlertTriangle,
|
||
} from "lucide-react";
|
||
import { Collapsible, CollapsibleTrigger, CollapsibleContent } from "@/components/ui/collapsible";
|
||
import { TooltipProvider } from "@/components/ui/tooltip";
|
||
import { Input } from "@/components/ui/input";
|
||
import { AgentToolsTab } from "./AgentToolsTab";
|
||
import { AgentChannelsPanel } from "../components/chat/AgentChannelsPanel";
|
||
import { useChatConnectorsEnabled } from "@/hooks/useChatConnectorsEnabled";
|
||
import {
|
||
isUuidLike,
|
||
type Agent,
|
||
type AgentDetail as AgentDetailRecord,
|
||
type BudgetPolicySummary,
|
||
type HeartbeatRun,
|
||
type AgentRuntimeState,
|
||
type LiveEvent,
|
||
isResponsibleUserDenialCode,
|
||
responsibleUserLabel,
|
||
} from "@paperclipai/shared";
|
||
import { ResponsibleUserDenialNotice } from "../components/ResponsibleUserDenialNotice";
|
||
import { RunWorkspaceRecoverySurface } from "../components/RunWorkspaceRecoverySurface";
|
||
import { buildPermissionsForTrustPreset, getTrustPreset } from "../lib/trust-policy-ui";
|
||
import { agentRouteRef } from "../lib/utils";
|
||
import {
|
||
isStarred,
|
||
resourceMembershipState,
|
||
useResourceMembershipMutation,
|
||
useResourceMemberships,
|
||
} from "../hooks/useResourceMemberships";
|
||
import { Badge } from "@/components/ui/badge";
|
||
import { LogViewer } from "../components/run-log/LogViewer";
|
||
import { asRecord, asNonEmptyString } from "../components/run-log/RunDetails";
|
||
|
||
export { LogViewer } from "../components/run-log/LogViewer";
|
||
export {
|
||
type RunLogChunk,
|
||
shouldPollRunShellLog,
|
||
buildHeartbeatProgressLogLine,
|
||
heartbeatProgressLogLineKey,
|
||
RunInvocationCard,
|
||
} from "../components/run-log/RunDetails";
|
||
|
||
const runStatusIcons: Record<string, { icon: typeof CheckCircle2; color: string }> = {
|
||
succeeded: { icon: CheckCircle2, color: "text-green-600 dark:text-green-400" },
|
||
failed: { icon: XCircle, color: "text-red-600 dark:text-red-400" },
|
||
running: { icon: Loader2, color: "text-blue-600 dark:text-blue-400" }, // Gallery feedback r1: running = status blue, not cyan.
|
||
queued: { icon: Clock, color: "text-yellow-600 dark:text-yellow-400" },
|
||
scheduled_retry: { icon: Clock, color: "text-sky-600 dark:text-sky-400" },
|
||
timed_out: { icon: Timer, color: "text-orange-600 dark:text-orange-400" },
|
||
cancelled: { icon: Slash, color: "text-neutral-500 dark:text-neutral-400" },
|
||
};
|
||
|
||
function formatOrgChainHealthPath(agent: AgentDetailRecord) {
|
||
return agent.orgChainHealth?.fullChain
|
||
.map((entry) => `${entry.name}${entry.status !== "active" && entry.status !== "idle" ? ` (${entry.status})` : ""}`)
|
||
.join(" -> ") ?? agent.name;
|
||
}
|
||
|
||
function isMarkdown(pathValue: string) {
|
||
return pathValue.toLowerCase().endsWith(".md");
|
||
}
|
||
|
||
function shouldUseMarkdownInstructionsEditor(input: {
|
||
selectedFileExists: boolean;
|
||
selectedPath: string;
|
||
detail?: { markdown?: boolean } | null;
|
||
summary?: { markdown?: boolean } | null;
|
||
}) {
|
||
const metadataMarkdown = input.detail?.markdown ?? input.summary?.markdown;
|
||
if (typeof metadataMarkdown === "boolean") return metadataMarkdown;
|
||
return isMarkdown(input.selectedPath);
|
||
}
|
||
|
||
const sourceLabels: Record<string, string> = {
|
||
timer: "Timer",
|
||
assignment: "Assignment",
|
||
on_demand: "On-demand",
|
||
automation: "Automation",
|
||
};
|
||
|
||
type AgentDetailView = "dashboard" | "instructions" | "configuration" | "secrets" | "skills" | "tools" | "channels" | "runs" | "audit" | "budget";
|
||
|
||
export const AGENT_DETAIL_TABS: ReadonlyArray<{ value: AgentDetailView; label: string }> = [
|
||
{ value: "dashboard", label: "Dashboard" },
|
||
{ value: "instructions", label: "Instructions" },
|
||
{ value: "skills", label: "Skills" },
|
||
{ value: "configuration", label: "Configuration" },
|
||
{ value: "secrets", label: "Secrets" },
|
||
{ value: "tools", label: "Tools" },
|
||
{ value: "channels", label: "Channels" },
|
||
{ value: "runs", label: "Runs" },
|
||
{ value: "audit", label: "Audit" },
|
||
{ value: "budget", label: "Budget" },
|
||
];
|
||
|
||
export const DISCARD_AGENT_CONFIG_CHANGES_MESSAGE = "Discard unsaved agent configuration changes?";
|
||
|
||
export function confirmAgentConfigNavigation(
|
||
dirty: boolean,
|
||
confirm: (message: string) => boolean = (message) =>
|
||
typeof window === "undefined" || window.confirm(message),
|
||
): boolean {
|
||
return !dirty || confirm(DISCARD_AGENT_CONFIG_CHANGES_MESSAGE);
|
||
}
|
||
|
||
export function agentConfigHistoryRestoreDelta(currentIndex: unknown, nextIndex: unknown): number | null {
|
||
if (typeof currentIndex !== "number" || typeof nextIndex !== "number") return null;
|
||
const delta = currentIndex - nextIndex;
|
||
return delta === 0 ? null : delta;
|
||
}
|
||
|
||
export function restoreAgentConfigHistoryEntry(
|
||
history: Pick<History, "go" | "pushState">,
|
||
currentEntry: { index: unknown; state: unknown; url: string },
|
||
nextIndex: unknown,
|
||
): boolean {
|
||
const restoreDelta = agentConfigHistoryRestoreDelta(currentEntry.index, nextIndex);
|
||
if (restoreDelta === null) {
|
||
// Some legacy URL-cleanup paths erased React Router's history index. A
|
||
// fresh copy of the guarded entry is the only safe way to return without
|
||
// letting Router consume the unindexed destination and discard the form.
|
||
history.pushState(currentEntry.state, "", currentEntry.url);
|
||
return false;
|
||
}
|
||
|
||
history.go(restoreDelta);
|
||
return true;
|
||
}
|
||
|
||
export function parseAgentDetailView(value: string | null): AgentDetailView {
|
||
if (value === "instructions" || value === "prompts") return "instructions";
|
||
if (value === "configure" || value === "configuration") return "configuration";
|
||
if (value === "secrets") return "secrets";
|
||
if (value === "skills") return "skills";
|
||
if (value === "tools") return "tools";
|
||
if (value === "channels") return "channels";
|
||
if (value === "budget") return "budget";
|
||
if (value === "audit") return "audit";
|
||
if (value === "runs") return value;
|
||
return "dashboard";
|
||
}
|
||
|
||
function usageNumber(usage: Record<string, unknown> | null, ...keys: string[]) {
|
||
if (!usage) return 0;
|
||
for (const key of keys) {
|
||
const value = usage[key];
|
||
if (typeof value === "number" && Number.isFinite(value)) return value;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
function setsEqual<T>(left: Set<T>, right: Set<T>) {
|
||
if (left.size !== right.size) return false;
|
||
for (const value of left) {
|
||
if (!right.has(value)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function runMetrics(run: HeartbeatRun) {
|
||
const usage = (run.usageJson ?? null) as Record<string, unknown> | null;
|
||
const result = (run.resultJson ?? null) as Record<string, unknown> | null;
|
||
const input = usageNumber(usage, "inputTokens", "input_tokens");
|
||
const output = usageNumber(usage, "outputTokens", "output_tokens");
|
||
const cached = usageNumber(
|
||
usage,
|
||
"cachedInputTokens",
|
||
"cached_input_tokens",
|
||
"cache_read_input_tokens",
|
||
);
|
||
const cost =
|
||
visibleRunCostUsd(usage, result);
|
||
const provider = asNonEmptyString(usage?.provider) ?? null;
|
||
const model = asNonEmptyString(usage?.model) ?? null;
|
||
return {
|
||
input,
|
||
output,
|
||
cached,
|
||
cost,
|
||
totalTokens: visibleRunTokenTotal(usage),
|
||
provider,
|
||
model,
|
||
};
|
||
}
|
||
|
||
export function runDetailRefetchIntervalMs(status: HeartbeatRun["status"]): 5000 | 15000 | false {
|
||
if (status === "queued") return 5000;
|
||
if (status === "running") return 15000;
|
||
return false;
|
||
}
|
||
|
||
export function AgentDetail() {
|
||
const { companyPrefix, agentId, tab: urlTab, runId: urlRunId } = useParams<{
|
||
companyPrefix?: string;
|
||
agentId: string;
|
||
tab?: string;
|
||
runId?: string;
|
||
}>();
|
||
const { companies, selectedCompanyId, setSelectedCompanyId } = useCompany();
|
||
const { closePanel } = usePanel();
|
||
const { setBreadcrumbs } = useBreadcrumbs();
|
||
const queryClient = useQueryClient();
|
||
const navigate = useNavigate();
|
||
const location = useLocation();
|
||
const [actionError, setActionError] = useState<string | null>(null);
|
||
const [dismissedLeftAgentIds, setDismissedLeftAgentIds] = useState<Set<string>>(() => new Set());
|
||
const { enabled: chatEnabled, githubEnabled, loaded: chatConnectorsLoaded } = useChatConnectorsEnabled();
|
||
const chatConnectorsEnabled = chatEnabled || githubEnabled;
|
||
const activeView = urlRunId ? "runs" as AgentDetailView
|
||
: urlTab === "channels" && !chatConnectorsEnabled ? "dashboard" : parseAgentDetailView(urlTab ?? null);
|
||
const needsDashboardData = activeView === "dashboard";
|
||
const needsRunData = activeView === "runs" || Boolean(urlRunId);
|
||
const shouldLoadHeartbeats = needsDashboardData || needsRunData;
|
||
const [configDirty, setConfigDirty] = useState(false);
|
||
const [configSaving, setConfigSaving] = useState(false);
|
||
const saveConfigActionRef = useRef<(() => void) | null>(null);
|
||
const cancelConfigActionRef = useRef<(() => void) | null>(null);
|
||
const { isMobile } = useSidebar();
|
||
const routeAgentRef = agentId ?? "";
|
||
const routeCompanyId = useMemo(() => {
|
||
if (!companyPrefix) return null;
|
||
const requestedPrefix = companyPrefix.toUpperCase();
|
||
return companies.find((company) => company.issuePrefix.toUpperCase() === requestedPrefix)?.id ?? null;
|
||
}, [companies, companyPrefix]);
|
||
const lookupCompanyId = routeCompanyId ?? selectedCompanyId ?? undefined;
|
||
const canFetchAgent = routeAgentRef.length > 0 && (isUuidLike(routeAgentRef) || Boolean(lookupCompanyId));
|
||
const setSaveConfigAction = useCallback((fn: (() => void) | null) => { saveConfigActionRef.current = fn; }, []);
|
||
const setCancelConfigAction = useCallback((fn: (() => void) | null) => { cancelConfigActionRef.current = fn; }, []);
|
||
const prepareAgentNavigation = useCallback(() => {
|
||
return confirmAgentConfigNavigation(configDirty);
|
||
}, [configDirty]);
|
||
|
||
const agentQuery = useQuery<AgentDetailRecord>({
|
||
queryKey: [...queryKeys.agents.detail(routeAgentRef), lookupCompanyId ?? null],
|
||
queryFn: () => agentsApi.get(routeAgentRef, lookupCompanyId),
|
||
enabled: canFetchAgent,
|
||
});
|
||
const { data: agent, isLoading, error } = agentQuery;
|
||
const agentView = useQueryView(agentQuery);
|
||
const resolvedCompanyId = agent?.companyId ?? selectedCompanyId;
|
||
const canonicalAgentRef = agent ? agentRouteRef(agent) : routeAgentRef;
|
||
const agentLookupRef = agent?.id ?? routeAgentRef;
|
||
const resolvedAgentId = agent?.id ?? null;
|
||
const membershipsQuery = useResourceMemberships(resolvedCompanyId);
|
||
const membershipMutation = useResourceMembershipMutation(resolvedCompanyId);
|
||
const agentMembershipState = resolvedAgentId
|
||
? resourceMembershipState(membershipsQuery.data, "agent", resolvedAgentId)
|
||
: "joined";
|
||
|
||
const { data: experimentalSettings } = useQuery({
|
||
queryKey: queryKeys.instance.experimentalSettings,
|
||
queryFn: () => instanceSettingsApi.getExperimental(),
|
||
enabled: !!resolvedCompanyId,
|
||
});
|
||
const builtInAgentsEnabled = experimentalSettings?.enableBuiltInAgents === true;
|
||
const { data: builtInStates } = useQuery({
|
||
queryKey: queryKeys.builtInAgents.list(resolvedCompanyId!),
|
||
queryFn: () => builtInAgentsApi.list(resolvedCompanyId!),
|
||
enabled: !!resolvedCompanyId && builtInAgentsEnabled,
|
||
});
|
||
const builtInState = builtInAgentsEnabled
|
||
? builtInStates?.find((entry) => entry.agentId === resolvedAgentId) ?? null
|
||
: null;
|
||
const builtInFeatureLabel = builtInState
|
||
? builtInState.definition.featureKeys
|
||
.map((key) => key.charAt(0).toUpperCase() + key.slice(1))
|
||
.join(", ")
|
||
: "";
|
||
const invalidateBuiltIn = useCallback(() => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.builtInAgents.list(resolvedCompanyId!) });
|
||
if (resolvedAgentId) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(resolvedAgentId) });
|
||
}
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(routeAgentRef) });
|
||
}, [queryClient, resolvedCompanyId, resolvedAgentId, routeAgentRef]);
|
||
|
||
const resetBuiltIn = useMutation({
|
||
mutationFn: () => builtInAgentsApi.reset(resolvedCompanyId!, builtInState!.definition.key),
|
||
onSuccess: invalidateBuiltIn,
|
||
});
|
||
|
||
const [showBuiltInConfigure, setShowBuiltInConfigure] = useState(false);
|
||
const resetBuiltInResource = useMutation({
|
||
mutationFn: (kind: BuiltInManagedResourceKind) =>
|
||
builtInAgentsApi.reset(resolvedCompanyId!, builtInState!.definition.key, [kind]),
|
||
onSuccess: invalidateBuiltIn,
|
||
onError: (error) => {
|
||
setActionError(error instanceof Error ? error.message : "Failed to update bundle resource");
|
||
},
|
||
});
|
||
const runBuiltInRoutine = useMutation({
|
||
mutationFn: (routineKey: string) =>
|
||
builtInAgentsApi.runRoutine(resolvedCompanyId!, builtInState!.definition.key, routineKey),
|
||
onSuccess: invalidateBuiltIn,
|
||
onError: (error) => {
|
||
setActionError(error instanceof Error ? error.message : "Failed to run built-in routine");
|
||
},
|
||
});
|
||
const enableBuiltInSchedule = useMutation({
|
||
mutationFn: (routineKey: string) =>
|
||
builtInAgentsApi.enableRoutineSchedule(resolvedCompanyId!, builtInState!.definition.key, routineKey),
|
||
onSuccess: invalidateBuiltIn,
|
||
onError: (error) => {
|
||
setActionError(error instanceof Error ? error.message : "Failed to enable routine schedule");
|
||
},
|
||
});
|
||
const disableBuiltInSchedule = useMutation({
|
||
mutationFn: (routineKey: string) =>
|
||
builtInAgentsApi.disableRoutineSchedule(resolvedCompanyId!, builtInState!.definition.key, routineKey),
|
||
onSuccess: invalidateBuiltIn,
|
||
onError: (error) => {
|
||
setActionError(error instanceof Error ? error.message : "Failed to disable routine schedule");
|
||
},
|
||
});
|
||
const builtInRoutineActionPending =
|
||
runBuiltInRoutine.isPending
|
||
? "run"
|
||
: enableBuiltInSchedule.isPending
|
||
? "enable"
|
||
: disableBuiltInSchedule.isPending
|
||
? "disable"
|
||
: null;
|
||
|
||
const { data: runtimeState } = useQuery({
|
||
queryKey: queryKeys.agents.runtimeState(resolvedAgentId ?? routeAgentRef),
|
||
queryFn: () => agentsApi.runtimeState(resolvedAgentId!, resolvedCompanyId ?? undefined),
|
||
enabled: Boolean(resolvedAgentId) && needsDashboardData,
|
||
});
|
||
|
||
const { data: heartbeats } = useQuery({
|
||
queryKey: queryKeys.heartbeats(resolvedCompanyId!, agent?.id ?? undefined),
|
||
queryFn: () => heartbeatsApi.list(resolvedCompanyId!, agent?.id ?? undefined),
|
||
enabled: !!resolvedCompanyId && !!agent?.id && shouldLoadHeartbeats,
|
||
});
|
||
|
||
const { data: allIssues } = useQuery({
|
||
queryKey: [...queryKeys.issues.list(resolvedCompanyId!), "participant-agent", resolvedAgentId ?? "__none__"],
|
||
queryFn: () => issuesApi.list(resolvedCompanyId!, { participantAgentId: resolvedAgentId! }),
|
||
enabled: !!resolvedCompanyId && !!resolvedAgentId && needsDashboardData,
|
||
});
|
||
|
||
const { data: allAgents } = useQuery({
|
||
queryKey: queryKeys.agents.list(resolvedCompanyId!),
|
||
queryFn: () => agentsApi.list(resolvedCompanyId!),
|
||
enabled: !!resolvedCompanyId && needsDashboardData,
|
||
});
|
||
|
||
const { data: budgetOverview } = useQuery({
|
||
queryKey: queryKeys.budgets.overview(resolvedCompanyId ?? "__none__"),
|
||
queryFn: () => budgetsApi.overview(resolvedCompanyId!),
|
||
enabled: !!resolvedCompanyId,
|
||
refetchInterval: 30_000,
|
||
staleTime: 5_000,
|
||
});
|
||
|
||
const assignedIssues = (allIssues ?? [])
|
||
.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
|
||
const reportsToAgent = (allAgents ?? []).find((a) => a.id === agent?.reportsTo);
|
||
const directReports = (allAgents ?? []).filter((a) => a.reportsTo === agent?.id && a.status !== "terminated");
|
||
const agentBudgetSummary = useMemo(() => {
|
||
const matched = budgetOverview?.policies.find(
|
||
(policy) => policy.scopeType === "agent" && policy.scopeId === (agent?.id ?? routeAgentRef),
|
||
);
|
||
if (matched) return matched;
|
||
const budgetMonthlyCents = agent?.budgetMonthlyCents ?? 0;
|
||
const spentMonthlyCents = agent?.spentMonthlyCents ?? 0;
|
||
return {
|
||
policyId: "",
|
||
companyId: resolvedCompanyId ?? "",
|
||
scopeType: "agent",
|
||
scopeId: agent?.id ?? routeAgentRef,
|
||
scopeName: agent?.name ?? "Agent",
|
||
metric: "billed_cents",
|
||
windowKind: "calendar_month_utc",
|
||
amount: budgetMonthlyCents,
|
||
unpricedEventCount: 0, pendingRunCount: 0,
|
||
unpricedUsagePolicy: "block",
|
||
observedAmount: spentMonthlyCents,
|
||
remainingAmount: Math.max(0, budgetMonthlyCents - spentMonthlyCents),
|
||
utilizationPercent:
|
||
budgetMonthlyCents > 0 ? Number(((spentMonthlyCents / budgetMonthlyCents) * 100).toFixed(2)) : 0,
|
||
warnPercent: 80,
|
||
hardStopEnabled: true,
|
||
notifyEnabled: true,
|
||
isActive: budgetMonthlyCents > 0,
|
||
status: budgetMonthlyCents > 0 && spentMonthlyCents >= budgetMonthlyCents ? "hard_stop" : "ok",
|
||
paused: agent?.status === "paused",
|
||
pauseReason: agent?.pauseReason ?? null,
|
||
windowStart: new Date(),
|
||
windowEnd: new Date(),
|
||
} satisfies BudgetPolicySummary;
|
||
}, [agent, budgetOverview?.policies, resolvedCompanyId, routeAgentRef]);
|
||
const mobileLiveRun = useMemo(
|
||
() => (heartbeats ?? []).find((r) => r.status === "running" || r.status === "queued") ?? null,
|
||
[heartbeats],
|
||
);
|
||
|
||
useEffect(() => {
|
||
if (!agent) return;
|
||
if (!urlRunId && urlTab === "channels" && !chatConnectorsLoaded) return;
|
||
if (urlRunId) {
|
||
if (routeAgentRef !== canonicalAgentRef) {
|
||
navigate(`/agents/${canonicalAgentRef}/runs/${urlRunId}`, { replace: true });
|
||
}
|
||
return;
|
||
}
|
||
const canonicalTab =
|
||
activeView === "instructions"
|
||
? "instructions"
|
||
: activeView === "configuration"
|
||
? "configuration"
|
||
: activeView === "secrets"
|
||
? "secrets"
|
||
: activeView === "skills"
|
||
? "skills"
|
||
: activeView === "tools" || activeView === "channels"
|
||
? activeView
|
||
: activeView === "runs"
|
||
? "runs"
|
||
: activeView === "audit"
|
||
? "audit"
|
||
: activeView === "budget"
|
||
? "budget"
|
||
: "dashboard";
|
||
if (routeAgentRef !== canonicalAgentRef || urlTab !== canonicalTab) {
|
||
navigate(`/agents/${canonicalAgentRef}/${canonicalTab}${location.search}`, { replace: true });
|
||
return;
|
||
}
|
||
}, [agent, routeAgentRef, canonicalAgentRef, urlRunId, urlTab, activeView, navigate, chatConnectorsLoaded, location.search]);
|
||
|
||
useEffect(() => {
|
||
if (!agent?.companyId || agent.companyId === selectedCompanyId) return;
|
||
setSelectedCompanyId(agent.companyId, { source: "route_sync" });
|
||
}, [agent?.companyId, selectedCompanyId, setSelectedCompanyId]);
|
||
|
||
// Invoke / pause / resume / terminate / duplicate / reset live in the shared
|
||
// AgentActionButtons component. The detail header keeps only "approve" here,
|
||
// which is surfaced via the pending-approval banner below.
|
||
const agentAction = useMutation({
|
||
mutationFn: async (action: "approve") => {
|
||
if (!agentLookupRef) return Promise.reject(new Error("No agent reference"));
|
||
if (action === "approve") {
|
||
return agentsApi.approve(agentLookupRef, resolvedCompanyId ?? undefined);
|
||
}
|
||
},
|
||
onSuccess: () => {
|
||
setActionError(null);
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(routeAgentRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agentLookupRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.runtimeState(agentLookupRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.taskSessions(agentLookupRef) });
|
||
if (resolvedCompanyId) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(resolvedCompanyId) });
|
||
if (agent?.id) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(resolvedCompanyId, agent.id) });
|
||
}
|
||
}
|
||
},
|
||
onError: (err) => {
|
||
setActionError(err instanceof Error ? err.message : "Action failed");
|
||
},
|
||
});
|
||
|
||
const budgetMutation = useMutation({
|
||
mutationFn: (amount: number) =>
|
||
budgetsApi.upsertPolicy(resolvedCompanyId!, {
|
||
scopeType: "agent",
|
||
scopeId: agent?.id ?? routeAgentRef,
|
||
amount,
|
||
windowKind: "calendar_month_utc",
|
||
}),
|
||
onSuccess: () => {
|
||
if (!resolvedCompanyId) return;
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.budgets.overview(resolvedCompanyId) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(routeAgentRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agentLookupRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(resolvedCompanyId) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.dashboard(resolvedCompanyId) });
|
||
},
|
||
});
|
||
|
||
const updateIcon = useMutation({
|
||
mutationFn: (icon: string) => agentsApi.update(agentLookupRef, { icon }, resolvedCompanyId ?? undefined),
|
||
onSuccess: () => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(routeAgentRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agentLookupRef) });
|
||
if (resolvedCompanyId) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(resolvedCompanyId) });
|
||
}
|
||
},
|
||
});
|
||
|
||
const updatePermissions = useMutation({
|
||
mutationFn: (permissions: AgentPermissionUpdate) =>
|
||
agentsApi.updatePermissions(agentLookupRef, permissions, resolvedCompanyId ?? undefined),
|
||
onSuccess: () => {
|
||
setActionError(null);
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(routeAgentRef) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agentLookupRef) });
|
||
if (resolvedCompanyId) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(resolvedCompanyId) });
|
||
}
|
||
},
|
||
onError: (err) => {
|
||
setActionError(err instanceof Error ? err.message : "Failed to update permissions");
|
||
},
|
||
});
|
||
|
||
useEffect(() => {
|
||
const crumbs: { label: string; href?: string }[] = [
|
||
{ label: "Agents", href: "/agents" },
|
||
];
|
||
const agentName = agent?.name ?? routeAgentRef ?? "Agent";
|
||
if (activeView === "dashboard" && !urlRunId) {
|
||
crumbs.push({ label: agentName });
|
||
} else {
|
||
crumbs.push({ label: agentName, href: `/agents/${canonicalAgentRef}/dashboard` });
|
||
if (urlRunId) {
|
||
crumbs.push({ label: "Runs", href: `/agents/${canonicalAgentRef}/runs` });
|
||
crumbs.push({ label: `Run ${urlRunId.slice(0, 8)}` });
|
||
} else if (activeView === "instructions") {
|
||
crumbs.push({ label: "Instructions" });
|
||
} else if (activeView === "configuration") {
|
||
crumbs.push({ label: "Configuration" });
|
||
} else if (activeView === "secrets") {
|
||
crumbs.push({ label: "Secrets" });
|
||
// } else if (activeView === "skills") { // TODO: bring back later
|
||
// crumbs.push({ label: "Skills" });
|
||
} else if (activeView === "tools") {
|
||
crumbs.push({ label: "Tools" });
|
||
} else if (activeView === "runs") {
|
||
crumbs.push({ label: "Runs" });
|
||
} else if (activeView === "budget") {
|
||
crumbs.push({ label: "Budget" });
|
||
} else {
|
||
crumbs.push({ label: "Dashboard" });
|
||
}
|
||
}
|
||
setBreadcrumbs(crumbs);
|
||
}, [setBreadcrumbs, agent, routeAgentRef, canonicalAgentRef, activeView, urlRunId]);
|
||
|
||
useEffect(() => {
|
||
closePanel();
|
||
return () => closePanel();
|
||
}, [closePanel]);
|
||
|
||
useEffect(() => {
|
||
if (!resolvedAgentId || agentMembershipState !== "joined") return;
|
||
setDismissedLeftAgentIds((current) => {
|
||
if (!current.has(resolvedAgentId)) return current;
|
||
const next = new Set(current);
|
||
next.delete(resolvedAgentId);
|
||
return next;
|
||
});
|
||
}, [resolvedAgentId, agentMembershipState]);
|
||
|
||
useBeforeUnload(
|
||
useCallback((event) => {
|
||
if (!configDirty) return;
|
||
event.preventDefault();
|
||
event.returnValue = "";
|
||
}, [configDirty]),
|
||
);
|
||
|
||
useEffect(() => {
|
||
if (!configDirty) return;
|
||
|
||
function handleDocumentClick(event: MouseEvent) {
|
||
if (
|
||
event.defaultPrevented ||
|
||
event.button !== 0 ||
|
||
event.altKey ||
|
||
event.ctrlKey ||
|
||
event.metaKey ||
|
||
event.shiftKey
|
||
) {
|
||
return;
|
||
}
|
||
const target = event.target;
|
||
if (!(target instanceof Element)) return;
|
||
const anchor = target.closest("a[href]");
|
||
if (!(anchor instanceof HTMLAnchorElement)) return;
|
||
if (anchor.target && anchor.target !== "_self") return;
|
||
|
||
const nextUrl = new URL(anchor.href, window.location.href);
|
||
const currentUrl = new URL(window.location.href);
|
||
if (nextUrl.origin !== currentUrl.origin) return;
|
||
if (
|
||
nextUrl.pathname === currentUrl.pathname &&
|
||
nextUrl.search === currentUrl.search &&
|
||
nextUrl.hash === currentUrl.hash
|
||
) {
|
||
return;
|
||
}
|
||
if (prepareAgentNavigation()) return;
|
||
event.preventDefault();
|
||
event.stopPropagation();
|
||
}
|
||
|
||
document.addEventListener("click", handleDocumentClick, true);
|
||
return () => document.removeEventListener("click", handleDocumentClick, true);
|
||
}, [configDirty, prepareAgentNavigation]);
|
||
|
||
useEffect(() => {
|
||
if (!configDirty) return;
|
||
|
||
// BrowserRouter updates after popstate. Run first in the capture phase so a
|
||
// rejected Back/Forward navigation can be restored before React Router
|
||
// consumes it and unmounts the route-backed form.
|
||
const currentEntry = {
|
||
index: window.history.state?.idx,
|
||
state: window.history.state,
|
||
url: window.location.href,
|
||
};
|
||
let restoring = false;
|
||
|
||
function handlePopState(event: PopStateEvent) {
|
||
if (restoring) {
|
||
restoring = false;
|
||
return;
|
||
}
|
||
|
||
if (prepareAgentNavigation()) return;
|
||
|
||
event.stopImmediatePropagation();
|
||
restoring = restoreAgentConfigHistoryEntry(window.history, currentEntry, event.state?.idx);
|
||
}
|
||
|
||
window.addEventListener("popstate", handlePopState, true);
|
||
return () => window.removeEventListener("popstate", handlePopState, true);
|
||
}, [configDirty, prepareAgentNavigation]);
|
||
|
||
if (isLoading || agentView.kind === "reconnecting") return <PageSkeleton variant="detail" />;
|
||
if (agentView.kind === "error") {
|
||
return <QueryErrorState size="page" error={error} action="load this agent" onRetry={agentView.retry} retrying={agentView.isFetching} />;
|
||
}
|
||
if (!agent) return null;
|
||
if (!urlRunId && !urlTab) {
|
||
return <Navigate to={`/agents/${canonicalAgentRef}/dashboard`} replace />;
|
||
}
|
||
const isPendingApproval = agent.status === "pending_approval";
|
||
const hasInvalidOrgChain = agent.orgChainHealth?.status === "invalid_org_chain";
|
||
const pausedEscalationWarning = !hasInvalidOrgChain ? agent.orgChainHealth?.escalationWarning ?? null : null;
|
||
const showConfigActionBar = (
|
||
activeView === "configuration" || activeView === "instructions" || activeView === "secrets"
|
||
) && (configDirty || configSaving);
|
||
const showLeftAgentNotice = agentMembershipState === "left" && !dismissedLeftAgentIds.has(agent.id);
|
||
const agentMembershipPending =
|
||
membershipMutation.isPending &&
|
||
membershipMutation.variables?.resourceType === "agent" &&
|
||
membershipMutation.variables.resourceId === agent.id;
|
||
const agentStarred = isStarred(membershipsQuery.data, "agent", agent.id);
|
||
const agentStarPending = agentMembershipPending && membershipMutation.variables?.starred !== undefined;
|
||
const agentJoinLeavePending = agentMembershipPending && membershipMutation.variables?.starred === undefined;
|
||
|
||
function handleAgentTabChange(value: string) {
|
||
if (value === activeView || !prepareAgentNavigation()) return;
|
||
navigate(`/agents/${canonicalAgentRef}/${value}`);
|
||
}
|
||
|
||
return (
|
||
<div className={cn("space-y-6", isMobile && showConfigActionBar && "pb-24")}>
|
||
{showLeftAgentNotice ? (
|
||
<div className="flex items-center gap-3 border border-yellow-300/35 bg-yellow-300/10 px-3 py-2 text-sm text-yellow-900 dark:text-yellow-100">
|
||
<p className="min-w-0 flex-1">
|
||
You left this agent. It no longer appears in your sidebar.
|
||
</p>
|
||
<MembershipAction
|
||
compact
|
||
state="left"
|
||
pending={agentJoinLeavePending}
|
||
pendingState={agentJoinLeavePending ? membershipMutation.variables?.state : null}
|
||
resourceName={agent.name}
|
||
onJoin={() => membershipMutation.mutate({
|
||
resourceType: "agent",
|
||
resourceId: agent.id,
|
||
resourceName: agent.name,
|
||
state: "joined",
|
||
})}
|
||
onLeave={() => membershipMutation.mutate({
|
||
resourceType: "agent",
|
||
resourceId: agent.id,
|
||
resourceName: agent.name,
|
||
state: "left",
|
||
})}
|
||
/>
|
||
<button
|
||
type="button"
|
||
className="h-6 w-6 shrink-0 text-yellow-900/70 hover:text-yellow-900 dark:text-yellow-100/70 dark:hover:text-yellow-100"
|
||
aria-label="Dismiss agent membership notice"
|
||
onClick={() => setDismissedLeftAgentIds((current) => new Set(current).add(agent.id))}
|
||
>
|
||
×
|
||
</button>
|
||
</div>
|
||
) : null}
|
||
{pausedEscalationWarning ? (
|
||
<div className="flex items-start gap-3 border border-amber-300/35 bg-amber-300/10 px-3 py-2 text-sm text-amber-900 dark:text-amber-100">
|
||
<AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
|
||
<div className="min-w-0 space-y-1">
|
||
<p className="font-medium">Escalation path is paused</p>
|
||
<p className="text-amber-900/90 dark:text-amber-100/90">{pausedEscalationWarning}</p>
|
||
</div>
|
||
</div>
|
||
) : null}
|
||
{hasInvalidOrgChain ? (
|
||
<div className="flex items-start gap-3 border border-amber-300/35 bg-amber-300/10 px-3 py-2 text-sm text-amber-900 dark:text-amber-100">
|
||
<AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
|
||
<div className="min-w-0 space-y-1">
|
||
<p className="font-medium">Invalid reporting chain</p>
|
||
<p className="text-amber-900/90 dark:text-amber-100/90">
|
||
{agent.name} cannot accept tasks or start runs until its reporting chain is repaired.
|
||
</p>
|
||
<p className="break-words font-mono text-xs text-amber-900/80 dark:text-amber-100/80">
|
||
{formatOrgChainHealthPath(agent)}
|
||
</p>
|
||
{agent.orgChainHealth?.repairGuidance ? (
|
||
<p className="text-amber-900/85 dark:text-amber-100/85">{agent.orgChainHealth.repairGuidance}</p>
|
||
) : (
|
||
<p className="text-amber-900/85 dark:text-amber-100/85">
|
||
Assign this agent to an active manager/root, or explicitly pause or terminate the affected agent/subtree.
|
||
</p>
|
||
)}
|
||
</div>
|
||
</div>
|
||
) : null}
|
||
{/* Header */}
|
||
<div className="flex items-center justify-between gap-2">
|
||
<div className="flex items-center gap-3 min-w-0">
|
||
<AgentCharacter agent={agent} state={characterStateForAgent(agent.status)} size={96} trackingScope="page" />
|
||
<div className="min-w-0">
|
||
<div className="flex items-center gap-2">
|
||
<h2 className="text-2xl font-bold truncate">{agent.name}</h2>
|
||
</div>
|
||
<p className="text-sm text-muted-foreground truncate">
|
||
{roleLabels[agent.role] ?? agent.role}
|
||
{agent.title ? ` - ${agent.title}` : ""}
|
||
</p>
|
||
</div>
|
||
</div>
|
||
<div className="flex items-center gap-2 shrink-0">
|
||
<StarToggle
|
||
size="button"
|
||
starred={agentStarred}
|
||
pending={agentStarPending}
|
||
resourceName={agent.name}
|
||
onToggle={(next) => membershipMutation.mutate({
|
||
resourceType: "agent",
|
||
resourceId: agent.id,
|
||
resourceName: agent.name,
|
||
starred: next,
|
||
})}
|
||
/>
|
||
<AgentActionButtons
|
||
agent={agent}
|
||
companyId={resolvedCompanyId}
|
||
assignLabel="Assign Task"
|
||
runLabel="Run Heartbeat"
|
||
actionsDisabled={agentAction.isPending}
|
||
workActionsDisabled={hasInvalidOrgChain}
|
||
workActionsDisabledReason="Repair this agent's reporting chain before assigning tasks or starting runs"
|
||
hasPendingNavigationChanges={configDirty}
|
||
onBeforeNavigate={prepareAgentNavigation}
|
||
onActionError={setActionError}
|
||
onTerminateSuccess={() => navigate("/agents/all", { replace: true })}
|
||
hideTerminate={Boolean(builtInState)}
|
||
pauseConfirm={
|
||
builtInState
|
||
? {
|
||
title: `Pause the ${builtInState.definition.displayName}?`,
|
||
description: (
|
||
<>
|
||
{builtInFeatureLabel} depends on this agent. While paused,{" "}
|
||
{builtInFeatureLabel.toLowerCase()} generation is skipped and the{" "}
|
||
{builtInFeatureLabel} page shows a warning.
|
||
</>
|
||
),
|
||
}
|
||
: undefined
|
||
}
|
||
>
|
||
{mobileLiveRun && (
|
||
<Link
|
||
to={`/agents/${canonicalAgentRef}/runs/${mobileLiveRun.id}`}
|
||
className="sm:hidden flex items-center gap-1.5 px-2 py-0.5 rounded-full bg-blue-500/10 hover:bg-blue-500/20 transition-colors no-underline"
|
||
>
|
||
<span className="relative flex h-2 w-2">
|
||
<span className="animate-pulse absolute inline-flex h-full w-full rounded-full bg-blue-400 opacity-75" />
|
||
<span className="relative inline-flex rounded-full h-2 w-2 bg-blue-500" />
|
||
</span>
|
||
<span className="text-(length:--text-micro) font-medium text-blue-600 dark:text-blue-400">Live</span>
|
||
</Link>
|
||
)}
|
||
</AgentActionButtons>
|
||
</div>
|
||
</div>
|
||
|
||
{builtInState && (
|
||
<InlineBanner
|
||
tone="info"
|
||
title="Built-in agent"
|
||
actions={
|
||
<Button
|
||
variant="outline"
|
||
size="sm"
|
||
onClick={() => resetBuiltIn.mutate()}
|
||
disabled={resetBuiltIn.isPending}
|
||
>
|
||
{resetBuiltIn.isPending ? "Resetting…" : "Reset to defaults"}
|
||
</Button>
|
||
}
|
||
>
|
||
Ships with Paperclip and powers <strong>{builtInFeatureLabel}</strong>. Configure it like
|
||
any agent — model, instructions, budget. It can be paused but not deleted; pausing it
|
||
pauses {builtInFeatureLabel}.
|
||
</InlineBanner>
|
||
)}
|
||
|
||
{builtInState?.definition.bundle && (
|
||
<BuiltInBundlePanel
|
||
state={builtInState}
|
||
agentRef={canonicalAgentRef}
|
||
onConfigure={() => setShowBuiltInConfigure(true)}
|
||
onResetResource={(kind) => resetBuiltInResource.mutate(kind)}
|
||
onRunRoutine={(routineKey) => runBuiltInRoutine.mutate(routineKey)}
|
||
onEnableSchedule={(routineKey) => enableBuiltInSchedule.mutate(routineKey)}
|
||
onDisableSchedule={(routineKey) => disableBuiltInSchedule.mutate(routineKey)}
|
||
resettingResource={resetBuiltInResource.isPending ? resetBuiltInResource.variables ?? null : null}
|
||
routineActionPending={builtInRoutineActionPending}
|
||
/>
|
||
)}
|
||
|
||
{builtInState && resolvedCompanyId && (
|
||
<ConfigureBuiltInAgentModal
|
||
companyId={resolvedCompanyId}
|
||
state={builtInState}
|
||
open={showBuiltInConfigure}
|
||
onOpenChange={setShowBuiltInConfigure}
|
||
onConfigured={() => {
|
||
setShowBuiltInConfigure(false);
|
||
invalidateBuiltIn();
|
||
}}
|
||
/>
|
||
)}
|
||
|
||
{!urlRunId && (
|
||
<Tabs
|
||
value={activeView}
|
||
onValueChange={handleAgentTabChange}
|
||
>
|
||
<PageTabBar
|
||
items={AGENT_DETAIL_TABS.filter((item) => item.value !== "channels" || chatConnectorsEnabled)}
|
||
value={activeView}
|
||
onValueChange={handleAgentTabChange}
|
||
/>
|
||
</Tabs>
|
||
)}
|
||
|
||
{actionError && <p className="text-sm text-destructive">{actionError}</p>}
|
||
{isPendingApproval && (
|
||
<div className="flex flex-wrap items-center gap-3 rounded-md border border-amber-300/60 bg-amber-50 px-3 py-2 text-sm text-amber-900 dark:border-amber-400/40 dark:bg-amber-950/30 dark:text-amber-200">
|
||
<span>This agent is pending board approval and cannot be invoked yet.</span>
|
||
<Button
|
||
variant="outline"
|
||
size="sm"
|
||
onClick={() => agentAction.mutate("approve")}
|
||
disabled={agentAction.isPending}
|
||
>
|
||
<CheckCircle2 className="h-3.5 w-3.5 sm:mr-1" />
|
||
<span>Approve agent</span>
|
||
</Button>
|
||
</div>
|
||
)}
|
||
|
||
{/* Floating Save/Cancel (desktop) */}
|
||
{!isMobile && showConfigActionBar && (
|
||
<div className="fixed bottom-6 right-6 z-30">
|
||
<div className="flex items-center gap-2 bg-background/90 backdrop-blur-sm border border-border rounded-lg px-3 py-1.5 shadow-lg">
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
onClick={() => cancelConfigActionRef.current?.()}
|
||
disabled={configSaving}
|
||
>
|
||
Cancel
|
||
</Button>
|
||
<Button
|
||
size="sm"
|
||
onClick={() => saveConfigActionRef.current?.()}
|
||
disabled={configSaving}
|
||
>
|
||
{configSaving ? "Saving…" : "Save"}
|
||
</Button>
|
||
</div>
|
||
</div>
|
||
)}
|
||
|
||
{/* Mobile bottom Save/Cancel bar */}
|
||
{isMobile && showConfigActionBar && (
|
||
<div className="fixed inset-x-0 bottom-0 z-30 border-t border-border bg-background/95 backdrop-blur-sm">
|
||
<div
|
||
className="flex items-center justify-end gap-2 px-3 py-2"
|
||
style={{ paddingBottom: "max(env(safe-area-inset-bottom), 0.5rem)" }}
|
||
>
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
onClick={() => cancelConfigActionRef.current?.()}
|
||
disabled={configSaving}
|
||
>
|
||
Cancel
|
||
</Button>
|
||
<Button
|
||
size="sm"
|
||
onClick={() => saveConfigActionRef.current?.()}
|
||
disabled={configSaving}
|
||
>
|
||
{configSaving ? "Saving…" : "Save"}
|
||
</Button>
|
||
</div>
|
||
</div>
|
||
)}
|
||
|
||
{/* View content */}
|
||
{activeView === "dashboard" && (
|
||
<AgentOverview
|
||
agent={agent}
|
||
runs={heartbeats ?? []}
|
||
assignedIssues={assignedIssues}
|
||
runtimeState={runtimeState}
|
||
agentId={agent.id}
|
||
agentRouteId={canonicalAgentRef}
|
||
/>
|
||
)}
|
||
|
||
{activeView === "instructions" && (
|
||
<PromptsTab
|
||
agent={agent}
|
||
companyId={resolvedCompanyId ?? undefined}
|
||
onDirtyChange={setConfigDirty}
|
||
onSaveActionChange={setSaveConfigAction}
|
||
onCancelActionChange={setCancelConfigAction}
|
||
onSavingChange={setConfigSaving}
|
||
/>
|
||
)}
|
||
|
||
{activeView === "configuration" && (
|
||
<AgentConfigurePage
|
||
agent={agent}
|
||
agentId={agent.id}
|
||
companyId={resolvedCompanyId ?? undefined}
|
||
onDirtyChange={setConfigDirty}
|
||
onSaveActionChange={setSaveConfigAction}
|
||
onCancelActionChange={setCancelConfigAction}
|
||
onSavingChange={setConfigSaving}
|
||
updatePermissions={updatePermissions}
|
||
/>
|
||
)}
|
||
|
||
{activeView === "secrets" && (
|
||
<div className="max-w-3xl">
|
||
<ConfigurationTab
|
||
agent={agent}
|
||
companyId={resolvedCompanyId ?? undefined}
|
||
onDirtyChange={setConfigDirty}
|
||
onSaveActionChange={setSaveConfigAction}
|
||
onCancelActionChange={setCancelConfigAction}
|
||
onSavingChange={setConfigSaving}
|
||
updatePermissions={updatePermissions}
|
||
content="secrets"
|
||
/>
|
||
</div>
|
||
)}
|
||
|
||
{activeView === "skills" && (
|
||
<AgentSkillsTab
|
||
agent={agent}
|
||
companyId={resolvedCompanyId ?? undefined}
|
||
/>
|
||
)}
|
||
|
||
{activeView === "tools" && resolvedCompanyId && (
|
||
<AgentToolsTab agent={agent} companyId={resolvedCompanyId} />
|
||
)}
|
||
|
||
{activeView === "channels" && resolvedCompanyId && (
|
||
<AgentChannelsPanel agentId={agent.id} companyId={resolvedCompanyId} />
|
||
)}
|
||
|
||
{activeView === "runs" && (
|
||
<RunsTab
|
||
runs={heartbeats ?? []}
|
||
companyId={resolvedCompanyId!}
|
||
agentId={agent.id}
|
||
agentRouteId={canonicalAgentRef}
|
||
selectedRunId={urlRunId ?? null}
|
||
adapterType={agent.adapterType}
|
||
adapterConfig={agent.adapterConfig}
|
||
/>
|
||
)}
|
||
|
||
{activeView === "audit" && resolvedCompanyId ? (
|
||
<AuditFeed companyId={resolvedCompanyId} lockedAgentId={agent.id} hideHeader />
|
||
) : null}
|
||
|
||
{activeView === "budget" && resolvedCompanyId ? (
|
||
<div className="max-w-3xl">
|
||
<BudgetPolicyCard
|
||
summary={agentBudgetSummary}
|
||
isSaving={budgetMutation.isPending}
|
||
onSave={(amount) => budgetMutation.mutate(amount)}
|
||
variant="plain"
|
||
/>
|
||
</div>
|
||
) : null}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Helper components ---- */
|
||
|
||
function SummaryRow({ label, children }: { label: string; children: React.ReactNode }) {
|
||
return (
|
||
<div className="flex items-center justify-between">
|
||
<span className="text-muted-foreground text-xs">{label}</span>
|
||
<div className="flex items-center gap-1">{children}</div>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
export type LatestRunIssue = { id: string; title: string; status: string; identifier?: string | null };
|
||
|
||
/**
|
||
* The id of the issue a run works on, read from its context snapshot. Newer
|
||
* snapshots use `issueId`; older ones use `taskId`. Returns undefined for pure
|
||
* timer heartbeats that carry no task reference.
|
||
*/
|
||
export function getRunSnapshotIssueId(
|
||
run: Pick<HeartbeatRun, "contextSnapshot">,
|
||
): string | undefined {
|
||
const ctx = run.contextSnapshot as Record<string, unknown> | null;
|
||
const issueId = ctx?.issueId ?? ctx?.taskId;
|
||
return issueId ? String(issueId) : undefined;
|
||
}
|
||
|
||
/**
|
||
* Resolve the Live Run section's two navigation destinations and the task (if
|
||
* any) the run works on. The run→task link lives in the run's context snapshot
|
||
* (`issueId`, falling back to `taskId` for older snapshots); the `HeartbeatRun`
|
||
* itself doesn't carry the issue id. The heading always links to the run detail
|
||
* page; the running row links to the task detail page when the snapshot resolves
|
||
* to a known issue, otherwise falls back to the run detail page (pure timer
|
||
* heartbeats or an issue that can't be resolved).
|
||
*/
|
||
export function resolveLatestRunNavigation(
|
||
run: Pick<HeartbeatRun, "id" | "contextSnapshot">,
|
||
agentId: string,
|
||
issuesById: Map<string, LatestRunIssue>,
|
||
): { task: LatestRunIssue | undefined; runHref: string; rowHref: string } {
|
||
const issueId = getRunSnapshotIssueId(run);
|
||
const task = issueId ? issuesById.get(issueId) : undefined;
|
||
const runHref = `/agents/${agentId}/runs/${run.id}`;
|
||
const rowHref = task ? `/issues/${task.identifier ?? task.id}` : runHref;
|
||
return { task, runHref, rowHref };
|
||
}
|
||
|
||
function LatestRunCard({
|
||
runs,
|
||
agentId,
|
||
issuesById,
|
||
}: {
|
||
runs: HeartbeatRun[];
|
||
agentId: string;
|
||
issuesById: Map<string, LatestRunIssue>;
|
||
}) {
|
||
const sorted = useMemo(
|
||
() =>
|
||
[...runs].sort(
|
||
(a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
|
||
),
|
||
[runs]
|
||
);
|
||
|
||
const liveRun = sorted.find((r) => r.status === "running" || r.status === "queued");
|
||
const run = liveRun ?? sorted[0];
|
||
|
||
// The assigned-issues list this card resolves against is bounded (server page
|
||
// limit), so a live run can reference a valid issue that isn't on the loaded
|
||
// page. When the snapshot points at an issue we don't already have, fetch it
|
||
// directly so the running row always links to the task rather than falling
|
||
// back to run metadata. `enabled` keeps this a no-op for the common case.
|
||
const snapshotIssueId = run ? getRunSnapshotIssueId(run) : undefined;
|
||
const needsFallbackFetch = !!snapshotIssueId && !issuesById.has(snapshotIssueId);
|
||
const { data: fallbackIssue } = useQuery({
|
||
queryKey: queryKeys.issues.detail(snapshotIssueId ?? "__none__"),
|
||
queryFn: () => issuesApi.get(snapshotIssueId as string),
|
||
enabled: needsFallbackFetch,
|
||
staleTime: 30_000,
|
||
});
|
||
|
||
const summaryRaw = run
|
||
? run.resultJson
|
||
? String((run.resultJson as Record<string, unknown>).summary ?? (run.resultJson as Record<string, unknown>).result ?? "")
|
||
: run.error ?? ""
|
||
: "";
|
||
|
||
// Extract a clean 2-3 line excerpt: first non-empty, non-header, non-list-mark lines
|
||
const summary = useMemo(() => {
|
||
if (!summaryRaw) return "";
|
||
const lines = summaryRaw
|
||
.replace(/^#{1,6}\s+/gm, "")
|
||
.split("\n")
|
||
.map((l) => l.trim())
|
||
.filter((l) => l.length > 0 && !l.startsWith("---") && !l.startsWith("|") && !l.startsWith("```") && !/^[-*>]/.test(l) && !/^\d+\./.test(l));
|
||
const excerpt: string[] = [];
|
||
let chars = 0;
|
||
for (const line of lines) {
|
||
if (excerpt.length >= 3 || chars + line.length > 280) break;
|
||
excerpt.push(line);
|
||
chars += line.length;
|
||
}
|
||
return excerpt.join(" ");
|
||
}, [summaryRaw]);
|
||
|
||
if (!run) return null;
|
||
|
||
const isLive = run.status === "running" || run.status === "queued";
|
||
// Fold any directly-fetched fallback issue into the lookup, keyed by the same
|
||
// snapshot id used to resolve the row so it hits regardless of id-vs-slug.
|
||
const effectiveIssuesById =
|
||
fallbackIssue && snapshotIssueId
|
||
? new Map(issuesById).set(snapshotIssueId, {
|
||
id: fallbackIssue.id,
|
||
title: fallbackIssue.title,
|
||
status: fallbackIssue.status,
|
||
identifier: fallbackIssue.identifier,
|
||
})
|
||
: issuesById;
|
||
const { task, runHref, rowHref } = resolveLatestRunNavigation(run, agentId, effectiveIssuesById);
|
||
const statusInfo = runStatusIcons[run.status] ?? { icon: Clock, color: "text-neutral-400" };
|
||
const StatusIcon = statusInfo.icon;
|
||
|
||
return (
|
||
<div className="space-y-3">
|
||
<div className="flex w-full items-center justify-between">
|
||
<Link
|
||
to={runHref}
|
||
className="no-underline"
|
||
>
|
||
<h3 className="flex items-center gap-2 text-sm font-medium transition-colors hover:text-foreground">
|
||
{isLive && (
|
||
<span className="relative flex h-2 w-2">
|
||
<span className="animate-pulse absolute inline-flex h-full w-full rounded-full bg-blue-400 opacity-75" />
|
||
<span className="relative inline-flex rounded-full h-2 w-2 bg-blue-500" />
|
||
</span>
|
||
)}
|
||
<span>{isLive ? "Live Run" : "Latest Run"}</span>
|
||
<span className="font-mono text-xs font-normal text-muted-foreground">
|
||
· {run.id.slice(0, 8)}
|
||
</span>
|
||
</h3>
|
||
</Link>
|
||
</div>
|
||
|
||
<Link
|
||
to={rowHref}
|
||
className={cn(
|
||
"block border rounded-lg p-4 space-y-2 w-full no-underline transition-colors hover:bg-muted/50 cursor-pointer",
|
||
isLive ? "border-blue-500/30 shadow-(--shadow-extract-14)" : "border-border"
|
||
)}
|
||
>
|
||
<div className="flex items-center gap-2">
|
||
<StatusIcon className={cn("h-3.5 w-3.5", statusInfo.color, run.status === "running" && "animate-spin")} />
|
||
<StatusBadge status={run.status} />
|
||
{task ? (
|
||
<>
|
||
<StatusGlyph status={task.status} size="sm" />
|
||
<span className="font-mono text-xs text-muted-foreground">
|
||
{task.identifier ?? task.id.slice(0, 8)}
|
||
</span>
|
||
<span className="truncate text-xs">{task.title}</span>
|
||
</>
|
||
) : (
|
||
<>
|
||
<span className="font-mono text-xs text-muted-foreground">{run.id.slice(0, 8)}</span>
|
||
<Badge variant="ghost" className={cn(
|
||
"px-1.5 text-(length:--text-nano)",
|
||
run.invocationSource === "timer" ? "bg-blue-100 text-blue-700 dark:bg-blue-900/50 dark:text-blue-300"
|
||
: run.invocationSource === "assignment" ? "bg-violet-100 text-violet-700 dark:bg-violet-900/50 dark:text-violet-300"
|
||
: run.invocationSource === "on_demand" ? "bg-cyan-100 text-cyan-700 dark:bg-cyan-900/50 dark:text-cyan-300"
|
||
: "bg-muted text-muted-foreground"
|
||
)}>
|
||
{sourceLabels[run.invocationSource] ?? run.invocationSource}
|
||
</Badge>
|
||
</>
|
||
)}
|
||
<span className="ml-auto text-xs text-muted-foreground">{relativeTime(run.createdAt)}</span>
|
||
</div>
|
||
|
||
{summary && (
|
||
<div className="overflow-hidden max-h-16">
|
||
<MarkdownBody className="[&>*:first-child]:mt-0 [&>*:last-child]:mb-0">{summary}</MarkdownBody>
|
||
</div>
|
||
)}
|
||
</Link>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Agent Overview (main single-page view) ---- */
|
||
|
||
function AgentOverview({
|
||
agent,
|
||
runs,
|
||
assignedIssues,
|
||
runtimeState,
|
||
agentId,
|
||
agentRouteId,
|
||
}: {
|
||
agent: AgentDetailRecord;
|
||
runs: HeartbeatRun[];
|
||
assignedIssues: { id: string; title: string; status: string; priority: string; identifier?: string | null; createdAt: Date }[];
|
||
runtimeState?: AgentRuntimeState;
|
||
agentId: string;
|
||
agentRouteId: string;
|
||
}) {
|
||
const issuesById = useMemo(() => {
|
||
const map = new Map<string, (typeof assignedIssues)[number]>();
|
||
for (const issue of assignedIssues) map.set(issue.id, issue);
|
||
return map;
|
||
}, [assignedIssues]);
|
||
|
||
return (
|
||
<div className="space-y-8">
|
||
{/* Latest Run */}
|
||
<LatestRunCard runs={runs} agentId={agentRouteId} issuesById={issuesById} />
|
||
|
||
{/* Charts */}
|
||
<div className="grid grid-cols-2 lg:grid-cols-4 gap-4">
|
||
<ChartCard title="Run Activity" subtitle="Last 14 days">
|
||
<RunActivityChart runs={runs} />
|
||
</ChartCard>
|
||
{/* PAP-411: "Tasks by Priority" chart hidden behind SHOW_TASK_PRIORITY_UI. */}
|
||
{SHOW_TASK_PRIORITY_UI && (
|
||
<ChartCard title="Tasks by Priority" subtitle="Last 14 days">
|
||
<PriorityChart issues={assignedIssues} />
|
||
</ChartCard>
|
||
)}
|
||
<ChartCard title="Tasks by Status" subtitle="Last 14 days">
|
||
<IssueStatusChart issues={assignedIssues} />
|
||
</ChartCard>
|
||
<ChartCard title="Success Rate" subtitle="Last 14 days">
|
||
<SuccessRateChart runs={runs} />
|
||
</ChartCard>
|
||
</div>
|
||
|
||
{/* Recent Issues */}
|
||
<div className="space-y-3">
|
||
<div className="flex items-center justify-between">
|
||
<h3 className="text-sm font-medium">Recent Tasks</h3>
|
||
<Link
|
||
to={`/issues?participantAgentId=${agentId}`}
|
||
className="text-xs text-muted-foreground hover:text-foreground transition-colors"
|
||
>
|
||
See All →
|
||
</Link>
|
||
</div>
|
||
{assignedIssues.length === 0 ? (
|
||
<p className="text-sm text-muted-foreground">No recent tasks.</p>
|
||
) : (
|
||
<div className="border border-border rounded-lg">
|
||
{assignedIssues.slice(0, 10).map((issue) => (
|
||
<EntityRow
|
||
key={issue.id}
|
||
identifier={issue.identifier ?? issue.id.slice(0, 8)}
|
||
title={issue.title}
|
||
to={`/issues/${issue.identifier ?? issue.id}`}
|
||
trailing={<StatusBadge status={issue.status} />}
|
||
/>
|
||
))}
|
||
{assignedIssues.length > 10 && (
|
||
<div className="px-3 py-2 text-xs text-muted-foreground text-center border-t border-border">
|
||
+{assignedIssues.length - 10} more tasks
|
||
</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
|
||
{/* Costs */}
|
||
<div className="space-y-3">
|
||
<h3 className="text-sm font-medium">Costs</h3>
|
||
<CostsSection runtimeState={runtimeState} runs={runs} />
|
||
</div>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Costs Section (inline) ---- */
|
||
|
||
function CostsSection({
|
||
runtimeState,
|
||
runs,
|
||
}: {
|
||
runtimeState?: AgentRuntimeState;
|
||
runs: HeartbeatRun[];
|
||
}) {
|
||
const runsWithCost = runs
|
||
.filter((r) => {
|
||
const metrics = runMetrics(r);
|
||
return metrics.cost > 0 || metrics.input > 0 || metrics.output > 0 || metrics.cached > 0;
|
||
})
|
||
.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
|
||
|
||
return (
|
||
<div className="space-y-4">
|
||
{runtimeState && (
|
||
<div className="border border-border rounded-lg p-4">
|
||
<div className="grid grid-cols-2 md:grid-cols-4 gap-4 tabular-nums">
|
||
<div>
|
||
<span className="text-xs text-muted-foreground block">Input tokens</span>
|
||
<span className="text-lg font-semibold">{formatTokens(runtimeState.totalInputTokens)}</span>
|
||
</div>
|
||
<div>
|
||
<span className="text-xs text-muted-foreground block">Output tokens</span>
|
||
<span className="text-lg font-semibold">{formatTokens(runtimeState.totalOutputTokens)}</span>
|
||
</div>
|
||
<div>
|
||
<span className="text-xs text-muted-foreground block">Cached tokens</span>
|
||
<span className="text-lg font-semibold">{formatTokens(runtimeState.totalCachedInputTokens)}</span>
|
||
</div>
|
||
<div>
|
||
<span className="text-xs text-muted-foreground block">Total cost</span>
|
||
<span className="text-lg font-semibold">{formatCents(runtimeState.totalCostCents)}</span>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
)}
|
||
{runsWithCost.length > 0 && (
|
||
<div className="border border-border rounded-lg overflow-hidden">
|
||
<table className="w-full text-xs">
|
||
<thead>
|
||
<tr className="border-b border-border bg-accent/20">
|
||
<th scope="col" className="text-left px-3 py-2 font-medium text-muted-foreground">Date</th>
|
||
<th scope="col" className="text-left px-3 py-2 font-medium text-muted-foreground">Run</th>
|
||
<th scope="col" className="text-right px-3 py-2 font-medium text-muted-foreground">Input</th>
|
||
<th scope="col" className="text-right px-3 py-2 font-medium text-muted-foreground">Output</th>
|
||
<th scope="col" className="text-right px-3 py-2 font-medium text-muted-foreground">Cost</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{runsWithCost.slice(0, 10).map((run) => {
|
||
const metrics = runMetrics(run);
|
||
return (
|
||
<tr key={run.id} className="border-b border-border last:border-b-0">
|
||
<td className="px-3 py-2">{formatDate(run.createdAt)}</td>
|
||
<td className="px-3 py-2 font-mono">{run.id.slice(0, 8)}</td>
|
||
<td className="px-3 py-2 text-right tabular-nums">{formatTokens(metrics.input)}</td>
|
||
<td className="px-3 py-2 text-right tabular-nums">{formatTokens(metrics.output)}</td>
|
||
<td className="px-3 py-2 text-right tabular-nums">
|
||
{metrics.cost > 0
|
||
? `$${metrics.cost.toFixed(4)}`
|
||
: "-"
|
||
}
|
||
</td>
|
||
</tr>
|
||
);
|
||
})}
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Agent Configure Page ---- */
|
||
|
||
/**
|
||
* Agent detail URLs use a name-derived key, so updates that change the agent's
|
||
* name (a rename or a config-revision rollback) can invalidate the reference
|
||
* currently in the URL. When that happens, refetching the old reference would
|
||
* 404 with "Agent not found". Instead, drop the stale cached queries and
|
||
* replace the URL with the new canonical reference. Returns true when a
|
||
* redirect happened.
|
||
*/
|
||
export function syncAgentRouteAfterRename(
|
||
queryClient: QueryClient,
|
||
navigate: NavigateFunction,
|
||
previous: { id: string; urlKey?: string | null; name?: string | null },
|
||
updated: { id: string; urlKey?: string | null; name?: string | null },
|
||
tab: string,
|
||
): boolean {
|
||
const previousRef = agentRouteRef(previous);
|
||
const nextRef = agentRouteRef(updated);
|
||
if (nextRef === previousRef) return false;
|
||
queryClient.removeQueries({ queryKey: queryKeys.agents.detail(previousRef) });
|
||
navigate(`/agents/${nextRef}/${tab}`, { replace: true });
|
||
return true;
|
||
}
|
||
|
||
function AgentConfigurePage({
|
||
agent,
|
||
agentId,
|
||
companyId,
|
||
onDirtyChange,
|
||
onSaveActionChange,
|
||
onCancelActionChange,
|
||
onSavingChange,
|
||
updatePermissions,
|
||
}: {
|
||
agent: AgentDetailRecord;
|
||
agentId: string;
|
||
companyId?: string;
|
||
onDirtyChange: (dirty: boolean) => void;
|
||
onSaveActionChange: (save: (() => void) | null) => void;
|
||
onCancelActionChange: (cancel: (() => void) | null) => void;
|
||
onSavingChange: (saving: boolean) => void;
|
||
updatePermissions: { mutate: (permissions: AgentPermissionUpdate) => void; isPending: boolean };
|
||
}) {
|
||
const queryClient = useQueryClient();
|
||
const navigate = useNavigate();
|
||
const { tab: urlTab } = useParams<{ tab?: string }>();
|
||
const [revisionsOpen, setRevisionsOpen] = useState(false);
|
||
|
||
const { data: configRevisions } = useQuery({
|
||
queryKey: queryKeys.agents.configRevisions(agent.id),
|
||
queryFn: () => agentsApi.listConfigRevisions(agent.id, companyId),
|
||
});
|
||
|
||
const rollbackConfig = useMutation({
|
||
mutationFn: (revisionId: string) => agentsApi.rollbackConfigRevision(agent.id, revisionId, companyId),
|
||
onSuccess: (updated) => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.configRevisions(agent.id) });
|
||
if (!syncAgentRouteAfterRename(queryClient, navigate, agent, updated, urlTab ?? "configuration")) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.urlKey) });
|
||
}
|
||
},
|
||
});
|
||
|
||
return (
|
||
<div className="max-w-3xl space-y-6">
|
||
<ConfigurationTab
|
||
agent={agent}
|
||
onDirtyChange={onDirtyChange}
|
||
onSaveActionChange={onSaveActionChange}
|
||
onCancelActionChange={onCancelActionChange}
|
||
onSavingChange={onSavingChange}
|
||
updatePermissions={updatePermissions}
|
||
companyId={companyId}
|
||
hidePromptTemplate
|
||
hideInstructionsFile
|
||
/>
|
||
<div>
|
||
<h3 className="text-sm font-medium mb-3">API Keys</h3>
|
||
<KeysTab agentId={agentId} companyId={companyId} />
|
||
</div>
|
||
|
||
{/* Configuration Revisions — collapsible at the bottom */}
|
||
<div>
|
||
<button
|
||
className="flex items-center gap-2 text-sm font-medium hover:text-foreground transition-colors"
|
||
onClick={() => setRevisionsOpen((v) => !v)}
|
||
>
|
||
{revisionsOpen
|
||
? <ChevronDown className="h-3.5 w-3.5 text-muted-foreground" />
|
||
: <ChevronRight className="h-3.5 w-3.5 text-muted-foreground" />
|
||
}
|
||
Configuration Revisions
|
||
<span className="text-xs font-normal text-muted-foreground">{configRevisions?.length ?? 0}</span>
|
||
</button>
|
||
{revisionsOpen && (
|
||
<div className="mt-3">
|
||
{(configRevisions ?? []).length === 0 ? (
|
||
<p className="text-sm text-muted-foreground">No configuration revisions yet.</p>
|
||
) : (
|
||
<div className="space-y-2">
|
||
{(configRevisions ?? []).slice(0, 10).map((revision) => (
|
||
<div key={revision.id} className="border border-border/70 rounded-md p-3 space-y-2">
|
||
<div className="flex items-center justify-between gap-3">
|
||
<div className="text-xs text-muted-foreground">
|
||
<span className="font-mono">{revision.id.slice(0, 8)}</span>
|
||
<span className="mx-1">·</span>
|
||
<span>{formatDate(revision.createdAt)}</span>
|
||
<span className="mx-1">·</span>
|
||
<span>{revision.source}</span>
|
||
</div>
|
||
<Button
|
||
size="sm"
|
||
variant="outline"
|
||
className="h-7 px-2.5 text-xs"
|
||
onClick={() => rollbackConfig.mutate(revision.id)}
|
||
disabled={rollbackConfig.isPending}
|
||
>
|
||
Restore
|
||
</Button>
|
||
</div>
|
||
<p className="text-xs text-muted-foreground">
|
||
Changed:{" "}
|
||
{revision.changedKeys.length > 0 ? revision.changedKeys.join(", ") : "no tracked changes"}
|
||
</p>
|
||
</div>
|
||
))}
|
||
</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Configuration Tab ---- */
|
||
|
||
export function ConfigurationTab({
|
||
agent,
|
||
companyId,
|
||
onDirtyChange,
|
||
onSaveActionChange,
|
||
onCancelActionChange,
|
||
onSavingChange,
|
||
updatePermissions,
|
||
hidePromptTemplate,
|
||
hideInstructionsFile,
|
||
content = "configuration",
|
||
}: {
|
||
agent: AgentDetailRecord;
|
||
companyId?: string;
|
||
onDirtyChange: (dirty: boolean) => void;
|
||
onSaveActionChange: (save: (() => void) | null) => void;
|
||
onCancelActionChange: (cancel: (() => void) | null) => void;
|
||
onSavingChange: (saving: boolean) => void;
|
||
updatePermissions: { mutate: (permissions: AgentPermissionUpdate) => void; isPending: boolean };
|
||
hidePromptTemplate?: boolean;
|
||
hideInstructionsFile?: boolean;
|
||
content?: "configuration" | "secrets";
|
||
}) {
|
||
const queryClient = useQueryClient();
|
||
const navigate = useNavigate();
|
||
const { tab: urlTab } = useParams<{ tab?: string }>();
|
||
const { pushToast } = useToastActions();
|
||
const [awaitingRefreshAfterSave, setAwaitingRefreshAfterSave] = useState(false);
|
||
const lastAgentRef = useRef(agent);
|
||
|
||
const catalogProvider = agent.adapterType === "paperclip_runner" ? String(agent.adapterConfig.provider ?? "codex") : undefined;
|
||
const { data: adapterModels } = useQuery({
|
||
queryKey:
|
||
companyId
|
||
? queryKeys.agents.adapterModels(companyId, agent.adapterType, null, catalogProvider)
|
||
: ["agents", "none", "adapter-models", agent.adapterType],
|
||
queryFn: () => agentsApi.adapterModels(companyId!, agent.adapterType, { provider: catalogProvider }),
|
||
enabled: Boolean(companyId) && content === "configuration",
|
||
});
|
||
|
||
const lowTrustSelected = getTrustPreset(agent.permissions) === "low_trust_review";
|
||
|
||
const { data: boundaryProjects, isLoading: boundaryProjectsLoading } = useQuery({
|
||
...companyProjectsQuery(companyId ?? ""),
|
||
enabled: Boolean(companyId && lowTrustSelected) && content === "configuration",
|
||
});
|
||
|
||
const { data: boundaryIssues, isLoading: boundaryIssuesLoading } = useQuery({
|
||
queryKey: companyId
|
||
? [...queryKeys.issues.list(companyId), "low-trust-boundary-candidates"]
|
||
: ["issues", "__low-trust-disabled"],
|
||
queryFn: () => issuesApi.list(companyId!, { limit: 100, sortField: "updated", sortDir: "desc" }),
|
||
enabled: Boolean(companyId && lowTrustSelected) && content === "configuration",
|
||
});
|
||
|
||
const updateAgent = useMutation({
|
||
mutationFn: (data: Record<string, unknown>) => agentsApi.update(agent.id, data, companyId),
|
||
onMutate: () => {
|
||
setAwaitingRefreshAfterSave(true);
|
||
},
|
||
onSuccess: (updated) => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.configRevisions(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.list(agent.companyId) });
|
||
if (!syncAgentRouteAfterRename(queryClient, navigate, agent, updated, urlTab ?? content)) {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.urlKey) });
|
||
}
|
||
pushToast({ title: "Agent saved", tone: "success" });
|
||
},
|
||
onError: (err) => {
|
||
setAwaitingRefreshAfterSave(false);
|
||
const message =
|
||
err instanceof ApiError
|
||
? err.message
|
||
: err instanceof Error
|
||
? err.message
|
||
: "Could not save agent";
|
||
pushToast({ title: "Save failed", body: message, tone: "error" });
|
||
},
|
||
});
|
||
|
||
useEffect(() => {
|
||
if (awaitingRefreshAfterSave && agent !== lastAgentRef.current) {
|
||
setAwaitingRefreshAfterSave(false);
|
||
}
|
||
lastAgentRef.current = agent;
|
||
}, [agent, awaitingRefreshAfterSave]);
|
||
const isConfigSaving = updateAgent.isPending || awaitingRefreshAfterSave;
|
||
|
||
useEffect(() => {
|
||
onSavingChange(isConfigSaving);
|
||
}, [onSavingChange, isConfigSaving]);
|
||
|
||
const canCreateAgents = Boolean(agent.permissions?.canCreateAgents);
|
||
const canCreateSkills = agent.permissions?.canCreateSkills !== false;
|
||
const canAssignTasks = Boolean(agent.access?.canAssignTasks);
|
||
const taskAssignSource = agent.access?.taskAssignSource ?? "none";
|
||
const taskAssignLocked = agent.role === "ceo" || canCreateAgents;
|
||
const taskAssignHint =
|
||
taskAssignSource === "ceo_role"
|
||
? "Enabled automatically for CEO agents."
|
||
: taskAssignSource === "agent_creator"
|
||
? "Enabled automatically while this agent can create new agents."
|
||
: taskAssignSource === "explicit_grant"
|
||
? "Enabled via explicit company permission grant."
|
||
: taskAssignSource === "simple_default"
|
||
? "Enabled by simple company-wide task assignment defaults."
|
||
: "Disabled unless explicitly granted.";
|
||
|
||
return (
|
||
<div className="space-y-6">
|
||
<AgentConfigForm
|
||
mode="edit"
|
||
agent={agent}
|
||
onSave={(patch) => updateAgent.mutateAsync(patch)}
|
||
isSaving={isConfigSaving}
|
||
adapterModels={adapterModels}
|
||
onDirtyChange={onDirtyChange}
|
||
onSaveActionChange={onSaveActionChange}
|
||
onCancelActionChange={onCancelActionChange}
|
||
hideInlineSave
|
||
hidePromptTemplate={hidePromptTemplate}
|
||
hideInstructionsFile={hideInstructionsFile}
|
||
content={content}
|
||
sectionLayout="cards"
|
||
environmentVariablesPlacement={content === "secrets" ? "secrets" : "configuration"}
|
||
/>
|
||
{content === "configuration" ? (
|
||
<p className="text-xs text-muted-foreground">
|
||
Saved adapter config affects the next run. Active runs keep the config they started with, and config changes may start a fresh adapter session.
|
||
</p>
|
||
) : null}
|
||
|
||
{content === "configuration" ? <TrustPresetSection
|
||
projectAccessEditor={<AgentProjectAccessSettings agent={agent} />}
|
||
permissions={agent.permissions}
|
||
disabled={updatePermissions.isPending}
|
||
companyId={companyId}
|
||
projectCandidates={(boundaryProjects ?? []).map((project) => ({
|
||
id: project.id,
|
||
label: project.name,
|
||
}))}
|
||
issueCandidates={(boundaryIssues ?? []).map((issue) => ({
|
||
id: issue.id,
|
||
label: `${issue.identifier ?? issue.id.slice(0, 8)} · ${issue.title}`,
|
||
}))}
|
||
candidatesLoading={boundaryProjectsLoading || boundaryIssuesLoading}
|
||
onChange={(nextPermissions) =>
|
||
updatePermissions.mutate({
|
||
canCreateAgents,
|
||
canCreateSkills,
|
||
canAssignTasks,
|
||
...buildPermissionsForTrustPreset(nextPermissions, nextPermissions.trustPreset === "low_trust_review" ? "low_trust_review" : "standard"),
|
||
})
|
||
}
|
||
/> : null}
|
||
|
||
{content === "configuration" ? <div>
|
||
<h3 className="text-sm font-medium mb-3">Permissions</h3>
|
||
<div className="border border-border rounded-lg p-4 space-y-4">
|
||
<div className="flex items-center justify-between gap-4 text-sm">
|
||
<div className="space-y-1">
|
||
<div>Can create new agents</div>
|
||
<p className="text-xs text-muted-foreground">
|
||
Lets this agent create or hire agents. This also grants task assignment authority.
|
||
</p>
|
||
</div>
|
||
<ToggleSwitch
|
||
checked={canCreateAgents}
|
||
onCheckedChange={() =>
|
||
updatePermissions.mutate({
|
||
canCreateAgents: !canCreateAgents,
|
||
canCreateSkills,
|
||
canAssignTasks: !canCreateAgents ? true : canAssignTasks,
|
||
})
|
||
}
|
||
disabled={updatePermissions.isPending}
|
||
/>
|
||
</div>
|
||
<div className="flex items-center justify-between gap-4 text-sm">
|
||
<div className="space-y-1">
|
||
<div>Can create/import skills</div>
|
||
<p className="text-xs text-muted-foreground">
|
||
Lets this agent install, import, create, and scan company skills without creating agents.
|
||
</p>
|
||
</div>
|
||
<ToggleSwitch
|
||
checked={canCreateSkills}
|
||
onCheckedChange={() =>
|
||
updatePermissions.mutate({
|
||
canCreateAgents,
|
||
canCreateSkills: !canCreateSkills,
|
||
canAssignTasks,
|
||
})
|
||
}
|
||
disabled={updatePermissions.isPending}
|
||
/>
|
||
</div>
|
||
<div className="flex items-center justify-between gap-4 text-sm">
|
||
<div className="space-y-1">
|
||
<div>Can assign tasks</div>
|
||
<p className="text-xs text-muted-foreground">
|
||
{taskAssignHint}
|
||
</p>
|
||
</div>
|
||
<ToggleSwitch
|
||
checked={canAssignTasks}
|
||
onCheckedChange={() =>
|
||
updatePermissions.mutate({
|
||
canCreateAgents,
|
||
canCreateSkills,
|
||
canAssignTasks: !canAssignTasks,
|
||
})
|
||
}
|
||
disabled={updatePermissions.isPending || taskAssignLocked}
|
||
/>
|
||
</div>
|
||
</div>
|
||
</div> : null}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Prompts Tab ---- */
|
||
|
||
export function PromptsTab({
|
||
agent,
|
||
companyId,
|
||
onDirtyChange,
|
||
onSaveActionChange,
|
||
onCancelActionChange,
|
||
onSavingChange,
|
||
}: {
|
||
agent: Agent;
|
||
companyId?: string;
|
||
onDirtyChange: (dirty: boolean) => void;
|
||
onSaveActionChange: (save: (() => void) | null) => void;
|
||
onCancelActionChange: (cancel: (() => void) | null) => void;
|
||
onSavingChange: (saving: boolean) => void;
|
||
}) {
|
||
const queryClient = useQueryClient();
|
||
const { selectedCompanyId } = useCompany();
|
||
const { isMobile } = useSidebar();
|
||
const [selectedFile, setSelectedFile] = useState<string>("AGENTS.md");
|
||
const [showFilePanel, setShowFilePanel] = useState(false);
|
||
const [draft, setDraft] = useState<string | null>(null);
|
||
const [bundleDraft, setBundleDraft] = useState<{
|
||
mode: "managed" | "external";
|
||
rootPath: string;
|
||
entryFile: string;
|
||
} | null>(null);
|
||
const [newFilePath, setNewFilePath] = useState("");
|
||
const [showNewFileInput, setShowNewFileInput] = useState(false);
|
||
const [pendingFiles, setPendingFiles] = useState<string[]>([]);
|
||
const [expandedDirs, setExpandedDirs] = useState<Set<string>>(new Set());
|
||
const [filePanelWidth, setFilePanelWidth] = useState(260);
|
||
const [instructionPaneWidth, setInstructionPaneWidth] = useState<number | null>(null);
|
||
const containerRef = useRef<HTMLDivElement>(null);
|
||
const [awaitingRefresh, setAwaitingRefresh] = useState(false);
|
||
const lastFileVersionRef = useRef<string | null>(null);
|
||
const externalBundleRef = useRef<{
|
||
rootPath: string;
|
||
entryFile: string;
|
||
selectedFile: string;
|
||
} | null>(null);
|
||
|
||
useEffect(() => {
|
||
setSelectedFile("AGENTS.md");
|
||
setShowFilePanel(false);
|
||
setDraft(null);
|
||
setBundleDraft(null);
|
||
setNewFilePath("");
|
||
setShowNewFileInput(false);
|
||
setPendingFiles([]);
|
||
setExpandedDirs(new Set());
|
||
setAwaitingRefresh(false);
|
||
lastFileVersionRef.current = null;
|
||
externalBundleRef.current = null;
|
||
}, [agent.id]);
|
||
|
||
const getCapabilities = useAdapterCapabilities();
|
||
const isLocal = getCapabilities(agent.adapterType).supportsInstructionsBundle;
|
||
|
||
const { data: bundle, isLoading: bundleLoading } = useQuery({
|
||
queryKey: queryKeys.agents.instructionsBundle(agent.id),
|
||
queryFn: () => agentsApi.instructionsBundle(agent.id, companyId),
|
||
enabled: Boolean(companyId && isLocal),
|
||
});
|
||
|
||
const persistedMode = bundle?.mode ?? "managed";
|
||
const persistedRootPath = persistedMode === "managed"
|
||
? (bundle?.managedRootPath ?? bundle?.rootPath ?? "")
|
||
: (bundle?.rootPath ?? "");
|
||
const currentMode = bundleDraft?.mode ?? persistedMode;
|
||
const currentEntryFile = bundleDraft?.entryFile ?? bundle?.entryFile ?? "AGENTS.md";
|
||
const currentRootPath = bundleDraft?.rootPath ?? persistedRootPath;
|
||
const fileOptions = useMemo(
|
||
() => bundle?.files.map((file) => file.path) ?? [],
|
||
[bundle],
|
||
);
|
||
const bundleMatchesDraft = Boolean(
|
||
bundle &&
|
||
currentMode === persistedMode &&
|
||
currentEntryFile === bundle.entryFile &&
|
||
currentRootPath === persistedRootPath,
|
||
);
|
||
const visibleFilePaths = useMemo(
|
||
() => bundleMatchesDraft
|
||
? [...new Set([currentEntryFile, ...fileOptions, ...pendingFiles])]
|
||
: [currentEntryFile, ...pendingFiles],
|
||
[bundleMatchesDraft, currentEntryFile, fileOptions, pendingFiles],
|
||
);
|
||
const fileTree = useMemo(
|
||
() => buildFileTree(Object.fromEntries(visibleFilePaths.map((filePath) => [filePath, ""]))),
|
||
[visibleFilePaths],
|
||
);
|
||
const selectedOrEntryFile = selectedFile || currentEntryFile;
|
||
const selectedFileExists = bundleMatchesDraft && fileOptions.includes(selectedOrEntryFile);
|
||
const selectedFileSummary = bundle?.files.find((file) => file.path === selectedOrEntryFile) ?? null;
|
||
|
||
const { data: selectedFileDetail, isLoading: fileLoading } = useQuery({
|
||
queryKey: queryKeys.agents.instructionsFile(agent.id, selectedOrEntryFile),
|
||
queryFn: () => agentsApi.instructionsFile(agent.id, selectedOrEntryFile, companyId),
|
||
enabled: Boolean(companyId && isLocal && selectedFileExists),
|
||
});
|
||
|
||
const updateBundle = useMutation({
|
||
mutationFn: (data: {
|
||
mode?: "managed" | "external";
|
||
rootPath?: string | null;
|
||
entryFile?: string;
|
||
clearLegacyPromptTemplate?: boolean;
|
||
}) => agentsApi.updateInstructionsBundle(agent.id, data, companyId),
|
||
onMutate: () => setAwaitingRefresh(true),
|
||
onSuccess: () => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.instructionsBundle(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.urlKey) });
|
||
},
|
||
onError: () => setAwaitingRefresh(false),
|
||
});
|
||
|
||
const saveFile = useMutation({
|
||
mutationFn: (data: { path: string; content: string; clearLegacyPromptTemplate?: boolean }) =>
|
||
agentsApi.saveInstructionsFile(agent.id, data, companyId),
|
||
onMutate: () => setAwaitingRefresh(true),
|
||
onSuccess: (_, variables) => {
|
||
setPendingFiles((prev) => prev.filter((f) => f !== variables.path));
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.instructionsBundle(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.instructionsFile(agent.id, variables.path) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.urlKey) });
|
||
},
|
||
onError: () => setAwaitingRefresh(false),
|
||
});
|
||
|
||
const deleteFile = useMutation({
|
||
mutationFn: (relativePath: string) => agentsApi.deleteInstructionsFile(agent.id, relativePath, companyId),
|
||
onMutate: () => setAwaitingRefresh(true),
|
||
onSuccess: (_, relativePath) => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.instructionsBundle(agent.id) });
|
||
queryClient.removeQueries({ queryKey: queryKeys.agents.instructionsFile(agent.id, relativePath) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.detail(agent.urlKey) });
|
||
},
|
||
onError: () => setAwaitingRefresh(false),
|
||
});
|
||
|
||
const uploadMarkdownImage = useMutation({
|
||
mutationFn: async ({ file, namespace }: { file: File; namespace: string }) => {
|
||
if (!selectedCompanyId) throw new Error("Select a company to upload images");
|
||
return assetsApi.uploadImage(selectedCompanyId, file, namespace);
|
||
},
|
||
});
|
||
|
||
useEffect(() => {
|
||
if (!bundle) return;
|
||
if (!bundleMatchesDraft) {
|
||
if (selectedFile !== currentEntryFile) setSelectedFile(currentEntryFile);
|
||
return;
|
||
}
|
||
const availablePaths = bundle.files.map((file) => file.path);
|
||
if (availablePaths.length === 0) {
|
||
if (selectedFile !== bundle.entryFile) setSelectedFile(bundle.entryFile);
|
||
return;
|
||
}
|
||
if (!availablePaths.includes(selectedFile) && selectedFile !== currentEntryFile && !pendingFiles.includes(selectedFile)) {
|
||
setSelectedFile(availablePaths.includes(bundle.entryFile) ? bundle.entryFile : availablePaths[0]!);
|
||
}
|
||
}, [bundle, bundleMatchesDraft, currentEntryFile, pendingFiles, selectedFile]);
|
||
|
||
useEffect(() => {
|
||
const nextExpanded = new Set<string>();
|
||
for (const filePath of visibleFilePaths) {
|
||
const parts = filePath.split("/");
|
||
let currentPath = "";
|
||
for (let i = 0; i < parts.length - 1; i++) {
|
||
currentPath = currentPath ? `${currentPath}/${parts[i]}` : parts[i]!;
|
||
nextExpanded.add(currentPath);
|
||
}
|
||
}
|
||
setExpandedDirs((current) => (setsEqual(current, nextExpanded) ? current : nextExpanded));
|
||
}, [visibleFilePaths]);
|
||
|
||
useEffect(() => {
|
||
if (isMobile) {
|
||
setInstructionPaneWidth(null);
|
||
return;
|
||
}
|
||
const element = containerRef.current;
|
||
if (!element) return;
|
||
|
||
const updateWidth = () => setInstructionPaneWidth(element.getBoundingClientRect().width);
|
||
updateWidth();
|
||
|
||
if (typeof ResizeObserver === "undefined") return;
|
||
const observer = new ResizeObserver((entries) => {
|
||
const entry = entries[0];
|
||
if (entry) setInstructionPaneWidth(entry.contentRect.width);
|
||
});
|
||
observer.observe(element);
|
||
return () => observer.disconnect();
|
||
}, [bundleLoading, isMobile, visibleFilePaths.length]);
|
||
|
||
useEffect(() => {
|
||
const versionKey = selectedFileExists && selectedFileDetail
|
||
? `${selectedFileDetail.path}:${selectedFileDetail.content}`
|
||
: `draft:${currentMode}:${currentRootPath}:${selectedOrEntryFile}`;
|
||
if (awaitingRefresh) {
|
||
setAwaitingRefresh(false);
|
||
setBundleDraft(null);
|
||
setDraft(null);
|
||
lastFileVersionRef.current = versionKey;
|
||
return;
|
||
}
|
||
if (lastFileVersionRef.current !== versionKey) {
|
||
setDraft(null);
|
||
lastFileVersionRef.current = versionKey;
|
||
}
|
||
}, [awaitingRefresh, currentMode, currentRootPath, selectedFileDetail, selectedFileExists, selectedOrEntryFile]);
|
||
|
||
useEffect(() => {
|
||
if (!bundle) return;
|
||
setBundleDraft((current) => {
|
||
if (current) return current;
|
||
return {
|
||
mode: persistedMode,
|
||
rootPath: persistedRootPath,
|
||
entryFile: bundle.entryFile,
|
||
};
|
||
});
|
||
}, [bundle, persistedMode, persistedRootPath]);
|
||
|
||
useEffect(() => {
|
||
if (!bundle || currentMode !== "external") return;
|
||
externalBundleRef.current = {
|
||
rootPath: currentRootPath,
|
||
entryFile: currentEntryFile,
|
||
selectedFile: selectedOrEntryFile,
|
||
};
|
||
}, [bundle, currentEntryFile, currentMode, currentRootPath, selectedOrEntryFile]);
|
||
|
||
const currentContent = selectedFileExists ? (selectedFileDetail?.content ?? "") : "";
|
||
const displayValue = draft ?? currentContent;
|
||
const useMarkdownEditor = shouldUseMarkdownInstructionsEditor({
|
||
selectedFileExists,
|
||
selectedPath: selectedOrEntryFile,
|
||
detail: selectedFileDetail,
|
||
summary: selectedFileSummary,
|
||
});
|
||
const bundleDirty = Boolean(
|
||
bundleDraft &&
|
||
(
|
||
bundleDraft.mode !== persistedMode ||
|
||
bundleDraft.rootPath !== persistedRootPath ||
|
||
bundleDraft.entryFile !== (bundle?.entryFile ?? "AGENTS.md")
|
||
),
|
||
);
|
||
const fileDirty = draft !== null && draft !== currentContent;
|
||
const isDirty = bundleDirty || fileDirty;
|
||
const isSaving = updateBundle.isPending || saveFile.isPending || deleteFile.isPending || awaitingRefresh;
|
||
|
||
useEffect(() => { onSavingChange(isSaving); }, [onSavingChange, isSaving]);
|
||
useEffect(() => { onDirtyChange(isDirty); }, [onDirtyChange, isDirty]);
|
||
|
||
useEffect(() => {
|
||
onSaveActionChange(isDirty ? () => {
|
||
const save = async () => {
|
||
const shouldClearLegacy =
|
||
Boolean(bundle?.legacyPromptTemplateActive) || Boolean(bundle?.legacyBootstrapPromptTemplateActive);
|
||
if (bundleDirty && bundleDraft) {
|
||
await updateBundle.mutateAsync({
|
||
mode: bundleDraft.mode,
|
||
rootPath: bundleDraft.mode === "external" ? bundleDraft.rootPath : null,
|
||
entryFile: bundleDraft.entryFile,
|
||
});
|
||
}
|
||
if (fileDirty) {
|
||
await saveFile.mutateAsync({
|
||
path: selectedOrEntryFile,
|
||
content: displayValue,
|
||
clearLegacyPromptTemplate: shouldClearLegacy,
|
||
});
|
||
}
|
||
};
|
||
void save().catch(() => undefined);
|
||
} : null);
|
||
}, [
|
||
bundle,
|
||
bundleDirty,
|
||
bundleDraft,
|
||
displayValue,
|
||
fileDirty,
|
||
isDirty,
|
||
onSaveActionChange,
|
||
saveFile,
|
||
selectedOrEntryFile,
|
||
updateBundle,
|
||
]);
|
||
|
||
useEffect(() => {
|
||
onCancelActionChange(isDirty ? () => {
|
||
setDraft(null);
|
||
if (bundle) {
|
||
setBundleDraft({
|
||
mode: persistedMode,
|
||
rootPath: persistedRootPath,
|
||
entryFile: bundle.entryFile,
|
||
});
|
||
}
|
||
} : null);
|
||
}, [bundle, isDirty, onCancelActionChange, persistedMode, persistedRootPath]);
|
||
|
||
const handleSeparatorDrag = useCallback((event: React.MouseEvent) => {
|
||
event.preventDefault();
|
||
const startX = event.clientX;
|
||
const startWidth = filePanelWidth;
|
||
const onMouseMove = (moveEvent: MouseEvent) => {
|
||
const delta = moveEvent.clientX - startX;
|
||
const next = Math.max(180, Math.min(500, startWidth + delta));
|
||
setFilePanelWidth(next);
|
||
};
|
||
const onMouseUp = () => {
|
||
document.removeEventListener("mousemove", onMouseMove);
|
||
document.removeEventListener("mouseup", onMouseUp);
|
||
document.body.style.cursor = "";
|
||
document.body.style.userSelect = "";
|
||
};
|
||
document.addEventListener("mousemove", onMouseMove);
|
||
document.addEventListener("mouseup", onMouseUp);
|
||
document.body.style.cursor = "col-resize";
|
||
document.body.style.userSelect = "none";
|
||
}, [filePanelWidth]);
|
||
|
||
const instructionsSideBySide =
|
||
!isMobile && instructionPaneWidth !== null && instructionPaneWidth >= filePanelWidth + 520;
|
||
|
||
if (!isLocal) {
|
||
return (
|
||
<div className="max-w-3xl">
|
||
<p className="text-sm text-muted-foreground">
|
||
Instructions bundles are only available for local adapters.
|
||
</p>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
if (bundleLoading && !bundle) {
|
||
return <PromptsTabSkeleton />;
|
||
}
|
||
|
||
return (
|
||
<div className="space-y-6">
|
||
{(bundle?.warnings ?? []).length > 0 && (
|
||
<div className="space-y-2">
|
||
{(bundle?.warnings ?? []).map((warning) => (
|
||
<div key={warning} className="rounded-md border border-sky-500/25 bg-sky-500/10 px-3 py-2 text-xs text-sky-900 dark:text-sky-100">
|
||
{warning}
|
||
</div>
|
||
))}
|
||
</div>
|
||
)}
|
||
<p className="text-xs text-muted-foreground">
|
||
Saved instructions affect the next run. Active runs keep the instructions they started with, and instruction changes may start a fresh adapter session.
|
||
</p>
|
||
|
||
<Collapsible defaultOpen={currentMode === "external"}>
|
||
<CollapsibleTrigger className="flex items-center gap-1 text-xs text-muted-foreground hover:text-foreground transition-colors group">
|
||
<ChevronRight className="h-3 w-3 transition-transform group-data-[state=open]:rotate-90" />
|
||
Advanced
|
||
</CollapsibleTrigger>
|
||
<CollapsibleContent className="pt-4 pb-6">
|
||
<TooltipProvider>
|
||
<div className="grid gap-x-6 gap-y-4 md:grid-cols-(--gtc-18)">
|
||
<label className="space-y-1.5 min-w-0">
|
||
<span className="text-xs font-medium text-muted-foreground flex items-center gap-1">
|
||
Mode
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<HelpCircle className="h-3 w-3 text-muted-foreground cursor-help" />
|
||
</TooltipTrigger>
|
||
<TooltipContent side="right" sideOffset={4}>
|
||
Managed: Paperclip stores and serves the instructions bundle. External: you provide a path on disk where the instructions live.
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</span>
|
||
<div className="flex gap-2">
|
||
<Button
|
||
type="button"
|
||
size="sm"
|
||
variant={currentMode === "managed" ? "default" : "outline"}
|
||
onClick={() => {
|
||
if (currentMode === "external") {
|
||
externalBundleRef.current = {
|
||
rootPath: currentRootPath,
|
||
entryFile: currentEntryFile,
|
||
selectedFile: selectedOrEntryFile,
|
||
};
|
||
}
|
||
const nextEntryFile = currentEntryFile || "AGENTS.md";
|
||
setBundleDraft({
|
||
mode: "managed",
|
||
rootPath: bundle?.managedRootPath ?? currentRootPath,
|
||
entryFile: nextEntryFile,
|
||
});
|
||
setSelectedFile(nextEntryFile);
|
||
}}
|
||
>
|
||
Managed
|
||
</Button>
|
||
<Button
|
||
type="button"
|
||
size="sm"
|
||
variant={currentMode === "external" ? "default" : "outline"}
|
||
onClick={() => {
|
||
const externalBundle = externalBundleRef.current;
|
||
const nextEntryFile = externalBundle?.entryFile ?? currentEntryFile ?? "AGENTS.md";
|
||
setBundleDraft({
|
||
mode: "external",
|
||
rootPath: externalBundle?.rootPath ?? (bundle?.mode === "external" ? (bundle.rootPath ?? "") : ""),
|
||
entryFile: nextEntryFile,
|
||
});
|
||
setSelectedFile(externalBundle?.selectedFile ?? nextEntryFile);
|
||
}}
|
||
>
|
||
External
|
||
</Button>
|
||
</div>
|
||
</label>
|
||
<label className="space-y-1.5 min-w-0">
|
||
<span className="text-xs font-medium text-muted-foreground flex items-center gap-1">
|
||
Root path
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<HelpCircle className="h-3 w-3 text-muted-foreground cursor-help" />
|
||
</TooltipTrigger>
|
||
<TooltipContent side="right" sideOffset={4}>
|
||
The absolute directory on disk where the instructions bundle lives. In managed mode this is set by Paperclip automatically.
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</span>
|
||
{currentMode === "managed" ? (
|
||
<div className="flex items-center gap-1.5 font-mono text-xs text-muted-foreground pt-1.5">
|
||
<span className="min-w-0 truncate" title={currentRootPath || undefined}>{currentRootPath || "(managed)"}</span>
|
||
{currentRootPath && (
|
||
<CopyText text={currentRootPath} className="shrink-0">
|
||
<Copy className="h-3.5 w-3.5" />
|
||
</CopyText>
|
||
)}
|
||
</div>
|
||
) : (
|
||
<div className="flex items-center gap-1.5">
|
||
<Input
|
||
value={currentRootPath}
|
||
onChange={(event) => {
|
||
const nextRootPath = event.target.value;
|
||
externalBundleRef.current = {
|
||
rootPath: nextRootPath,
|
||
entryFile: currentEntryFile,
|
||
selectedFile: selectedOrEntryFile,
|
||
};
|
||
setBundleDraft({
|
||
mode: "external",
|
||
rootPath: nextRootPath,
|
||
entryFile: currentEntryFile,
|
||
});
|
||
}}
|
||
className="font-mono text-sm"
|
||
placeholder="/absolute/path/to/agent/prompts"
|
||
/>
|
||
{currentRootPath && (
|
||
<CopyText text={currentRootPath} className="shrink-0">
|
||
<Copy className="h-3.5 w-3.5" />
|
||
</CopyText>
|
||
)}
|
||
</div>
|
||
)}
|
||
</label>
|
||
<label className="space-y-1.5">
|
||
<span className="text-xs font-medium text-muted-foreground flex items-center gap-1">
|
||
Entry file
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<HelpCircle className="h-3 w-3 text-muted-foreground cursor-help" />
|
||
</TooltipTrigger>
|
||
<TooltipContent side="right" sideOffset={4}>
|
||
The main file the agent reads first when loading instructions. Defaults to AGENTS.md.
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
</span>
|
||
<Input
|
||
value={currentEntryFile}
|
||
onChange={(event) => {
|
||
const nextEntryFile = event.target.value || "AGENTS.md";
|
||
const nextSelectedFile = selectedOrEntryFile === currentEntryFile
|
||
? nextEntryFile
|
||
: selectedOrEntryFile;
|
||
if (currentMode === "external") {
|
||
externalBundleRef.current = {
|
||
rootPath: currentRootPath,
|
||
entryFile: nextEntryFile,
|
||
selectedFile: nextSelectedFile,
|
||
};
|
||
}
|
||
if (selectedOrEntryFile === currentEntryFile) setSelectedFile(nextEntryFile);
|
||
setBundleDraft({
|
||
mode: currentMode,
|
||
rootPath: currentRootPath,
|
||
entryFile: nextEntryFile,
|
||
});
|
||
}}
|
||
className="font-mono text-sm"
|
||
/>
|
||
</label>
|
||
</div>
|
||
</TooltipProvider>
|
||
</CollapsibleContent>
|
||
</Collapsible>
|
||
|
||
<div
|
||
ref={containerRef}
|
||
className="grid min-w-0 gap-3"
|
||
style={
|
||
instructionsSideBySide
|
||
? { gridTemplateColumns: `${filePanelWidth}px 0.5rem minmax(0, 1fr)` }
|
||
: undefined
|
||
}
|
||
>
|
||
<div className={cn(
|
||
"min-w-0 w-full border border-border rounded-lg p-3 space-y-3",
|
||
isMobile && showFilePanel && "block",
|
||
isMobile && !showFilePanel && "hidden",
|
||
)}>
|
||
<div className="flex items-center justify-between">
|
||
<h4 className="text-sm font-medium">Files</h4>
|
||
<div className="flex items-center gap-1">
|
||
{!showNewFileInput && (
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="outline"
|
||
className="h-7 w-7"
|
||
onClick={() => setShowNewFileInput(true)}
|
||
>
|
||
+
|
||
</Button>
|
||
)}
|
||
{isMobile && (
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="ghost"
|
||
className="h-7 w-7"
|
||
onClick={() => setShowFilePanel(false)}
|
||
>
|
||
✕
|
||
</Button>
|
||
)}
|
||
</div>
|
||
</div>
|
||
{showNewFileInput && (
|
||
<div className="space-y-2">
|
||
<Input
|
||
value={newFilePath}
|
||
onChange={(event) => setNewFilePath(event.target.value)}
|
||
placeholder="TOOLS.md"
|
||
className="font-mono text-sm"
|
||
autoFocus
|
||
onKeyDown={(event) => {
|
||
if (event.key === "Escape") {
|
||
setShowNewFileInput(false);
|
||
setNewFilePath("");
|
||
}
|
||
}}
|
||
/>
|
||
<div className="flex gap-2">
|
||
<Button
|
||
type="button"
|
||
size="sm"
|
||
variant="default"
|
||
className="flex-1"
|
||
disabled={!newFilePath.trim() || newFilePath.includes("..")}
|
||
onClick={() => {
|
||
const candidate = newFilePath.trim();
|
||
if (!candidate || candidate.includes("..")) return;
|
||
setPendingFiles((prev) => prev.includes(candidate) ? prev : [...prev, candidate]);
|
||
setSelectedFile(candidate);
|
||
setDraft("");
|
||
setNewFilePath("");
|
||
setShowNewFileInput(false);
|
||
}}
|
||
>
|
||
Create
|
||
</Button>
|
||
<Button
|
||
type="button"
|
||
size="sm"
|
||
variant="outline"
|
||
className="flex-1"
|
||
onClick={() => {
|
||
setShowNewFileInput(false);
|
||
setNewFilePath("");
|
||
}}
|
||
>
|
||
Cancel
|
||
</Button>
|
||
</div>
|
||
</div>
|
||
)}
|
||
<FileTree
|
||
nodes={fileTree}
|
||
selectedFile={selectedOrEntryFile}
|
||
expandedDirs={expandedDirs}
|
||
checkedFiles={new Set()}
|
||
onToggleDir={(dirPath) => setExpandedDirs((current) => {
|
||
const next = new Set(current);
|
||
if (next.has(dirPath)) next.delete(dirPath);
|
||
else next.add(dirPath);
|
||
return next;
|
||
})}
|
||
onSelectFile={(filePath) => {
|
||
setSelectedFile(filePath);
|
||
if (!fileOptions.includes(filePath)) setDraft("");
|
||
if (isMobile) setShowFilePanel(false);
|
||
}}
|
||
onToggleCheck={() => {}}
|
||
showCheckboxes={false}
|
||
wrapLabels
|
||
renderFileExtra={(node) => {
|
||
const file = bundle?.files.find((entry) => entry.path === node.path);
|
||
if (!file) return null;
|
||
if (file.deprecated) {
|
||
return (
|
||
<Tooltip>
|
||
<TooltipTrigger asChild>
|
||
<span className="ml-3 shrink-0 rounded border border-amber-500/40 bg-amber-500/10 text-amber-800 dark:text-amber-200 px-1.5 py-0.5 text-(length:--text-nano) uppercase tracking-wide cursor-help">
|
||
virtual file
|
||
</span>
|
||
</TooltipTrigger>
|
||
<TooltipContent side="right" sideOffset={4}>
|
||
Legacy inline prompt — this deprecated virtual file preserves the old promptTemplate content
|
||
</TooltipContent>
|
||
</Tooltip>
|
||
);
|
||
}
|
||
return (
|
||
<span className="ml-3 shrink-0 rounded border border-border text-muted-foreground px-1.5 py-0.5 text-(length:--text-nano) uppercase tracking-wide">
|
||
{file.isEntryFile ? "entry" : `${file.size}b`}
|
||
</span>
|
||
);
|
||
}}
|
||
/>
|
||
</div>
|
||
|
||
{/* Draggable separator */}
|
||
{instructionsSideBySide && (
|
||
<div
|
||
className="w-1 cursor-col-resize rounded transition-colors hover:bg-border active:bg-primary/50"
|
||
onMouseDown={handleSeparatorDrag}
|
||
/>
|
||
)}
|
||
|
||
<div className={cn("min-w-0 w-full overflow-hidden border border-border rounded-lg p-4 space-y-3", isMobile && showFilePanel && "hidden")}>
|
||
<div className="flex items-center justify-between gap-3">
|
||
<div className="flex items-center gap-2 min-w-0">
|
||
{isMobile && (
|
||
<Button
|
||
type="button"
|
||
size="icon"
|
||
variant="outline"
|
||
className="h-7 w-7 shrink-0"
|
||
onClick={() => setShowFilePanel(true)}
|
||
>
|
||
<FolderOpen className="h-3.5 w-3.5" />
|
||
</Button>
|
||
)}
|
||
<div className="min-w-0">
|
||
<h4 className="text-sm font-medium font-mono truncate">{selectedOrEntryFile}</h4>
|
||
<p className="text-xs text-muted-foreground">
|
||
{selectedFileExists
|
||
? selectedFileSummary?.deprecated
|
||
? "Deprecated virtual file"
|
||
: `${selectedFileDetail?.language ?? "text"} file`
|
||
: "New file in this bundle"}
|
||
</p>
|
||
</div>
|
||
</div>
|
||
<div className="flex items-center gap-2">
|
||
{!fileLoading && (
|
||
<CopyText
|
||
text={displayValue}
|
||
ariaLabel="Copy instructions file as markdown"
|
||
title="Copy as markdown"
|
||
copiedLabel="Copied"
|
||
className="inline-flex h-8 w-8 items-center justify-center rounded-md border border-border text-muted-foreground hover:bg-accent hover:text-foreground"
|
||
>
|
||
<Copy className="h-3.5 w-3.5" />
|
||
</CopyText>
|
||
)}
|
||
{selectedFileExists && !selectedFileSummary?.deprecated && selectedOrEntryFile !== currentEntryFile && (
|
||
<Button
|
||
type="button"
|
||
size="sm"
|
||
variant="outline"
|
||
onClick={() => {
|
||
if (confirm(`Delete ${selectedOrEntryFile}?`)) {
|
||
deleteFile.mutate(selectedOrEntryFile, {
|
||
onSuccess: () => {
|
||
setSelectedFile(currentEntryFile);
|
||
setDraft(null);
|
||
},
|
||
});
|
||
}
|
||
}}
|
||
disabled={deleteFile.isPending}
|
||
>
|
||
Delete
|
||
</Button>
|
||
)}
|
||
</div>
|
||
</div>
|
||
|
||
{selectedFileExists && fileLoading && !selectedFileDetail ? (
|
||
<PromptEditorSkeleton />
|
||
) : useMarkdownEditor ? (
|
||
<MarkdownEditor
|
||
key={selectedOrEntryFile}
|
||
value={displayValue}
|
||
onChange={(value) => setDraft(value ?? "")}
|
||
placeholder="# Agent instructions"
|
||
className="min-w-0 overflow-hidden"
|
||
contentClassName="min-h-(--sz-420px) max-w-full break-words text-sm leading-7"
|
||
imageUploadHandler={async (file) => {
|
||
const namespace = `agents/${agent.id}/instructions/${selectedOrEntryFile.replaceAll("/", "-")}`;
|
||
const asset = await uploadMarkdownImage.mutateAsync({ file, namespace });
|
||
return asset.contentPath;
|
||
}}
|
||
/>
|
||
) : (
|
||
<textarea
|
||
value={displayValue}
|
||
onChange={(event) => setDraft(event.target.value)}
|
||
className="min-h-(--sz-420px) w-full min-w-0 rounded-md border border-border bg-transparent px-3 py-2 font-mono text-sm outline-none"
|
||
placeholder="File contents"
|
||
/>
|
||
)}
|
||
</div>
|
||
</div>
|
||
|
||
</div>
|
||
);
|
||
}
|
||
|
||
function PromptsTabSkeleton() {
|
||
return (
|
||
<div className="max-w-5xl space-y-4">
|
||
<div className="rounded-lg border border-border p-4 space-y-4">
|
||
<div className="flex items-start justify-between gap-4">
|
||
<div className="space-y-2">
|
||
<Skeleton className="h-4 w-40" />
|
||
<Skeleton className="h-4 w-(--sz-30rem) max-w-full" />
|
||
</div>
|
||
<Skeleton className="h-4 w-16" />
|
||
</div>
|
||
<div className="grid gap-3 md:grid-cols-3">
|
||
{Array.from({ length: 3 }).map((_, index) => (
|
||
<div key={index} className="space-y-2">
|
||
<Skeleton className="h-3 w-20" />
|
||
<Skeleton className="h-10 w-full" />
|
||
</div>
|
||
))}
|
||
</div>
|
||
</div>
|
||
<div className="grid gap-4 lg:grid-cols-(--gtc-19)">
|
||
<div className="rounded-lg border border-border p-3 space-y-3">
|
||
<div className="flex items-center justify-between">
|
||
<Skeleton className="h-4 w-12" />
|
||
<Skeleton className="h-8 w-16" />
|
||
</div>
|
||
<Skeleton className="h-10 w-full" />
|
||
<div className="space-y-2">
|
||
{Array.from({ length: 5 }).map((_, index) => (
|
||
<Skeleton key={index} className="h-9 w-full rounded-none" />
|
||
))}
|
||
</div>
|
||
</div>
|
||
<div className="rounded-lg border border-border p-4 space-y-3">
|
||
<div className="space-y-2">
|
||
<Skeleton className="h-4 w-48" />
|
||
<Skeleton className="h-3 w-28" />
|
||
</div>
|
||
<PromptEditorSkeleton />
|
||
</div>
|
||
</div>
|
||
</div>
|
||
);
|
||
}
|
||
|
||
function PromptEditorSkeleton() {
|
||
return (
|
||
<div className="space-y-3">
|
||
<Skeleton className="h-10 w-full" />
|
||
<Skeleton className="h-(--sz-420px) w-full" />
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Runs Tab ---- */
|
||
|
||
function RunListItem({ run, isSelected, agentId }: { run: HeartbeatRun; isSelected: boolean; agentId: string }) {
|
||
const statusInfo = runStatusIcons[run.status] ?? { icon: Clock, color: "text-neutral-400" };
|
||
const StatusIcon = statusInfo.icon;
|
||
const metrics = runMetrics(run);
|
||
const summary = run.resultJson
|
||
? String((run.resultJson as Record<string, unknown>).summary ?? (run.resultJson as Record<string, unknown>).result ?? "")
|
||
: run.error ?? "";
|
||
const sourceResolvedFold = readSourceResolvedWatchdogFold(run.resultJson);
|
||
|
||
return (
|
||
<Link
|
||
to={isSelected ? `/agents/${agentId}/runs` : `/agents/${agentId}/runs/${run.id}`}
|
||
className={cn(
|
||
"flex flex-col gap-1 w-full px-3 py-2.5 text-left border-b border-border last:border-b-0 transition-colors no-underline text-inherit",
|
||
isSelected ? "bg-accent/40" : "hover:bg-accent/20",
|
||
)}
|
||
>
|
||
<div className="flex items-center gap-2">
|
||
<StatusIcon className={cn("h-3.5 w-3.5 shrink-0", statusInfo.color, run.status === "running" && "animate-spin")} />
|
||
<span className="font-mono text-xs text-muted-foreground">
|
||
{run.id.slice(0, 8)}
|
||
</span>
|
||
<Badge variant="ghost" className={cn(
|
||
"px-1.5 text-(length:--text-nano)",
|
||
run.invocationSource === "timer" ? "bg-blue-100 text-blue-700 dark:bg-blue-900/50 dark:text-blue-300"
|
||
: run.invocationSource === "assignment" ? "bg-violet-100 text-violet-700 dark:bg-violet-900/50 dark:text-violet-300"
|
||
: run.invocationSource === "on_demand" ? "bg-cyan-100 text-cyan-700 dark:bg-cyan-900/50 dark:text-cyan-300"
|
||
: "bg-muted text-muted-foreground"
|
||
)}>
|
||
{sourceLabels[run.invocationSource] ?? run.invocationSource}
|
||
</Badge>
|
||
{sourceResolvedFold ? <SourceResolvedFoldBadge showIcon={false} className="shrink-0 text-(length:--text-nano) py-0" /> : null}
|
||
<span className="ml-auto text-(length:--text-micro) text-muted-foreground shrink-0">
|
||
{relativeTime(run.createdAt)}
|
||
</span>
|
||
</div>
|
||
{summary && (
|
||
<span className="text-xs text-muted-foreground truncate pl-5.5">
|
||
{summary.slice(0, 60)}
|
||
</span>
|
||
)}
|
||
{(metrics.totalTokens > 0 || metrics.cost > 0) && (
|
||
<div className="flex items-center gap-2 pl-5.5 text-(length:--text-micro) text-muted-foreground tabular-nums">
|
||
{metrics.totalTokens > 0 && <span>{formatTokens(metrics.totalTokens)} tok</span>}
|
||
{metrics.cost > 0 && <span>${metrics.cost.toFixed(3)}</span>}
|
||
</div>
|
||
)}
|
||
</Link>
|
||
);
|
||
}
|
||
|
||
export function RunsTab({
|
||
runs,
|
||
companyId,
|
||
agentId,
|
||
agentRouteId,
|
||
selectedRunId,
|
||
adapterType,
|
||
adapterConfig,
|
||
}: {
|
||
runs: HeartbeatRun[];
|
||
companyId: string;
|
||
agentId: string;
|
||
agentRouteId: string;
|
||
selectedRunId: string | null;
|
||
adapterType: string;
|
||
adapterConfig: Record<string, unknown>;
|
||
}) {
|
||
const { isMobile } = useSidebar();
|
||
|
||
// Sort by created descending
|
||
const sorted = [...runs].sort(
|
||
(a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
|
||
);
|
||
|
||
// On mobile, don't auto-select so the list shows first; on desktop, auto-select latest
|
||
const effectiveRunId = isMobile ? selectedRunId : (selectedRunId ?? sorted[0]?.id ?? null);
|
||
const selection = useSelectedHeartbeatRun(sorted, effectiveRunId, companyId, agentId);
|
||
const selectedRun = selection.run;
|
||
if (selectedRunId && !selectedRun) {
|
||
if (selection.loading) return <p className="text-sm text-muted-foreground">Loading run…</p>;
|
||
return <div role="alert">
|
||
<p className="text-sm text-destructive">{selection.error instanceof Error ? selection.error.message : "This run is unavailable for this agent."}</p>
|
||
{selection.error && <Button variant="outline" onClick={() => { void selection.retry(); }}>Try again</Button>}
|
||
</div>;
|
||
}
|
||
if (runs.length === 0 && !selectedRun) return <p className="text-sm text-muted-foreground">No runs yet.</p>;
|
||
|
||
// Mobile: show either run list OR run detail with back button
|
||
if (isMobile) {
|
||
if (selectedRun) {
|
||
return (
|
||
<div className="space-y-3 min-w-0 overflow-x-hidden">
|
||
<Link
|
||
to={`/agents/${agentRouteId}/runs`}
|
||
className="flex items-center gap-1.5 text-sm text-muted-foreground hover:text-foreground transition-colors no-underline"
|
||
>
|
||
<ArrowLeft className="h-3.5 w-3.5" />
|
||
Back to runs
|
||
</Link>
|
||
<RunDetail key={selectedRun.id} run={selectedRun} agentRouteId={agentRouteId} adapterType={adapterType} adapterConfig={adapterConfig} />
|
||
</div>
|
||
);
|
||
}
|
||
return (
|
||
<div className="border border-border rounded-lg overflow-x-hidden">
|
||
{sorted.map((run) => (
|
||
<RunListItem key={run.id} run={run} isSelected={false} agentId={agentRouteId} />
|
||
))}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
// Desktop: side-by-side layout
|
||
return (
|
||
<div className="flex gap-0">
|
||
{/* Left: run list — border stretches full height, content sticks */}
|
||
<div className={cn(
|
||
"shrink-0 border border-border rounded-lg",
|
||
selectedRun ? "w-72" : "w-full",
|
||
)}>
|
||
<div className="sticky top-4 overflow-y-auto" style={{ maxHeight: "calc(100vh - 2rem)" }}>
|
||
{sorted.map((run) => (
|
||
<RunListItem key={run.id} run={run} isSelected={run.id === effectiveRunId} agentId={agentRouteId} />
|
||
))}
|
||
</div>
|
||
</div>
|
||
|
||
{/* Right: run detail — natural height, page scrolls */}
|
||
{selectedRun && (
|
||
<div className="flex-1 min-w-0 pl-4">
|
||
<RunDetail key={selectedRun.id} run={selectedRun} agentRouteId={agentRouteId} adapterType={adapterType} adapterConfig={adapterConfig} />
|
||
</div>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Run Detail (expanded) ---- */
|
||
|
||
function RunDetail({ run: initialRun, agentRouteId, adapterType, adapterConfig }: { run: HeartbeatRun; agentRouteId: string; adapterType: string; adapterConfig: Record<string, unknown> }) {
|
||
const queryClient = useQueryClient();
|
||
const navigate = useNavigate();
|
||
const { data: hydratedRun } = useQuery({
|
||
queryKey: queryKeys.runDetail(initialRun.id),
|
||
queryFn: () => heartbeatsApi.get(initialRun.id),
|
||
enabled: Boolean(initialRun.id),
|
||
refetchInterval: (query) => runDetailRefetchIntervalMs(
|
||
(query.state.data ?? initialRun).status,
|
||
),
|
||
});
|
||
const run = hydratedRun ?? initialRun;
|
||
const metrics = runMetrics(run);
|
||
const { data: userDirectory } = useQuery({
|
||
queryKey: queryKeys.access.companyUserDirectory(run.companyId),
|
||
queryFn: () => accessApi.listUserDirectory(run.companyId),
|
||
enabled: Boolean(run.companyId && run.responsibleUserId),
|
||
});
|
||
const responsibleUserName = useMemo(() => {
|
||
if (!run.responsibleUserId) return null;
|
||
const entry = userDirectory?.users.find(
|
||
(candidate) => candidate.principalId === run.responsibleUserId,
|
||
);
|
||
return entry?.user?.name ?? entry?.user?.email ?? null;
|
||
}, [run.responsibleUserId, userDirectory]);
|
||
const responsibleDenialCode = isResponsibleUserDenialCode(run.errorCode) ? run.errorCode : null;
|
||
const [sessionOpen, setSessionOpen] = useState(false);
|
||
const [claudeLoginResult, setClaudeLoginResult] = useState<ClaudeLoginResult | null>(null);
|
||
|
||
useEffect(() => {
|
||
setClaudeLoginResult(null);
|
||
}, [run.id]);
|
||
|
||
const cancelRun = useMutation({
|
||
mutationFn: () => {
|
||
if (run.status !== "failed") return heartbeatsApi.cancel(run.id);
|
||
return stopFailedNativeRun(initialRun.id, initialRun.companyId);
|
||
},
|
||
onSettled: () => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.runDetail(run.id) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(run.companyId, run.agentId) });
|
||
},
|
||
});
|
||
const canResumeLostRun = run.errorCode === "process_lost" && run.status === "failed";
|
||
const resumePayload = useMemo(() => {
|
||
const payload: Record<string, unknown> = {
|
||
resumeFromRunId: run.id,
|
||
};
|
||
const context = asRecord(run.contextSnapshot);
|
||
if (!context) return payload;
|
||
const issueId = asNonEmptyString(context.issueId);
|
||
const taskId = asNonEmptyString(context.taskId);
|
||
const taskKey = asNonEmptyString(context.taskKey);
|
||
const commentId = asNonEmptyString(context.wakeCommentId) ?? asNonEmptyString(context.commentId);
|
||
if (issueId) payload.issueId = issueId;
|
||
if (taskId) payload.taskId = taskId;
|
||
if (taskKey) payload.taskKey = taskKey;
|
||
if (commentId) payload.commentId = commentId;
|
||
return payload;
|
||
}, [run.contextSnapshot, run.id]);
|
||
const resumeRun = useMutation({
|
||
mutationFn: async () => {
|
||
const result = await agentsApi.wakeup(run.agentId, {
|
||
source: "on_demand",
|
||
triggerDetail: "manual",
|
||
reason: "resume_process_lost_run",
|
||
payload: resumePayload,
|
||
}, run.companyId);
|
||
if (!("id" in result)) {
|
||
throw new Error(result.message ?? "Resume request was skipped.");
|
||
}
|
||
return result;
|
||
},
|
||
onSuccess: (resumedRun) => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(run.companyId, run.agentId) });
|
||
navigate(`/agents/${agentRouteId}/runs/${resumedRun.id}`);
|
||
},
|
||
});
|
||
|
||
const canRetryRun = run.status === "failed" || run.status === "timed_out";
|
||
const retryRun = useMutation({
|
||
mutationFn: async () => {
|
||
return agentsApi.retryFailedRun(run.agentId, run.id, run.companyId);
|
||
},
|
||
onSuccess: (newRun) => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.heartbeats(run.companyId, run.agentId) });
|
||
if (newRun.runId)
|
||
navigate(`/agents/${agentRouteId}/runs/${newRun.runId}`);
|
||
else if (newRun.issueId) navigate(`/issues/${newRun.issueId}`);
|
||
},
|
||
});
|
||
|
||
const { data: touchedIssues } = useQuery({
|
||
queryKey: queryKeys.runIssues(run.id),
|
||
queryFn: () => activityApi.issuesForRun(run.id),
|
||
});
|
||
const touchedIssueIds = useMemo(
|
||
() => Array.from(new Set((touchedIssues ?? []).map((issue) => issue.issueId))),
|
||
[touchedIssues],
|
||
);
|
||
|
||
const clearSessionsForTouchedIssues = useMutation({
|
||
mutationFn: async () => {
|
||
if (touchedIssueIds.length === 0) return 0;
|
||
await Promise.all(touchedIssueIds.map((issueId) => agentsApi.resetSession(run.agentId, issueId, run.companyId)));
|
||
return touchedIssueIds.length;
|
||
},
|
||
onSuccess: () => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.runtimeState(run.agentId) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.taskSessions(run.agentId) });
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.runIssues(run.id) });
|
||
},
|
||
});
|
||
|
||
const runClaudeLogin = useMutation({
|
||
mutationFn: () => agentsApi.loginWithClaude(run.agentId, run.companyId),
|
||
onSuccess: (data) => {
|
||
setClaudeLoginResult(data);
|
||
},
|
||
});
|
||
|
||
const isRunning = run.status === "running" && !!run.startedAt && !run.finishedAt;
|
||
const [elapsedSec, setElapsedSec] = useState<number>(() => {
|
||
if (!run.startedAt) return 0;
|
||
return Math.max(0, Math.round((Date.now() - new Date(run.startedAt).getTime()) / 1000));
|
||
});
|
||
|
||
useEffect(() => {
|
||
if (!isRunning || !run.startedAt) return;
|
||
const startMs = new Date(run.startedAt).getTime();
|
||
setElapsedSec(Math.max(0, Math.round((Date.now() - startMs) / 1000)));
|
||
const id = setInterval(() => {
|
||
setElapsedSec(Math.max(0, Math.round((Date.now() - startMs) / 1000)));
|
||
}, 1000);
|
||
return () => clearInterval(id);
|
||
}, [isRunning, run.startedAt]);
|
||
|
||
const timeFormat: Intl.DateTimeFormatOptions = { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false };
|
||
const startTime = run.startedAt ? new Date(run.startedAt).toLocaleTimeString("en-US", timeFormat) : null;
|
||
const endTime = run.finishedAt ? new Date(run.finishedAt).toLocaleTimeString("en-US", timeFormat) : null;
|
||
const durationSec = run.startedAt && run.finishedAt
|
||
? Math.round((new Date(run.finishedAt).getTime() - new Date(run.startedAt).getTime()) / 1000)
|
||
: null;
|
||
const displayDurationSec = durationSec ?? (isRunning ? elapsedSec : null);
|
||
const hasMetrics = metrics.input > 0 || metrics.output > 0 || metrics.cached > 0 || metrics.cost > 0;
|
||
const hasSession = !!(run.sessionIdBefore || run.sessionIdAfter);
|
||
const sessionChanged = run.sessionIdBefore && run.sessionIdAfter && run.sessionIdBefore !== run.sessionIdAfter;
|
||
const sessionId = run.sessionIdAfter || run.sessionIdBefore;
|
||
const hasNonZeroExit = run.exitCode !== null && run.exitCode !== 0;
|
||
const retryState = describeRunRetryState(run);
|
||
|
||
return (
|
||
<div className="space-y-4 min-w-0">
|
||
{/* Workspace-validation recovery: surfaces the recovery card when this run was declined over a
|
||
git workspace it could not validate, wired to the same reconcile / repair / re-issue /
|
||
break-glass handlers as the task detail page. */}
|
||
<RunWorkspaceRecoverySurface run={run} />
|
||
{/* Run summary card */}
|
||
<div className="border border-border rounded-lg overflow-hidden">
|
||
<div className="flex flex-col sm:flex-row">
|
||
{/* Left column: status + timing */}
|
||
<div className="flex-1 p-4 space-y-3">
|
||
<div className="flex items-center gap-2">
|
||
<StatusBadge status={run.status} />
|
||
{(run.status === "running" || run.status === "queued" || (run.status === "failed" && run.driverKind !== "grok_bot_mcp" && run.execution?.canStop === true)) && (
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
className="text-destructive hover:text-destructive text-xs h-6 px-2"
|
||
onClick={() => cancelRun.mutate()}
|
||
disabled={cancelRun.isPending}
|
||
>
|
||
{runCancellationLabel({ isFailed: run.status === "failed", isPending: cancelRun.isPending })}
|
||
</Button>
|
||
)}
|
||
{canResumeLostRun && (
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
className="text-xs h-6 px-2"
|
||
onClick={() => resumeRun.mutate()}
|
||
disabled={resumeRun.isPending}
|
||
>
|
||
<RotateCcw className="h-3.5 w-3.5 mr-1" />
|
||
{resumeRun.isPending ? "Resuming…" : "Resume"}
|
||
</Button>
|
||
)}
|
||
{canRetryRun && !canResumeLostRun && (
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
className="text-xs h-6 px-2"
|
||
onClick={() => retryRun.mutate()}
|
||
disabled={retryRun.isPending}
|
||
>
|
||
<RotateCcw className="h-3.5 w-3.5 mr-1" />
|
||
{retryRun.isPending ? "Retrying…" : "Retry"}
|
||
</Button>
|
||
)}
|
||
</div>
|
||
{/* Adapter type · provider · model */}
|
||
{(() => {
|
||
const displayProvider = metrics.provider
|
||
?? asNonEmptyString(adapterConfig?.provider);
|
||
const displayModel = metrics.model
|
||
?? asNonEmptyString(adapterConfig?.model);
|
||
if (!adapterType && !displayProvider && !displayModel) return null;
|
||
return (
|
||
<div className="text-(length:--text-micro) text-muted-foreground font-mono flex items-center gap-1.5 flex-wrap">
|
||
{adapterType && (
|
||
<span className="bg-muted rounded px-1.5 py-0.5 text-(length:--text-nano) font-medium uppercase tracking-wide">{adapterType.replace(/_/g, " ")}</span>
|
||
)}
|
||
{displayProvider && displayModel && (
|
||
<span>{displayProvider}/{displayModel}</span>
|
||
)}
|
||
{!displayProvider && displayModel && (
|
||
<span>{displayModel}</span>
|
||
)}
|
||
</div>
|
||
);
|
||
})()}
|
||
{run.responsibleUserId && (
|
||
<div
|
||
data-testid="run-detail-on-behalf-of"
|
||
className="text-xs text-muted-foreground"
|
||
>
|
||
On behalf of{" "}
|
||
<span className="text-foreground">
|
||
{responsibleUserName ?? responsibleUserLabel(null)}
|
||
</span>
|
||
</div>
|
||
)}
|
||
{cancelRun.error && (
|
||
<div className="text-xs text-destructive" role="alert">
|
||
{cancelRun.error instanceof Error ? cancelRun.error.message : "Failed to stop run"}
|
||
</div>
|
||
)}
|
||
{resumeRun.isError && ( // query-error-ok: mutation result, not a query
|
||
<div className="text-xs text-destructive">
|
||
{resumeRun.error instanceof Error ? resumeRun.error.message : "Failed to resume run"}
|
||
</div>
|
||
)}
|
||
{retryRun.isError && ( // query-error-ok: mutation result, not a query
|
||
<div className="text-xs text-destructive">
|
||
{retryRun.error instanceof Error ? retryRun.error.message : "Failed to retry run"}
|
||
</div>
|
||
)}
|
||
{startTime && (
|
||
<div className="space-y-0.5">
|
||
<div className="text-sm font-mono">
|
||
{startTime}
|
||
{endTime && <span className="text-muted-foreground"> → </span>}
|
||
{endTime}
|
||
</div>
|
||
<div className="text-(length:--text-micro) text-muted-foreground">
|
||
{relativeTime(run.startedAt!)}
|
||
{run.finishedAt && <> → {relativeTime(run.finishedAt)}</>}
|
||
</div>
|
||
{displayDurationSec !== null && (
|
||
<div className="text-xs text-muted-foreground">
|
||
Duration: {displayDurationSec >= 60 ? `${Math.floor(displayDurationSec / 60)}m ${displayDurationSec % 60}s` : `${displayDurationSec}s`}
|
||
</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
{run.error && (
|
||
<div className="text-xs">
|
||
<span className="text-red-600 dark:text-red-400">{run.error}</span>
|
||
{run.errorCode && <span className="text-muted-foreground ml-1">({run.errorCode})</span>}
|
||
</div>
|
||
)}
|
||
{run.errorCode === "claude_auth_required" && adapterType === "claude_local" && (
|
||
<div className="space-y-2">
|
||
<Button
|
||
variant="outline"
|
||
size="sm"
|
||
className="h-7 px-2 text-xs"
|
||
onClick={() => runClaudeLogin.mutate()}
|
||
disabled={runClaudeLogin.isPending}
|
||
>
|
||
{runClaudeLogin.isPending ? "Running claude login..." : "Login to Claude Code"}
|
||
</Button>
|
||
{runClaudeLogin.isError && ( // query-error-ok: mutation result, not a query
|
||
<p className="text-xs text-destructive">
|
||
{runClaudeLogin.error instanceof Error
|
||
? runClaudeLogin.error.message
|
||
: "Failed to run Claude login"}
|
||
</p>
|
||
)}
|
||
{claudeLoginResult?.loginUrl && (
|
||
<p className="text-xs">
|
||
Login URL:
|
||
<a
|
||
href={claudeLoginResult.loginUrl}
|
||
className="text-blue-600 underline underline-offset-2 ml-1 break-all dark:text-blue-400"
|
||
target="_blank"
|
||
rel="noreferrer"
|
||
>
|
||
{claudeLoginResult.loginUrl}
|
||
</a>
|
||
</p>
|
||
)}
|
||
{claudeLoginResult && (
|
||
<>
|
||
{!!claudeLoginResult.stdout && (
|
||
<pre className="bg-neutral-100 dark:bg-neutral-950 rounded-md p-3 text-xs font-mono text-foreground overflow-x-auto whitespace-pre-wrap">
|
||
{claudeLoginResult.stdout}
|
||
</pre>
|
||
)}
|
||
{!!claudeLoginResult.stderr && (
|
||
<pre className="bg-neutral-100 dark:bg-neutral-950 rounded-md p-3 text-xs font-mono text-red-700 dark:text-red-300 overflow-x-auto whitespace-pre-wrap">
|
||
{claudeLoginResult.stderr}
|
||
</pre>
|
||
)}
|
||
</>
|
||
)}
|
||
</div>
|
||
)}
|
||
{responsibleDenialCode && (
|
||
<ResponsibleUserDenialNotice
|
||
code={responsibleDenialCode}
|
||
userName={responsibleUserName}
|
||
/>
|
||
)}
|
||
{hasNonZeroExit && (
|
||
<div className="text-xs text-red-600 dark:text-red-400">
|
||
Exit code {run.exitCode}
|
||
{run.signal && <span className="text-muted-foreground ml-1">(signal: {run.signal})</span>}
|
||
</div>
|
||
)}
|
||
{retryState && (
|
||
<div className="rounded-md border border-border/70 bg-accent/20 px-3 py-2 text-xs leading-5">
|
||
<div className="flex flex-wrap items-center gap-2">
|
||
<span
|
||
className={cn(
|
||
"rounded-md border px-1.5 py-0.5 text-(length:--text-micro) font-medium",
|
||
retryState.tone,
|
||
)}
|
||
>
|
||
{retryState.badgeLabel}
|
||
</span>
|
||
{retryState.retryOfRunId ? (
|
||
<Link
|
||
to={`/agents/${agentRouteId}/runs/${retryState.retryOfRunId}`}
|
||
className="font-mono text-foreground hover:underline"
|
||
>
|
||
{retryState.retryOfRunId.slice(0, 8)}
|
||
</Link>
|
||
) : null}
|
||
</div>
|
||
{retryState.detail ? <p className="mt-2 text-muted-foreground">{retryState.detail}</p> : null}
|
||
{retryState.secondary ? <p className="text-muted-foreground">{retryState.secondary}</p> : null}
|
||
</div>
|
||
)}
|
||
</div>
|
||
|
||
{/* Right column: metrics */}
|
||
{hasMetrics && (
|
||
<div className="border-t sm:border-t-0 sm:border-l border-border p-4 grid grid-cols-2 gap-x-4 sm:gap-x-8 gap-y-3 content-center tabular-nums">
|
||
<div>
|
||
<div className="text-xs text-muted-foreground">Input</div>
|
||
<div className="text-sm font-medium font-mono">{formatTokens(metrics.input)}</div>
|
||
</div>
|
||
<div>
|
||
<div className="text-xs text-muted-foreground">Output</div>
|
||
<div className="text-sm font-medium font-mono">{formatTokens(metrics.output)}</div>
|
||
</div>
|
||
<div>
|
||
<div className="text-xs text-muted-foreground">Cached</div>
|
||
<div className="text-sm font-medium font-mono">{formatTokens(metrics.cached)}</div>
|
||
</div>
|
||
<div>
|
||
<div className="text-xs text-muted-foreground">Cost</div>
|
||
<div className="text-sm font-medium font-mono">{metrics.cost > 0 ? `$${metrics.cost.toFixed(4)}` : "-"}</div>
|
||
</div>
|
||
</div>
|
||
)}
|
||
</div>
|
||
|
||
{/* Collapsible session row */}
|
||
{hasSession && (
|
||
<div className="border-t border-border">
|
||
<button
|
||
className="flex items-center gap-1.5 w-full px-4 py-2 text-xs text-muted-foreground hover:text-foreground transition-colors"
|
||
onClick={() => setSessionOpen((v) => !v)}
|
||
>
|
||
<ChevronRight className={cn("h-3 w-3 transition-transform", sessionOpen && "rotate-90")} />
|
||
Session
|
||
{sessionChanged && <span className="text-yellow-400 ml-1">(changed)</span>}
|
||
</button>
|
||
{sessionOpen && (
|
||
<div className="px-4 pb-3 space-y-1 text-xs">
|
||
{run.sessionIdBefore && (
|
||
<div className="flex items-center gap-2">
|
||
<span className="text-muted-foreground w-12">{sessionChanged ? "Before" : "ID"}</span>
|
||
<CopyText text={run.sessionIdBefore} className="font-mono" />
|
||
</div>
|
||
)}
|
||
{sessionChanged && run.sessionIdAfter && (
|
||
<div className="flex items-center gap-2">
|
||
<span className="text-muted-foreground w-12">After</span>
|
||
<CopyText text={run.sessionIdAfter} className="font-mono" />
|
||
</div>
|
||
)}
|
||
{touchedIssueIds.length > 0 && (
|
||
<div className="pt-1">
|
||
<button
|
||
type="button"
|
||
className="text-(length:--text-micro) text-muted-foreground underline underline-offset-2 hover:text-foreground disabled:opacity-60"
|
||
disabled={clearSessionsForTouchedIssues.isPending}
|
||
onClick={() => {
|
||
const issueCount = touchedIssueIds.length;
|
||
const confirmed = window.confirm(
|
||
`Clear session for ${issueCount} issue${issueCount === 1 ? "" : "s"} touched by this run?`,
|
||
);
|
||
if (!confirmed) return;
|
||
clearSessionsForTouchedIssues.mutate();
|
||
}}
|
||
>
|
||
{clearSessionsForTouchedIssues.isPending
|
||
? "clearing session..."
|
||
: "clear session for these tasks"}
|
||
</button>
|
||
{clearSessionsForTouchedIssues.isError && ( // query-error-ok: mutation result, not a query
|
||
<p className="text-(length:--text-micro) text-destructive mt-1">
|
||
{clearSessionsForTouchedIssues.error instanceof Error
|
||
? clearSessionsForTouchedIssues.error.message
|
||
: "Failed to clear sessions"}
|
||
</p>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
</div>
|
||
|
||
{/* Issues touched by this run */}
|
||
{touchedIssues && touchedIssues.length > 0 && (
|
||
<div className="space-y-2">
|
||
<span className="text-xs font-medium text-muted-foreground">Tasks Touched ({touchedIssues.length})</span>
|
||
<div className="border border-border rounded-lg divide-y divide-border">
|
||
{touchedIssues.map((issue) => (
|
||
<Link
|
||
key={issue.issueId}
|
||
to={`/issues/${issue.identifier ?? issue.issueId}`}
|
||
className="flex items-center justify-between w-full px-3 py-2 text-xs hover:bg-accent/20 transition-colors text-left no-underline text-inherit"
|
||
>
|
||
<div className="flex items-center gap-2 min-w-0">
|
||
<StatusBadge status={issue.status} />
|
||
<span className="truncate">{issue.title}</span>
|
||
</div>
|
||
<span className="font-mono text-muted-foreground shrink-0 ml-2">{issue.identifier ?? issue.issueId.slice(0, 8)}</span>
|
||
</Link>
|
||
))}
|
||
</div>
|
||
</div>
|
||
)}
|
||
|
||
{/* stderr excerpt for failed runs */}
|
||
{run.stderrExcerpt && (
|
||
<div className="space-y-1">
|
||
<span className="text-xs font-medium text-red-600 dark:text-red-400">stderr</span>
|
||
<pre className="bg-neutral-100 dark:bg-neutral-950 rounded-md p-3 text-xs font-mono text-red-700 dark:text-red-300 overflow-x-auto whitespace-pre-wrap">{run.stderrExcerpt}</pre>
|
||
</div>
|
||
)}
|
||
|
||
{/* stdout excerpt when no log is available */}
|
||
{run.stdoutExcerpt && !run.logRef && (
|
||
<div className="space-y-1">
|
||
<span className="text-xs font-medium text-muted-foreground">stdout</span>
|
||
<pre className="bg-neutral-100 dark:bg-neutral-950 rounded-md p-3 text-xs font-mono text-foreground overflow-x-auto whitespace-pre-wrap">{run.stdoutExcerpt}</pre>
|
||
</div>
|
||
)}
|
||
|
||
{(() => {
|
||
const fold = readSourceResolvedWatchdogFold(run.resultJson);
|
||
if (!fold) return null;
|
||
if (run.status === "failed" || run.status === "timed_out") return null;
|
||
return <SourceResolvedFoldCallout fold={fold} finalizedAt={run.finishedAt} />;
|
||
})()}
|
||
|
||
{/* Log viewer */}
|
||
<LogViewer run={run} adapterType={adapterType} />
|
||
<ScrollToBottom />
|
||
</div>
|
||
);
|
||
}
|
||
|
||
/* ---- Keys Tab ---- */
|
||
|
||
function KeysTab({ agentId, companyId }: { agentId: string; companyId?: string }) {
|
||
const queryClient = useQueryClient();
|
||
const { pushToast } = useToastActions();
|
||
const [newKeyName, setNewKeyName] = useState("");
|
||
const [newToken, setNewToken] = useState<string | null>(null);
|
||
const [tokenVisible, setTokenVisible] = useState(false);
|
||
const [copied, setCopied] = useState(false);
|
||
|
||
const { data: keys, isLoading } = useQuery({
|
||
queryKey: queryKeys.agents.keys(agentId),
|
||
queryFn: () => agentsApi.listKeys(agentId, companyId),
|
||
});
|
||
|
||
const createKey = useMutation({
|
||
mutationFn: () => agentsApi.createKey(agentId, newKeyName.trim() || "Default", companyId),
|
||
onSuccess: (data) => {
|
||
setNewToken(data.token);
|
||
setTokenVisible(true);
|
||
setNewKeyName("");
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.keys(agentId) });
|
||
},
|
||
});
|
||
|
||
const revokeKey = useMutation({
|
||
mutationFn: (keyId: string) => agentsApi.revokeKey(agentId, keyId, companyId),
|
||
onSuccess: () => {
|
||
queryClient.invalidateQueries({ queryKey: queryKeys.agents.keys(agentId) });
|
||
},
|
||
});
|
||
|
||
function copyToken() {
|
||
if (!newToken) return;
|
||
void copyTextToClipboard(newToken)
|
||
.then(() => {
|
||
setCopied(true);
|
||
setTimeout(() => setCopied(false), 2000);
|
||
})
|
||
.catch(() => {
|
||
pushToast({ title: "Copy failed", body: "Clipboard access is unavailable.", tone: "error" });
|
||
});
|
||
}
|
||
|
||
const activeKeys = (keys ?? []).filter((k: AgentKey) => !k.revokedAt);
|
||
const revokedKeys = (keys ?? []).filter((k: AgentKey) => k.revokedAt);
|
||
|
||
return (
|
||
<div className="space-y-6">
|
||
{/* New token banner */}
|
||
{newToken && (
|
||
<div className="border border-yellow-300 dark:border-yellow-600/40 bg-yellow-50 dark:bg-yellow-500/5 rounded-lg p-4 space-y-2">
|
||
<p className="text-sm font-medium text-yellow-700 dark:text-yellow-400">
|
||
API key created — copy it now, it will not be shown again.
|
||
</p>
|
||
<div className="flex items-center gap-2">
|
||
<code className="flex-1 bg-neutral-100 dark:bg-neutral-950 rounded px-3 py-1.5 text-xs font-mono text-green-700 dark:text-green-300 truncate">
|
||
{tokenVisible ? newToken : newToken.replace(/./g, "•")}
|
||
</code>
|
||
<Button
|
||
variant="ghost"
|
||
size="icon-sm"
|
||
onClick={() => setTokenVisible((v) => !v)}
|
||
title={tokenVisible ? "Hide" : "Show"}
|
||
>
|
||
{tokenVisible ? <EyeOff className="h-3.5 w-3.5" /> : <Eye className="h-3.5 w-3.5" />}
|
||
</Button>
|
||
<Button
|
||
variant="ghost"
|
||
size="icon-sm"
|
||
onClick={copyToken}
|
||
title="Copy"
|
||
>
|
||
<Copy className="h-3.5 w-3.5" />
|
||
</Button>
|
||
{copied && <span className="text-xs text-green-400">Copied!</span>}
|
||
</div>
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
className="text-muted-foreground text-xs"
|
||
onClick={() => setNewToken(null)}
|
||
>
|
||
Dismiss
|
||
</Button>
|
||
</div>
|
||
)}
|
||
|
||
{/* Create new key */}
|
||
<div className="border border-border rounded-lg p-4 space-y-3">
|
||
<h3 className="text-xs font-medium text-muted-foreground flex items-center gap-2">
|
||
<Key className="h-3.5 w-3.5" />
|
||
Create API Key
|
||
</h3>
|
||
<p className="text-xs text-muted-foreground">
|
||
API keys allow this agent to authenticate calls to the Paperclip server.
|
||
</p>
|
||
<div className="flex items-center gap-2">
|
||
<Input
|
||
placeholder="Key name (e.g. production)"
|
||
value={newKeyName}
|
||
onChange={(e) => setNewKeyName(e.target.value)}
|
||
className="h-8 text-sm"
|
||
onKeyDown={(e) => {
|
||
if (e.key === "Enter") createKey.mutate();
|
||
}}
|
||
/>
|
||
<Button
|
||
size="sm"
|
||
onClick={() => createKey.mutate()}
|
||
disabled={createKey.isPending}
|
||
>
|
||
<Plus className="h-3.5 w-3.5 mr-1" />
|
||
Create
|
||
</Button>
|
||
</div>
|
||
</div>
|
||
|
||
{/* Active keys */}
|
||
{isLoading && <p className="text-sm text-muted-foreground">Loading keys...</p>}
|
||
|
||
{!isLoading && activeKeys.length === 0 && !newToken && (
|
||
<p className="text-sm text-muted-foreground">No active API keys.</p>
|
||
)}
|
||
|
||
{activeKeys.length > 0 && (
|
||
<div>
|
||
<h3 className="text-xs font-medium text-muted-foreground mb-2">
|
||
Active Keys
|
||
</h3>
|
||
<div className="border border-border rounded-lg divide-y divide-border">
|
||
{activeKeys.map((key: AgentKey) => (
|
||
<div key={key.id} className="flex items-center justify-between px-4 py-2.5">
|
||
<div>
|
||
<span className="text-sm font-medium">{key.name}</span>
|
||
<span className="text-xs text-muted-foreground ml-3">
|
||
Created {formatDate(key.createdAt)}
|
||
</span>
|
||
</div>
|
||
<Button
|
||
variant="ghost"
|
||
size="sm"
|
||
className="text-destructive hover:text-destructive text-xs"
|
||
onClick={() => revokeKey.mutate(key.id)}
|
||
disabled={revokeKey.isPending}
|
||
>
|
||
Revoke
|
||
</Button>
|
||
</div>
|
||
))}
|
||
</div>
|
||
</div>
|
||
)}
|
||
|
||
{/* Revoked keys */}
|
||
{revokedKeys.length > 0 && (
|
||
<div>
|
||
<h3 className="text-xs font-medium text-muted-foreground mb-2">
|
||
Revoked Keys
|
||
</h3>
|
||
<div className="border border-border rounded-lg divide-y divide-border opacity-50">
|
||
{revokedKeys.map((key: AgentKey) => (
|
||
<div key={key.id} className="flex items-center justify-between px-4 py-2.5">
|
||
<div>
|
||
<span className="text-sm line-through">{key.name}</span>
|
||
<span className="text-xs text-muted-foreground ml-3">
|
||
Revoked {key.revokedAt ? formatDate(key.revokedAt) : ""}
|
||
</span>
|
||
</div>
|
||
</div>
|
||
))}
|
||
</div>
|
||
</div>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|