Files
PaperClipAI/ui/src/pages/AgentDetail.production.tsx
T
DottaandClaude Opus 5.5 b184e40108 perf(ui): serve every project list from one includeArchived read (#20395)
## 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>
2026-11-09 17:42:47 -06:00

3442 lines
139 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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">
&middot; {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 &rarr;
</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"> &rarr; </span>}
{endTime}
</div>
<div className="text-(length:--text-micro) text-muted-foreground">
{relativeTime(run.startedAt!)}
{run.finishedAt && <> &rarr; {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>
);
}