mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-20 18:26:40 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work > - Hosted Paperclip Cloud records browser sessions with PostHog session replay > - Replay masked all text and showed only an allowlist of chrome, so most replays showed only stars > - The team cannot see how people use the board, and the allowlist needed a review for each new label > - The owner decided to show text by default and mask only marked customer content, the way PostHog normally works > - This pull request flips the default, removes the allowlist, and marks every surface that can show connected-account content > - The benefit is readable replays, while Google user data and Slack data stay masked ## Linked Issues or Issue Description **Subsystem affected** Hosted Cloud browser analytics: PostHog session replay in the board UI (`ui/src/lib/analytics/`). **Problem or motivation** Replay masked every text node. Only sidebar items and opt-in components showed text. Replays were almost unreadable. Each new label needed an `analyticsChrome` opt-in and an allowlist review. **Proposed solution** Record text as it is. Mask text only inside `ph-mask` (customer content), `ph-no-capture` (secrets, blocked) and editable content. Add `ANALYTICS_MASK_CLASS` to every surface that can show connected-account content (Gmail, Calendar, Drive and Docs, Slack) or other free-form text from agents or customers. **Alternatives considered** Keep "mask all" and grow the allowlist. This needs a review for each label and still hides most of the board. ## What Changed - `privacy.ts`: `ANALYTICS_MASK_TEXT_SELECTOR` is now `.ph-mask, .ph-no-capture, [contenteditable]:not([contenteditable="false"])`. rrweb masks a text node only when its parent or an ancestor matches the selector. Removed `maskReplayText`, `isReplayTextRevealed`, `ANALYTICS_UNMASK_ATTRIBUTE` and `ANALYTICS_UNMASK_PROPS`. - `product-analytics.ts`: removed `maskTextFn`, so rrweb uses its default star masking. `maskAllInputs`, `blockClass`, `maskAttributeFn`, `mask_all_text` and `mask_all_element_attributes` do not change. - Removed the `analyticsChrome` prop from `Button`, `Label`, `TabsTrigger`, `EmptyState` and `SidebarNavItem`, and from all sidebar call sites. - Added `ANALYTICS_MASK_CLASS` to the content element (not the chrome) of these surfaces: - Link preview cards, task quicklook description, external object pills and rows, related-work titles. - Email message cards and email send intents. - Connected account names and email addresses (Browse, Connections, app detail headers, app sidebar, connection choice list, connection access and repair cards), GitHub login and repositories, Slack workspace names, chat channel and linked user labels. - Inbox and decision rows (subject and detail), obligation evidence, Needs You notes and receipts, decision options and result summaries, and the interaction card roots (questions, options, answers, tool action requests, suggested tasks). - Approval payloads, action card input and reason, recovery card headline, evidence and options, run ledger retry detail, interrupt handoff previews. - Run transcripts, run failure details and run events on the agent page. - Search result snippets, toast bodies, voice and call transcripts, case summary, files and fields, attachment previews, artifact previews (text, tables, patches and documents). - Replaced `unmask-allowlist.test.ts` with `replay-masking.test.tsx`. It checks that unmarked chrome records as it is, that each marker masks, that a rendered voice transcript and run transcript mask, that each surface above has the class, and that autocapture records no element text. Updated `privacy.test.ts`, `shared-chrome.test.tsx` and `product-analytics.test.ts`. - Updated `doc/cloud-browser-analytics.md`: new default, marker classes, masked surfaces, and residual risk. ## Verification - `pnpm exec vitest run src/lib/analytics` in `ui/`: 83 tests pass. - Vitest for the 48 test files next to the changed components: 994 tests pass. - `tsc --noEmit -p ui/tsconfig.json`: no new errors (only the existing generated Storybook catalog errors). - `pnpm verify` exits 2 because a doc is a global CI input. Required CI supplies the broad coverage. - Manual: I ran an isolated local instance with a Cloud-like browser analytics config. `PAPERCLIP_POSTHOG_HOST` pointed to a local capture server, not PostHog. I opened a task page in headless Chromium, hovered a GitHub pull request link, and decoded the captured `/s/` replay payloads: - Clear text: sidebar (`New task`, `Chat`, `Tasks`, `Inbox`, `More`), breadcrumb, task title `Quarterly launch checklist`, `REP-1`, the Connectors promo heading and button. - Masked (stars only): the markdown task body, the chat comment, the link preview card (pull request title, author, URL, status), and the company menu. - Marker strings in the body, comment and preview never appeared in clear text in any payload. - The page `<title>` (task title and company name) is in the replay head. This is accepted residual risk. ## Risks - Text that is not marked is now recorded. Task titles, agent names, project names, company names, routine names, artifact and document titles, and activity rows are visible in replays. The owner accepted this. An agent can copy email or Slack text into a task title. - A new surface that shows connected-account content without `ANALYTICS_MASK_CLASS` is recorded until somebody marks it. `replay-masking.test.tsx` and the doc list the marked surfaces. - The masking options in `posthog.init` take precedence over the PostHog project masking settings (posthog-js 1.450), so a dashboard change cannot unmask content. Keep the project settings empty to avoid a console warning. - Some masked areas also mask nearby fixed labels (for example the interaction card buttons). This is safe. - Analytics is off on self-hosted and local installs, so they see no change. > For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and discuss it in `#dev` before opening the PR. Feature PRs that overlap with planned core work may need to be redirected — check the roadmap first. See `CONTRIBUTING.md`. ## Model Used - Claude Opus 5.5 (claude-opus-5-5), Anthropic, with tool use and code execution in Claude Code. ## 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>
1656 lines
71 KiB
TypeScript
1656 lines
71 KiB
TypeScript
import { useWorkspaceIsolationControls } from "@/hooks/useWorkspaceIsolationControls";
|
|
import { useEffect, useMemo, useState } from "react";
|
|
import { Link, Navigate, useLocation, useNavigate, useParams } from "@/lib/router";
|
|
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
|
|
import type { ExecutionWorkspace, Issue, Project, ProjectWorkspace, RoutineListItem, WorkspaceOperation } from "@paperclipai/shared";
|
|
import { Copy, ExternalLink, Loader2, Play, Repeat } from "lucide-react";
|
|
import { QueryErrorState, useQueryView } from "@/components/QueryView";
|
|
import { describeError } from "@/api/errors";
|
|
import { Button } from "@/components/ui/button";
|
|
import { Card, CardContent, CardDescription, CardHeader, CardTitle, CardAction } from "@/components/ui/card";
|
|
import { Input } from "@/components/ui/input";
|
|
import { Separator } from "@/components/ui/separator";
|
|
import { Tabs } from "@/components/ui/tabs";
|
|
import { Textarea } from "@/components/ui/textarea";
|
|
import { CopyText } from "../components/CopyText";
|
|
import { ExecutionWorkspaceCloseDialog } from "../components/ExecutionWorkspaceCloseDialog";
|
|
import { MissingPluginTabPlaceholder } from "../components/MissingPluginTabPlaceholder";
|
|
import { agentsApi } from "../api/agents";
|
|
import { executionWorkspacesApi } from "../api/execution-workspaces";
|
|
import { heartbeatsApi } from "../api/heartbeats";
|
|
import { issuesApi } from "../api/issues";
|
|
import { projectsApi } from "../api/projects";
|
|
import { routinesApi } from "../api/routines";
|
|
import { IssuesList } from "../components/IssuesList";
|
|
import { PageTabBar } from "../components/PageTabBar";
|
|
import { SummarySlotCard } from "../components/SummarySlotCard";
|
|
import { usePublishSharedQueryData, useSharedPollingQuery } from "../hooks/useSharedPolling";
|
|
import { PluginSlotMount, PluginSlotOutlet, usePluginSlots } from "@/plugins/slots";
|
|
import {
|
|
RoutineRunVariablesDialog,
|
|
type RoutineRunDialogSubmitData,
|
|
} from "../components/RoutineRunVariablesDialog";
|
|
import {
|
|
buildWorkspaceRuntimeControlSections,
|
|
buildWorkspaceServiceControlEntries,
|
|
resolveWorkspaceServiceControlRequests,
|
|
WorkspaceRuntimeControls,
|
|
type WorkspaceRuntimeControlRequest,
|
|
} from "../components/WorkspaceRuntimeControls";
|
|
import { WorkspaceServiceControlBar } from "../components/WorkspaceServiceControlBar";
|
|
import { useBreadcrumbs } from "../context/BreadcrumbContext";
|
|
import { useCompany } from "../context/CompanyContext";
|
|
import { useManagedSandboxOnly } from "../hooks/useManagedSandboxOnly";
|
|
import { useToastActions } from "../context/ToastContext";
|
|
import { collectLiveIssueIds } from "../lib/liveIssueIds";
|
|
import { queryKeys } from "../lib/queryKeys";
|
|
import { cn, formatDateTime, issueUrl, projectRouteRef, projectWorkspaceUrl } from "../lib/utils";
|
|
import {
|
|
getWorkspaceSpecificRoutineVariableNames,
|
|
routineHasWorkspaceSpecificVariables,
|
|
sortWorkspaceRoutinesByName,
|
|
} from "../lib/workspace-routines";
|
|
import { useUpdateIssueMutation } from "../hooks/useUpdateIssueMutation";
|
|
import { ANALYTICS_MASK_CLASS } from "@/lib/analytics/privacy";
|
|
|
|
type WorkspaceFormState = {
|
|
name: string;
|
|
cwd: string;
|
|
repoUrl: string;
|
|
baseRef: string;
|
|
branchName: string;
|
|
providerRef: string;
|
|
provisionCommand: string;
|
|
runtimeProvisionCommand: string;
|
|
teardownCommand: string;
|
|
cleanupCommand: string;
|
|
inheritRuntime: boolean;
|
|
workspaceRuntime: string;
|
|
};
|
|
|
|
type ConfiguredRuntimeServicePort = {
|
|
collection: "commands" | "services";
|
|
index: number;
|
|
name: string;
|
|
port: number | null;
|
|
invalidPort: boolean;
|
|
};
|
|
|
|
type ExecutionWorkspaceBaseTab = "services" | "configuration" | "runtime_logs" | "issues" | "routines";
|
|
type ExecutionWorkspacePluginTab = `plugin:${string}`;
|
|
type ExecutionWorkspaceTab = ExecutionWorkspaceBaseTab | ExecutionWorkspacePluginTab;
|
|
type OrderedExecutionWorkspaceTabItem = {
|
|
value: ExecutionWorkspaceTab;
|
|
label: string;
|
|
order: number;
|
|
};
|
|
|
|
const DEFAULT_PLUGIN_DETAIL_TAB_ORDER = 100;
|
|
const EXECUTION_WORKSPACE_BASE_TAB_ITEMS: OrderedExecutionWorkspaceTabItem[] = [
|
|
{ value: "issues", label: "Tasks", order: 10 },
|
|
{ value: "services", label: "Services", order: 20 },
|
|
{ value: "configuration", label: "Configuration", order: 30 },
|
|
{ value: "runtime_logs", label: "Runtime logs", order: 40 },
|
|
{ value: "routines", label: "Routines", order: 60 },
|
|
];
|
|
|
|
function isExecutionWorkspacePluginTab(value: string | null): value is ExecutionWorkspacePluginTab {
|
|
return typeof value === "string" && value.startsWith("plugin:");
|
|
}
|
|
|
|
function orderExecutionWorkspaceTabItems(items: OrderedExecutionWorkspaceTabItem[]) {
|
|
return items
|
|
.map((item, index) => ({ item, index }))
|
|
.sort((left, right) => left.item.order - right.item.order || left.index - right.index)
|
|
.map(({ item }) => item);
|
|
}
|
|
|
|
function resolveExecutionWorkspaceTab(pathname: string, workspaceId: string): ExecutionWorkspaceBaseTab | null {
|
|
const segments = pathname.split("/").filter(Boolean);
|
|
const executionWorkspacesIndex = segments.indexOf("execution-workspaces");
|
|
if (executionWorkspacesIndex === -1 || segments[executionWorkspacesIndex + 1] !== workspaceId) return null;
|
|
const tab = segments[executionWorkspacesIndex + 2];
|
|
if (tab === "services") return "services";
|
|
if (tab === "issues") return "issues";
|
|
if (tab === "routines") return "routines";
|
|
if (tab === "runtime-logs") return "runtime_logs";
|
|
if (tab === "configuration") return "configuration";
|
|
return null;
|
|
}
|
|
|
|
function executionWorkspaceTabPath(workspaceId: string, tab: ExecutionWorkspaceBaseTab) {
|
|
const segment = tab === "runtime_logs" ? "runtime-logs" : tab;
|
|
return `/execution-workspaces/${workspaceId}/${segment}`;
|
|
}
|
|
|
|
function LegacyWorkspaceTabRedirect({ workspaceId }: { workspaceId: string }) {
|
|
useEffect(() => {
|
|
try {
|
|
localStorage.removeItem(`paperclip:execution-workspace-tab:${workspaceId}`);
|
|
} catch {}
|
|
}, [workspaceId]);
|
|
|
|
return <Navigate to={executionWorkspaceTabPath(workspaceId, "issues")} replace />;
|
|
}
|
|
|
|
function isSafeExternalUrl(value: string | null | undefined) {
|
|
if (!value) return false;
|
|
try {
|
|
const parsed = new URL(value);
|
|
return parsed.protocol === "http:" || parsed.protocol === "https:";
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function readText(value: string | null | undefined) {
|
|
return value ?? "";
|
|
}
|
|
|
|
function formatJson(value: Record<string, unknown> | null | undefined) {
|
|
if (!value || Object.keys(value).length === 0) return "";
|
|
return JSON.stringify(value, null, 2);
|
|
}
|
|
|
|
function formatOptionalDateTime(value: Date | string | null | undefined) {
|
|
return value ? formatDateTime(value) : "Never";
|
|
}
|
|
|
|
function normalizeText(value: string) {
|
|
const trimmed = value.trim();
|
|
return trimmed.length > 0 ? trimmed : null;
|
|
}
|
|
|
|
function parseWorkspaceRuntimeJson(value: string) {
|
|
const trimmed = value.trim();
|
|
if (!trimmed) return { ok: true as const, value: null as Record<string, unknown> | null };
|
|
|
|
try {
|
|
const parsed = JSON.parse(trimmed);
|
|
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
|
|
return {
|
|
ok: false as const,
|
|
error: "Workspace commands JSON must be a JSON object.",
|
|
};
|
|
}
|
|
return { ok: true as const, value: parsed as Record<string, unknown> };
|
|
} catch (error) {
|
|
return {
|
|
ok: false as const,
|
|
error: error instanceof Error ? error.message : "Invalid JSON.",
|
|
};
|
|
}
|
|
}
|
|
|
|
export function readConfiguredRuntimeServicePorts(runtimeConfig: Record<string, unknown> | null) {
|
|
if (!runtimeConfig) return [] as ConfiguredRuntimeServicePort[];
|
|
|
|
const entries: ConfiguredRuntimeServicePort[] = [];
|
|
const addServices = (collection: ConfiguredRuntimeServicePort["collection"], services: unknown, commandsRequireServiceKind: boolean) => {
|
|
if (!Array.isArray(services)) return;
|
|
services.forEach((service, index) => {
|
|
if (!service || typeof service !== "object" || Array.isArray(service)) return;
|
|
const config = service as Record<string, unknown>;
|
|
if (commandsRequireServiceKind && config.kind !== "service") return;
|
|
const portConfig = config.port;
|
|
const hasObjectPortValue = Boolean(
|
|
portConfig
|
|
&& typeof portConfig === "object"
|
|
&& !Array.isArray(portConfig)
|
|
&& Object.hasOwn(portConfig, "value"),
|
|
);
|
|
const portValue =
|
|
typeof portConfig === "number"
|
|
? portConfig
|
|
: hasObjectPortValue
|
|
? (portConfig as Record<string, unknown>).value
|
|
: null;
|
|
entries.push({
|
|
collection,
|
|
index,
|
|
name: typeof config.name === "string" && config.name.trim() ? config.name : `Service ${index + 1}`,
|
|
port: typeof portValue === "number" ? portValue : null,
|
|
invalidPort: (typeof portConfig === "number" || hasObjectPortValue)
|
|
&& (typeof portValue !== "number" || !Number.isInteger(portValue) || portValue < 1 || portValue > 65535),
|
|
});
|
|
});
|
|
};
|
|
|
|
addServices("commands", runtimeConfig.commands, true);
|
|
addServices("services", runtimeConfig.services, false);
|
|
return entries;
|
|
}
|
|
|
|
export function updateConfiguredRuntimeServicePort(input: {
|
|
runtimeConfig: Record<string, unknown>;
|
|
service: ConfiguredRuntimeServicePort;
|
|
port: string;
|
|
}) {
|
|
const runtimeConfig = structuredClone(input.runtimeConfig);
|
|
const entries = runtimeConfig[input.service.collection];
|
|
if (!Array.isArray(entries)) return runtimeConfig;
|
|
const entry = entries[input.service.index];
|
|
if (!entry || typeof entry !== "object" || Array.isArray(entry)) return runtimeConfig;
|
|
const config = entry as Record<string, unknown>;
|
|
const existingPort = config.port && typeof config.port === "object" && !Array.isArray(config.port)
|
|
? config.port as Record<string, unknown>
|
|
: null;
|
|
|
|
const trimmedPort = input.port.trim();
|
|
if (!trimmedPort) {
|
|
if (existingPort) {
|
|
const autoPort: Record<string, unknown> = { ...existingPort, type: "auto" };
|
|
delete autoPort.value;
|
|
config.port = autoPort;
|
|
} else {
|
|
delete config.port;
|
|
}
|
|
return runtimeConfig;
|
|
}
|
|
const port = Number(trimmedPort);
|
|
if (!Number.isInteger(port) || port < 1 || port > 65535) return runtimeConfig;
|
|
config.port = { ...existingPort, type: "fixed", value: port };
|
|
return runtimeConfig;
|
|
}
|
|
|
|
export function getConfiguredRuntimeServicePortWarnings(services: ConfiguredRuntimeServicePort[]) {
|
|
const servicesByPort = new Map<number, ConfiguredRuntimeServicePort[]>();
|
|
for (const service of services) {
|
|
if (service.invalidPort || !service.port) continue;
|
|
const servicesForPort = servicesByPort.get(service.port) ?? [];
|
|
servicesForPort.push(service);
|
|
servicesByPort.set(service.port, servicesForPort);
|
|
}
|
|
|
|
return Array.from(servicesByPort.entries())
|
|
.filter(([, servicesForPort]) => servicesForPort.length > 1)
|
|
.map(([port, servicesForPort]) =>
|
|
`Port ${port} is assigned to multiple services: ${servicesForPort.map((service) => service.name).join(", ")}.`,
|
|
);
|
|
}
|
|
|
|
function formStateFromWorkspace(workspace: ExecutionWorkspace): WorkspaceFormState {
|
|
return {
|
|
name: workspace.name,
|
|
cwd: readText(workspace.cwd),
|
|
repoUrl: readText(workspace.repoUrl),
|
|
baseRef: readText(workspace.baseRef),
|
|
branchName: readText(workspace.branchName),
|
|
providerRef: readText(workspace.providerRef),
|
|
provisionCommand: readText(workspace.config?.provisionCommand),
|
|
runtimeProvisionCommand: readText(workspace.config?.runtimeProvisionCommand),
|
|
teardownCommand: readText(workspace.config?.teardownCommand),
|
|
cleanupCommand: readText(workspace.config?.cleanupCommand),
|
|
inheritRuntime: !workspace.config?.workspaceRuntime,
|
|
workspaceRuntime: formatJson(workspace.config?.workspaceRuntime),
|
|
};
|
|
}
|
|
|
|
function buildWorkspacePatch(initialState: WorkspaceFormState, nextState: WorkspaceFormState) {
|
|
const patch: Record<string, unknown> = {};
|
|
const configPatch: Record<string, unknown> = {};
|
|
|
|
const maybeAssign = (
|
|
key: keyof Pick<WorkspaceFormState, "name" | "cwd" | "repoUrl" | "baseRef" | "branchName" | "providerRef">,
|
|
) => {
|
|
if (initialState[key] === nextState[key]) return;
|
|
patch[key] = key === "name" ? (normalizeText(nextState[key]) ?? initialState.name) : normalizeText(nextState[key]);
|
|
};
|
|
|
|
maybeAssign("name");
|
|
maybeAssign("cwd");
|
|
maybeAssign("repoUrl");
|
|
maybeAssign("baseRef");
|
|
maybeAssign("branchName");
|
|
maybeAssign("providerRef");
|
|
|
|
const maybeAssignConfigText = (key: keyof Pick<WorkspaceFormState, "provisionCommand" | "runtimeProvisionCommand" | "teardownCommand" | "cleanupCommand">) => {
|
|
if (initialState[key] === nextState[key]) return;
|
|
configPatch[key] = normalizeText(nextState[key]);
|
|
};
|
|
|
|
maybeAssignConfigText("provisionCommand");
|
|
maybeAssignConfigText("runtimeProvisionCommand");
|
|
maybeAssignConfigText("teardownCommand");
|
|
maybeAssignConfigText("cleanupCommand");
|
|
|
|
if (initialState.inheritRuntime !== nextState.inheritRuntime || initialState.workspaceRuntime !== nextState.workspaceRuntime) {
|
|
const parsed = parseWorkspaceRuntimeJson(nextState.workspaceRuntime);
|
|
if (!parsed.ok) throw new Error(parsed.error);
|
|
configPatch.workspaceRuntime = nextState.inheritRuntime ? null : parsed.value;
|
|
}
|
|
|
|
if (Object.keys(configPatch).length > 0) {
|
|
patch.config = configPatch;
|
|
}
|
|
|
|
return patch;
|
|
}
|
|
|
|
function validateForm(form: WorkspaceFormState) {
|
|
const repoUrl = normalizeText(form.repoUrl);
|
|
if (repoUrl) {
|
|
try {
|
|
new URL(repoUrl);
|
|
} catch {
|
|
return "Repo URL must be a valid URL.";
|
|
}
|
|
}
|
|
|
|
if (!form.inheritRuntime) {
|
|
const runtimeJson = parseWorkspaceRuntimeJson(form.workspaceRuntime);
|
|
if (!runtimeJson.ok) {
|
|
return runtimeJson.error;
|
|
}
|
|
const invalidPort = readConfiguredRuntimeServicePorts(runtimeJson.value).find((service) => service.invalidPort);
|
|
if (invalidPort) return `${invalidPort.name} has an invalid fixed port.`;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function Field({
|
|
label,
|
|
hint,
|
|
children,
|
|
}: {
|
|
label: string;
|
|
hint?: string;
|
|
children: React.ReactNode;
|
|
}) {
|
|
return (
|
|
<label className="block space-y-2">
|
|
<div className="flex flex-col gap-0.5 sm:flex-row sm:items-baseline sm:justify-between sm:gap-3">
|
|
<span className="text-sm font-medium text-foreground">{label}</span>
|
|
{hint ? <span className="text-xs text-muted-foreground sm:text-right">{hint}</span> : null}
|
|
</div>
|
|
{children}
|
|
</label>
|
|
);
|
|
}
|
|
|
|
function workspaceOperationPhaseLabel(phase: string) {
|
|
switch (phase) {
|
|
case "worktree_prepare":
|
|
return "Worktree setup";
|
|
case "workspace_config_freshness":
|
|
return "Config freshness";
|
|
case "workspace_provision":
|
|
return "Provision";
|
|
case "workspace_seed":
|
|
return "Database seed";
|
|
case "workspace_runtime_provision":
|
|
return "Runtime provision";
|
|
case "workspace_teardown":
|
|
return "Teardown";
|
|
case "worktree_cleanup":
|
|
return "Worktree cleanup";
|
|
case "workspace_finalize":
|
|
return "Finalize";
|
|
default:
|
|
return phase;
|
|
}
|
|
}
|
|
|
|
export type RuntimeProvisionStatus =
|
|
| { kind: "eager" }
|
|
| { kind: "deferred" }
|
|
| { kind: "provisioning"; at: Date | null }
|
|
| { kind: "provisioned"; at: Date | null }
|
|
| { kind: "failed"; at: Date | null };
|
|
|
|
/**
|
|
* Derives the lazy runtime-provisioning state from the configured command and the
|
|
* database-seed or runtime-provision operation-log entries (most-recent first). Returns
|
|
* "eager" when no runtime provision command is configured (the legacy path).
|
|
*/
|
|
export function resolveRuntimeProvisionStatus(input: {
|
|
runtimeProvisionCommand: string | null | undefined;
|
|
operations: WorkspaceOperation[] | undefined;
|
|
}): RuntimeProvisionStatus {
|
|
const latest = (input.operations ?? []).find((operation) => (
|
|
operation.phase === "workspace_seed" || operation.phase === "workspace_runtime_provision"
|
|
)) ?? null;
|
|
if (latest) {
|
|
const at = latest.finishedAt ?? latest.startedAt ?? null;
|
|
if (latest.status === "running") return { kind: "provisioning", at };
|
|
if (latest.status === "succeeded") return { kind: "provisioned", at };
|
|
if (latest.status === "failed") return { kind: "failed", at };
|
|
// "skipped" falls through to the config-derived state below.
|
|
}
|
|
const configured = Boolean(input.runtimeProvisionCommand && input.runtimeProvisionCommand.trim());
|
|
return configured ? { kind: "deferred" } : { kind: "eager" };
|
|
}
|
|
|
|
function DetailRow({ label, children }: { label: string; children: React.ReactNode }) {
|
|
return (
|
|
<div className="flex flex-col gap-1.5 py-1.5 sm:flex-row sm:items-start sm:gap-3">
|
|
<div className="shrink-0 text-xs text-muted-foreground sm:w-32">{label}</div>
|
|
<div className="min-w-0 flex-1 text-sm">{children}</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function StatusPill({ children, className }: { children: React.ReactNode; className?: string }) {
|
|
return (
|
|
<div className={cn("inline-flex items-center rounded-full border border-border bg-background px-2.5 py-1 text-xs text-muted-foreground", className)}>
|
|
{children}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
export function RuntimeProvisionStatusValue({
|
|
status,
|
|
onViewLogs,
|
|
}: {
|
|
status: RuntimeProvisionStatus;
|
|
onViewLogs: () => void;
|
|
}) {
|
|
if (status.kind === "eager") {
|
|
return (
|
|
<span className="text-sm text-muted-foreground">Eager · provisioned during workspace setup</span>
|
|
);
|
|
}
|
|
if (status.kind === "deferred") {
|
|
return (
|
|
<div className="flex flex-col gap-1">
|
|
<StatusPill className="border-amber-500/40 text-amber-600 dark:text-amber-400">Deferred</StatusPill>
|
|
<span className="text-xs text-muted-foreground">
|
|
Runs once before the first runtime-service start.
|
|
</span>
|
|
</div>
|
|
);
|
|
}
|
|
if (status.kind === "provisioning") {
|
|
return (
|
|
<StatusPill className="border-border text-muted-foreground">
|
|
<Loader2 className="mr-1.5 h-3 w-3 animate-spin" />
|
|
Provisioning…
|
|
</StatusPill>
|
|
);
|
|
}
|
|
if (status.kind === "provisioned") {
|
|
return (
|
|
<StatusPill className="border-emerald-500/40 text-emerald-600 dark:text-emerald-400">
|
|
Provisioned{status.at ? ` · ${formatDateTime(status.at)}` : ""}
|
|
</StatusPill>
|
|
);
|
|
}
|
|
return (
|
|
<div className="flex flex-col gap-1">
|
|
<StatusPill className="border-destructive/50 text-destructive">
|
|
Provisioning failed{status.at ? ` · ${formatDateTime(status.at)}` : ""}
|
|
</StatusPill>
|
|
<button type="button" onClick={onViewLogs} className="self-start text-xs text-muted-foreground underline underline-offset-2 hover:text-foreground">
|
|
View runtime logs
|
|
</button>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function MonoValue({ value, copy }: { value: string; copy?: boolean }) {
|
|
return (
|
|
<div className="inline-flex max-w-full items-start gap-2">
|
|
<span className="break-all font-mono text-xs">{value}</span>
|
|
{copy ? (
|
|
<CopyText text={value} className="shrink-0 text-muted-foreground hover:text-foreground" copiedLabel="Copied">
|
|
<Copy className="h-3.5 w-3.5" />
|
|
</CopyText>
|
|
) : null}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function WorkspaceLink({
|
|
project,
|
|
workspace,
|
|
}: {
|
|
project: Project;
|
|
workspace: ProjectWorkspace;
|
|
}) {
|
|
return <Link to={projectWorkspaceUrl(project, workspace.id)} className="hover:underline">{workspace.name}</Link>;
|
|
}
|
|
|
|
function ExecutionWorkspaceIssuesList({
|
|
companyId,
|
|
workspace,
|
|
issues,
|
|
isLoading,
|
|
error,
|
|
project,
|
|
}: {
|
|
companyId: string;
|
|
workspace: ExecutionWorkspace;
|
|
issues: Issue[];
|
|
isLoading: boolean;
|
|
error: Error | null;
|
|
project: Project | null;
|
|
}) {
|
|
const queryClient = useQueryClient();
|
|
|
|
const { data: agents } = useQuery({
|
|
queryKey: queryKeys.agents.list(companyId),
|
|
queryFn: () => agentsApi.list(companyId),
|
|
enabled: !!companyId,
|
|
});
|
|
|
|
const liveRunsQueryKey = queryKeys.liveRuns(companyId);
|
|
const sharedLiveRuns = useSharedPollingQuery({
|
|
companyId,
|
|
resourceKey: "live-runs",
|
|
queryKey: liveRunsQueryKey,
|
|
enabled: !!companyId,
|
|
// Event-sourced via LiveUpdatesProvider (issue 9627); no interval poll needed.
|
|
refetchInterval: false,
|
|
leaderOnly: true,
|
|
});
|
|
const { data: liveRuns, dataUpdatedAt: liveRunsUpdatedAt } = useQuery({
|
|
queryKey: liveRunsQueryKey,
|
|
queryFn: () => heartbeatsApi.liveRunsForCompany(companyId),
|
|
enabled: sharedLiveRuns.enabled,
|
|
refetchInterval: sharedLiveRuns.refetchInterval,
|
|
});
|
|
usePublishSharedQueryData(sharedLiveRuns, liveRuns, liveRunsUpdatedAt);
|
|
|
|
const liveIssueIds = useMemo(() => collectLiveIssueIds(liveRuns, issues), [issues, liveRuns]);
|
|
|
|
const updateIssue = useUpdateIssueMutation({
|
|
companyId,
|
|
invalidateKeys: [
|
|
queryKeys.issues.listByExecutionWorkspace(companyId, workspace.id),
|
|
queryKeys.issues.list(companyId),
|
|
...(project?.id ? [queryKeys.issues.listByProject(companyId, project.id)] : []),
|
|
],
|
|
});
|
|
|
|
const projectOptions = useMemo(
|
|
() => (project ? [{ id: project.id, name: project.name, workspaces: project.workspaces ?? [] }] : undefined),
|
|
[project],
|
|
);
|
|
const createIssueDefaults = useMemo(
|
|
() => ({
|
|
projectId: workspace.projectId,
|
|
...(workspace.projectWorkspaceId ? { projectWorkspaceId: workspace.projectWorkspaceId } : {}),
|
|
executionWorkspaceId: workspace.id,
|
|
executionWorkspaceMode: "reuse_existing",
|
|
}),
|
|
[workspace.id, workspace.projectId, workspace.projectWorkspaceId],
|
|
);
|
|
|
|
return (
|
|
<IssuesList
|
|
issues={issues}
|
|
isLoading={isLoading}
|
|
error={error}
|
|
agents={agents}
|
|
projects={projectOptions}
|
|
liveIssueIds={liveIssueIds}
|
|
projectId={project?.id}
|
|
viewStateKey="paperclip:execution-workspace-issues-view"
|
|
baseCreateIssueDefaults={createIssueDefaults}
|
|
onUpdateIssue={(id, data) => updateIssue.mutate({ id, data })}
|
|
/>
|
|
);
|
|
}
|
|
|
|
function WorkspaceRoutineRow({
|
|
routine,
|
|
variableNames,
|
|
runningRoutineId,
|
|
onRunNow,
|
|
}: {
|
|
routine: RoutineListItem;
|
|
variableNames: string[];
|
|
runningRoutineId: string | null;
|
|
onRunNow: (routine: RoutineListItem) => void;
|
|
}) {
|
|
const isArchived = routine.status === "archived";
|
|
const isRunning = runningRoutineId === routine.id;
|
|
|
|
return (
|
|
<div className="flex flex-col gap-3 border-b border-border px-3 py-3 last:border-b-0 sm:flex-row sm:items-center">
|
|
<div className="min-w-0 flex-1 space-y-1.5">
|
|
<div className="flex flex-wrap items-center gap-2">
|
|
<Link to={`/routines/${routine.id}`} className="truncate text-sm font-medium hover:underline">
|
|
{routine.title}
|
|
</Link>
|
|
{routine.status !== "active" ? (
|
|
<span className="text-xs text-muted-foreground">{routine.status}</span>
|
|
) : null}
|
|
</div>
|
|
<div className="flex flex-wrap items-center gap-x-4 gap-y-1 text-xs text-muted-foreground">
|
|
<span>{routine.assigneeAgentId ? "Default agent set" : "Choose agent when running"}</span>
|
|
<span>Last run {formatOptionalDateTime(routine.lastRun?.triggeredAt ?? routine.lastTriggeredAt)}</span>
|
|
<span className="flex flex-wrap gap-1">
|
|
{variableNames.map((name) => (
|
|
<span key={name} className="rounded-sm bg-muted px-1.5 py-0.5 font-mono text-(length:--text-micro) text-muted-foreground">
|
|
{name}
|
|
</span>
|
|
))}
|
|
</span>
|
|
</div>
|
|
</div>
|
|
<Button
|
|
variant="outline"
|
|
size="sm"
|
|
className="w-full sm:w-auto"
|
|
disabled={isArchived || isRunning}
|
|
onClick={() => onRunNow(routine)}
|
|
>
|
|
{isRunning ? <Loader2 className="mr-2 h-4 w-4 animate-spin" /> : <Play className="mr-2 h-4 w-4" />}
|
|
{isRunning ? "Running..." : "Run now"}
|
|
</Button>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
function ExecutionWorkspaceRoutinesList({
|
|
workspace,
|
|
project,
|
|
}: {
|
|
workspace: ExecutionWorkspace;
|
|
project: Project | null;
|
|
}) {
|
|
const queryClient = useQueryClient();
|
|
const { pushToast } = useToastActions();
|
|
const [runDialogRoutine, setRunDialogRoutine] = useState<RoutineListItem | null>(null);
|
|
const [runningRoutineId, setRunningRoutineId] = useState<string | null>(null);
|
|
|
|
const routinesQuery = useQuery({
|
|
queryKey: queryKeys.routines.list(workspace.companyId, { projectId: workspace.projectId }),
|
|
queryFn: () => routinesApi.list(workspace.companyId, { projectId: workspace.projectId }),
|
|
});
|
|
// Read the routine list through the shared view: cached rows stay usable
|
|
// during a transient refetch failure,and a no-data failure shows readable
|
|
// copy with Retry.
|
|
const routinesView = useQueryView(routinesQuery);
|
|
|
|
const { data: agents } = useQuery({
|
|
queryKey: queryKeys.agents.list(workspace.companyId),
|
|
queryFn: () => agentsApi.list(workspace.companyId),
|
|
});
|
|
|
|
const workspaceRoutines = useMemo(
|
|
() => sortWorkspaceRoutinesByName((routinesQuery.data ?? []).filter(routineHasWorkspaceSpecificVariables)),
|
|
[routinesQuery.data],
|
|
);
|
|
|
|
const runRoutine = useMutation({
|
|
mutationFn: ({ id, data }: { id: string; data?: RoutineRunDialogSubmitData }) => routinesApi.run(id, {
|
|
...(data?.variables && Object.keys(data.variables).length > 0 ? { variables: data.variables } : {}),
|
|
...(data?.assigneeAgentId !== undefined ? { assigneeAgentId: data.assigneeAgentId } : {}),
|
|
...(data?.projectId !== undefined ? { projectId: data.projectId } : {}),
|
|
...(data?.executionWorkspaceId !== undefined ? { executionWorkspaceId: data.executionWorkspaceId } : {}),
|
|
...(data?.executionWorkspacePreference !== undefined
|
|
? { executionWorkspacePreference: data.executionWorkspacePreference }
|
|
: {}),
|
|
...(data?.executionWorkspaceSettings !== undefined
|
|
? { executionWorkspaceSettings: data.executionWorkspaceSettings }
|
|
: {}),
|
|
}),
|
|
onMutate: ({ id }) => {
|
|
setRunningRoutineId(id);
|
|
},
|
|
onSuccess: async (_, { id }) => {
|
|
setRunDialogRoutine(null);
|
|
await Promise.all([
|
|
queryClient.invalidateQueries({ queryKey: ["routines", workspace.companyId] }),
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.routines.detail(id) }),
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.issues.listByExecutionWorkspace(workspace.companyId, workspace.id) }),
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.issues.list(workspace.companyId) }),
|
|
]);
|
|
pushToast({
|
|
title: "Routine started",
|
|
body: "Paperclip created a run using this execution workspace.",
|
|
tone: "success",
|
|
});
|
|
},
|
|
onSettled: () => {
|
|
setRunningRoutineId(null);
|
|
},
|
|
onError: (mutationError) => {
|
|
pushToast({
|
|
title: "Routine run failed",
|
|
body: describeError(mutationError).body,
|
|
tone: "error",
|
|
});
|
|
},
|
|
});
|
|
|
|
return (
|
|
<>
|
|
<Card className="rounded-none">
|
|
<CardHeader>
|
|
<CardTitle>Workspace routines</CardTitle>
|
|
<CardDescription>
|
|
Routines that use workspace-specific variables can be run against this execution workspace.
|
|
</CardDescription>
|
|
</CardHeader>
|
|
<CardContent>
|
|
{routinesView.kind === "loading" || routinesView.kind === "reconnecting" ? (
|
|
<p className="text-sm text-muted-foreground">Loading routines...</p>
|
|
) : routinesView.kind === "error" ? (
|
|
<QueryErrorState
|
|
size="inline"
|
|
error={routinesView.error}
|
|
action="load workspace routines"
|
|
onRetry={routinesView.retry}
|
|
retrying={routinesView.isFetching}
|
|
/>
|
|
) : workspaceRoutines.length === 0 ? (
|
|
<div className="flex flex-col items-center gap-2 py-10 text-center">
|
|
<Repeat className="h-5 w-5 text-muted-foreground" />
|
|
<p className="text-sm text-muted-foreground">
|
|
No routines use workspace-specific variables yet.
|
|
</p>
|
|
</div>
|
|
) : (
|
|
<div className="rounded-lg border border-border">
|
|
{workspaceRoutines.map((routine) => (
|
|
<WorkspaceRoutineRow
|
|
key={routine.id}
|
|
routine={routine}
|
|
variableNames={getWorkspaceSpecificRoutineVariableNames(routine)}
|
|
runningRoutineId={runningRoutineId}
|
|
onRunNow={setRunDialogRoutine}
|
|
/>
|
|
))}
|
|
</div>
|
|
)}
|
|
</CardContent>
|
|
</Card>
|
|
|
|
<RoutineRunVariablesDialog
|
|
open={runDialogRoutine !== null}
|
|
onOpenChange={(next) => {
|
|
if (!next) setRunDialogRoutine(null);
|
|
}}
|
|
companyId={workspace.companyId}
|
|
routineName={runDialogRoutine?.title ?? null}
|
|
agents={agents ?? []}
|
|
projects={project ? [project] : []}
|
|
defaultProjectId={workspace.projectId}
|
|
defaultAssigneeAgentId={runDialogRoutine?.assigneeAgentId ?? null}
|
|
defaultExecutionWorkspace={workspace}
|
|
variables={runDialogRoutine?.variables ?? []}
|
|
isPending={runRoutine.isPending}
|
|
onSubmit={(data) => {
|
|
if (!runDialogRoutine) return;
|
|
runRoutine.mutate({ id: runDialogRoutine.id, data });
|
|
}}
|
|
/>
|
|
</>
|
|
);
|
|
}
|
|
|
|
export function ExecutionWorkspaceDetail() {
|
|
const { visible: workspaceIsolationControlsVisible, loaded: workspaceVisibilityLoaded } = useWorkspaceIsolationControls();
|
|
const { workspaceId } = useParams<{ workspaceId: string }>();
|
|
const location = useLocation();
|
|
const navigate = useNavigate();
|
|
const queryClient = useQueryClient();
|
|
const { setBreadcrumbs } = useBreadcrumbs();
|
|
const { selectedCompanyId, setSelectedCompanyId } = useCompany();
|
|
const { hideHostPaths } = useManagedSandboxOnly();
|
|
const [form, setForm] = useState<WorkspaceFormState | null>(null);
|
|
const [closeDialogOpen, setCloseDialogOpen] = useState(false);
|
|
const [errorMessage, setErrorMessage] = useState<string | null>(null);
|
|
const [runtimeActionErrorMessage, setRuntimeActionErrorMessage] = useState<string | null>(null);
|
|
const [runtimeActionMessage, setRuntimeActionMessage] = useState<string | null>(null);
|
|
const [pendingRuntimeActions, setPendingRuntimeActions] = useState<WorkspaceRuntimeControlRequest[]>([]);
|
|
const activeRouteTab = workspaceId ? resolveExecutionWorkspaceTab(location.pathname, workspaceId) : null;
|
|
const pluginTabFromSearch = useMemo(() => {
|
|
const tab = new URLSearchParams(location.search).get("tab");
|
|
return isExecutionWorkspacePluginTab(tab) ? tab : null;
|
|
}, [location.search]);
|
|
const activeTab: ExecutionWorkspaceTab | null = activeRouteTab ?? pluginTabFromSearch;
|
|
|
|
const workspaceQuery = useQuery({
|
|
queryKey: queryKeys.executionWorkspaces.detail(workspaceId!),
|
|
queryFn: () => executionWorkspacesApi.get(workspaceId!),
|
|
enabled: Boolean(workspaceId),
|
|
});
|
|
const workspaceView = useQueryView(workspaceQuery);
|
|
const workspace = workspaceQuery.data ?? null;
|
|
|
|
const projectQuery = useQuery({
|
|
queryKey: workspace?.projectId ? [...queryKeys.projects.detail(workspace.projectId), workspace.companyId] : ["projects", "detail", "__pending__"],
|
|
queryFn: () => projectsApi.get(workspace!.projectId!, workspace!.companyId),
|
|
enabled: Boolean(workspace?.projectId),
|
|
});
|
|
const project = projectQuery.data ?? null;
|
|
|
|
const sourceIssueQuery = useQuery({
|
|
queryKey: workspace?.sourceIssueId ? queryKeys.issues.detail(workspace.sourceIssueId) : ["issues", "detail", "__none__"],
|
|
queryFn: () => issuesApi.get(workspace!.sourceIssueId!),
|
|
enabled: Boolean(workspace?.sourceIssueId),
|
|
});
|
|
const sourceIssue = sourceIssueQuery.data ?? null;
|
|
|
|
const derivedWorkspaceQuery = useQuery({
|
|
queryKey: workspace?.derivedFromExecutionWorkspaceId
|
|
? queryKeys.executionWorkspaces.detail(workspace.derivedFromExecutionWorkspaceId)
|
|
: ["execution-workspaces", "detail", "__none__"],
|
|
queryFn: () => executionWorkspacesApi.get(workspace!.derivedFromExecutionWorkspaceId!),
|
|
enabled: Boolean(workspace?.derivedFromExecutionWorkspaceId),
|
|
});
|
|
const derivedWorkspace = derivedWorkspaceQuery.data ?? null;
|
|
const linkedIssuesQuery = useQuery({
|
|
queryKey: workspace
|
|
? queryKeys.issues.listByExecutionWorkspace(workspace.companyId, workspace.id)
|
|
: ["issues", "__execution-workspace__", "__none__"],
|
|
queryFn: () => issuesApi.list(workspace!.companyId, { executionWorkspaceId: workspace!.id }),
|
|
enabled: Boolean(workspace?.companyId),
|
|
});
|
|
const linkedIssuesView = useQueryView(linkedIssuesQuery);
|
|
const linkedIssues = linkedIssuesQuery.data ?? [];
|
|
|
|
const linkedProjectWorkspace = useMemo(
|
|
() => project?.workspaces.find((item) => item.id === workspace?.projectWorkspaceId) ?? null,
|
|
[project, workspace?.projectWorkspaceId],
|
|
);
|
|
|
|
const {
|
|
slots: workspacePluginDetailSlots,
|
|
isLoading: workspacePluginDetailSlotsLoading,
|
|
errorMessage: workspacePluginDetailSlotsError,
|
|
} = usePluginSlots({
|
|
slotTypes: ["detailTab"],
|
|
entityType: "execution_workspace",
|
|
companyId: workspace?.companyId ?? null,
|
|
enabled: !!workspace?.companyId,
|
|
});
|
|
const workspacePluginTabItems = useMemo(
|
|
() => workspacePluginDetailSlots.map((slot) => ({
|
|
value: `plugin:${slot.pluginKey}:${slot.id}` as ExecutionWorkspacePluginTab,
|
|
label: slot.displayName,
|
|
order: slot.order ?? DEFAULT_PLUGIN_DETAIL_TAB_ORDER,
|
|
slot,
|
|
})),
|
|
[workspacePluginDetailSlots],
|
|
);
|
|
const workspaceTabItems = useMemo(
|
|
() => orderExecutionWorkspaceTabItems([
|
|
...EXECUTION_WORKSPACE_BASE_TAB_ITEMS.filter((item) => item.value !== "configuration" || workspaceIsolationControlsVisible),
|
|
...workspacePluginTabItems,
|
|
]),
|
|
[workspacePluginTabItems, workspaceIsolationControlsVisible],
|
|
);
|
|
const inheritedRuntimeConfig = linkedProjectWorkspace?.runtimeConfig?.workspaceRuntime ?? null;
|
|
const effectiveRuntimeConfig = workspace?.config?.workspaceRuntime ?? inheritedRuntimeConfig;
|
|
const runtimeConfigSource =
|
|
workspace?.config?.workspaceRuntime
|
|
? "execution_workspace"
|
|
: inheritedRuntimeConfig
|
|
? "project_workspace"
|
|
: "none";
|
|
|
|
const configuredRuntimeConfig = useMemo(() => {
|
|
if (!form || form.inheritRuntime) return inheritedRuntimeConfig;
|
|
const parsed = parseWorkspaceRuntimeJson(form.workspaceRuntime);
|
|
return parsed.ok ? parsed.value : null;
|
|
}, [form, inheritedRuntimeConfig]);
|
|
const configuredRuntimeServicePorts = useMemo(
|
|
() => readConfiguredRuntimeServicePorts(configuredRuntimeConfig),
|
|
[configuredRuntimeConfig],
|
|
);
|
|
const configuredRuntimeServicePortWarnings = useMemo(
|
|
() => getConfiguredRuntimeServicePortWarnings(configuredRuntimeServicePorts),
|
|
[configuredRuntimeServicePorts],
|
|
);
|
|
|
|
const initialState = useMemo(() => (workspace ? formStateFromWorkspace(workspace) : null), [workspace]);
|
|
const isDirty = Boolean(form && initialState && JSON.stringify(form) !== JSON.stringify(initialState));
|
|
const projectRef = project ? projectRouteRef(project) : workspace?.projectId ?? "";
|
|
|
|
useEffect(() => {
|
|
if (!workspace?.companyId || workspace.companyId === selectedCompanyId) return;
|
|
setSelectedCompanyId(workspace.companyId, { source: "route_sync" });
|
|
}, [workspace?.companyId, selectedCompanyId, setSelectedCompanyId]);
|
|
|
|
useEffect(() => {
|
|
if (!workspace) return;
|
|
setForm(formStateFromWorkspace(workspace));
|
|
setErrorMessage(null);
|
|
setRuntimeActionErrorMessage(null);
|
|
setPendingRuntimeActions([]);
|
|
}, [workspace]);
|
|
|
|
useEffect(() => {
|
|
if (!workspace) return;
|
|
const crumbs = [
|
|
{ label: "Projects", href: "/projects" },
|
|
...(project ? [{ label: project.name, href: `/projects/${projectRef}` }] : []),
|
|
...(project ? [{ label: "Workspaces", href: `/projects/${projectRef}/workspaces` }] : []),
|
|
{ label: workspace.name },
|
|
];
|
|
setBreadcrumbs(crumbs);
|
|
}, [setBreadcrumbs, workspace, project, projectRef]);
|
|
|
|
const updateWorkspace = useMutation({
|
|
mutationFn: (patch: Record<string, unknown>) => executionWorkspacesApi.update(workspace!.id, patch),
|
|
onSuccess: (nextWorkspace) => {
|
|
queryClient.setQueryData(queryKeys.executionWorkspaces.detail(nextWorkspace.id), nextWorkspace);
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.closeReadiness(nextWorkspace.id) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.workspaceOperations(nextWorkspace.id) });
|
|
if (project) {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.projects.detail(project.id) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.projects.detail(project.urlKey) });
|
|
}
|
|
if (sourceIssue) {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.issues.detail(sourceIssue.id) });
|
|
}
|
|
setErrorMessage(null);
|
|
},
|
|
onError: (error) => {
|
|
setErrorMessage(describeError(error).body);
|
|
},
|
|
});
|
|
const workspaceOperationsQuery = useQuery({
|
|
queryKey: queryKeys.executionWorkspaces.workspaceOperations(workspaceId!),
|
|
queryFn: () => executionWorkspacesApi.listWorkspaceOperations(workspaceId!),
|
|
enabled: Boolean(workspaceId),
|
|
});
|
|
// Read workspace operations through the shared view: cached rows stay
|
|
// visible during a transient refetch failure,and a no-data failure shows
|
|
// readable copy with Retry.
|
|
|
|
const opsView = useQueryView(workspaceOperationsQuery);
|
|
const runtimeProvisionCommand =
|
|
workspace?.config?.runtimeProvisionCommand
|
|
?? project?.executionWorkspacePolicy?.workspaceStrategy?.runtimeProvisionCommand
|
|
?? null;
|
|
const runtimeProvisionStatus = useMemo(
|
|
() =>
|
|
resolveRuntimeProvisionStatus({
|
|
runtimeProvisionCommand,
|
|
operations: workspaceOperationsQuery.data,
|
|
}),
|
|
[runtimeProvisionCommand, workspaceOperationsQuery.data],
|
|
);
|
|
const controlRuntimeServices = useMutation({
|
|
mutationFn: (request: WorkspaceRuntimeControlRequest) =>
|
|
executionWorkspacesApi.controlRuntimeCommands(workspace!.id, request.action, request),
|
|
onSuccess: (result, request) => {
|
|
queryClient.setQueryData(queryKeys.executionWorkspaces.detail(result.workspace.id), result.workspace);
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.overview(result.workspace.companyId) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.workspaceOperations(result.workspace.id) });
|
|
if (result.workspace.projectId) queryClient.invalidateQueries({ queryKey: queryKeys.projects.detail(result.workspace.projectId) });
|
|
setRuntimeActionErrorMessage(null);
|
|
setRuntimeActionMessage(
|
|
request.action === "run"
|
|
? "Workspace job completed."
|
|
: request.action === "stop"
|
|
? "Workspace service stopped."
|
|
: request.action === "restart"
|
|
? "Workspace service restarted."
|
|
: "Workspace service started.",
|
|
);
|
|
},
|
|
onError: (error) => {
|
|
setRuntimeActionMessage(null);
|
|
setRuntimeActionErrorMessage(describeError(error).body);
|
|
},
|
|
onSettled: (_result, _error, request) => {
|
|
setPendingRuntimeActions((current) => current.filter((pendingRequest) => pendingRequest !== request));
|
|
},
|
|
});
|
|
|
|
if (workspaceQuery.isLoading || workspaceView.kind === "reconnecting") {
|
|
return <p className="text-sm text-muted-foreground">Loading workspace…</p>;
|
|
}
|
|
if (workspaceView.kind === "error") {
|
|
return (
|
|
<QueryErrorState
|
|
size="page"
|
|
error={workspaceQuery.error}
|
|
action="load this workspace"
|
|
onRetry={workspaceView.retry}
|
|
retrying={workspaceView.isFetching}
|
|
/>
|
|
);
|
|
}
|
|
if (!workspace || !form || !initialState) return null;
|
|
|
|
const canRunWorkspaceCommands = Boolean(workspace.cwd);
|
|
const canStartRuntimeServices = Boolean(effectiveRuntimeConfig) && canRunWorkspaceCommands;
|
|
const runtimeControlSections = buildWorkspaceRuntimeControlSections({
|
|
runtimeConfig: effectiveRuntimeConfig,
|
|
runtimeServices: workspace.runtimeServices ?? [],
|
|
canStartServices: canStartRuntimeServices,
|
|
canRunJobs: canRunWorkspaceCommands,
|
|
});
|
|
const pendingRuntimeAction = controlRuntimeServices.isPending ? controlRuntimeServices.variables ?? null : null;
|
|
const serviceControlEntries = buildWorkspaceServiceControlEntries({
|
|
sections: runtimeControlSections,
|
|
runtimeServices: workspace.runtimeServices ?? [],
|
|
pendingRequests: pendingRuntimeActions,
|
|
});
|
|
const pluginSlotContext = {
|
|
companyId: workspace.companyId,
|
|
projectId: workspace.projectId,
|
|
entityId: workspace.id,
|
|
entityType: "execution_workspace" as const,
|
|
};
|
|
const activePluginTab = workspacePluginTabItems.find((item) => item.value === activeTab) ?? null;
|
|
|
|
if (activeTab === "configuration" && !workspaceVisibilityLoaded) return null;
|
|
if (workspaceId && activeTab === "configuration" && !workspaceIsolationControlsVisible) {
|
|
return <LegacyWorkspaceTabRedirect workspaceId={workspaceId} />;
|
|
}
|
|
|
|
if (workspaceId && activeTab === null) {
|
|
return <LegacyWorkspaceTabRedirect workspaceId={workspaceId} />;
|
|
}
|
|
|
|
const handleTabChange = (tab: ExecutionWorkspaceTab) => {
|
|
if (isExecutionWorkspacePluginTab(tab)) {
|
|
navigate(`/execution-workspaces/${workspace.id}?tab=${encodeURIComponent(tab)}`);
|
|
return;
|
|
}
|
|
navigate(executionWorkspaceTabPath(workspace.id, tab));
|
|
};
|
|
|
|
const saveChanges = () => {
|
|
const validationError = validateForm(form);
|
|
if (validationError) {
|
|
setErrorMessage(validationError);
|
|
return;
|
|
}
|
|
|
|
let patch: Record<string, unknown> = {};
|
|
try {
|
|
patch = buildWorkspacePatch(initialState, form);
|
|
} catch (error) {
|
|
setErrorMessage(describeError(error).body);
|
|
}
|
|
|
|
if (Object.keys(patch).length === 0) return;
|
|
updateWorkspace.mutate(patch);
|
|
};
|
|
|
|
const runRuntimeControlRequests = (requests: WorkspaceRuntimeControlRequest[]) => {
|
|
if (requests.length === 0) return;
|
|
setPendingRuntimeActions((current) => [...current, ...requests]);
|
|
for (const request of requests) controlRuntimeServices.mutate(request);
|
|
};
|
|
|
|
return (
|
|
<>
|
|
<div className="space-y-4 overflow-hidden sm:space-y-6">
|
|
<div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
|
|
<div className="min-w-0 space-y-2">
|
|
<div className="text-xs font-medium uppercase tracking-(--tracking-eyebrow) text-muted-foreground">
|
|
Execution workspace
|
|
</div>
|
|
<h1 className="truncate text-xl font-semibold sm:text-2xl">{workspace.name}</h1>
|
|
</div>
|
|
<WorkspaceServiceControlBar
|
|
services={serviceControlEntries}
|
|
onAction={(action, serviceKey) => {
|
|
runRuntimeControlRequests(
|
|
resolveWorkspaceServiceControlRequests(runtimeControlSections, action, serviceKey),
|
|
);
|
|
}}
|
|
onViewLogs={() => handleTabChange("runtime_logs")}
|
|
onManageServices={() => handleTabChange("services")}
|
|
/>
|
|
</div>
|
|
{runtimeActionErrorMessage ? <p className="text-sm text-destructive">{runtimeActionErrorMessage}</p> : null}
|
|
{!runtimeActionErrorMessage && runtimeActionMessage ? <p className="text-sm text-muted-foreground">{runtimeActionMessage}</p> : null}
|
|
|
|
<PluginSlotOutlet
|
|
slotTypes={["toolbarButton", "contextMenuItem"]}
|
|
entityType="execution_workspace"
|
|
context={pluginSlotContext}
|
|
className="flex flex-wrap gap-2"
|
|
itemClassName="inline-flex"
|
|
missingBehavior="placeholder"
|
|
/>
|
|
|
|
<Tabs value={activeTab ?? "issues"} onValueChange={(value) => handleTabChange(value as ExecutionWorkspaceTab)}>
|
|
<PageTabBar
|
|
items={workspaceTabItems.map((item) => ({ value: item.value, label: item.label }))}
|
|
align="start"
|
|
value={activeTab ?? "issues"}
|
|
onValueChange={(value) => handleTabChange(value as ExecutionWorkspaceTab)}
|
|
/>
|
|
</Tabs>
|
|
|
|
{activeTab === "services" ? (
|
|
<WorkspaceRuntimeControls
|
|
sections={runtimeControlSections}
|
|
isPending={controlRuntimeServices.isPending}
|
|
pendingRequest={pendingRuntimeAction}
|
|
serviceEmptyMessage={
|
|
effectiveRuntimeConfig
|
|
? "No services have been started for this execution workspace yet."
|
|
: "No workspace command config is defined for this execution workspace yet."
|
|
}
|
|
jobEmptyMessage="No one-shot jobs are configured for this execution workspace yet."
|
|
disabledHint={
|
|
canStartRuntimeServices
|
|
? null
|
|
: "Execution workspaces need a working directory before local commands can run, and services also need runtime config."
|
|
}
|
|
onAction={(request) => runRuntimeControlRequests([request])}
|
|
/>
|
|
) : activeTab === "configuration" ? (
|
|
<div className="space-y-4 sm:space-y-6">
|
|
<Card className="rounded-none">
|
|
<CardHeader>
|
|
<CardTitle>Workspace settings</CardTitle>
|
|
<CardDescription>
|
|
Edit the concrete path, repo, branch, provisioning, teardown, and runtime overrides attached to this execution workspace. Saved changes affect future runs; Paperclip may refresh or replace a reused workspace when config changes.
|
|
</CardDescription>
|
|
<CardAction>
|
|
<Button
|
|
variant="destructive"
|
|
size="sm"
|
|
className="w-full sm:w-auto"
|
|
onClick={() => setCloseDialogOpen(true)}
|
|
disabled={workspace.status === "archived"}
|
|
>
|
|
{workspace.status === "cleanup_failed" ? "Retry close" : "Close workspace"}
|
|
</Button>
|
|
</CardAction>
|
|
</CardHeader>
|
|
|
|
<CardContent>
|
|
|
|
<div className="space-y-6">
|
|
<div className="space-y-4">
|
|
<div className="text-xs font-medium uppercase tracking-widest text-muted-foreground">General</div>
|
|
<Field label="Workspace name">
|
|
<Input
|
|
value={form.name}
|
|
onChange={(event) => setForm((current) => current ? { ...current, name: event.target.value } : current)}
|
|
placeholder="Execution workspace name"
|
|
/>
|
|
</Field>
|
|
</div>
|
|
|
|
<Separator />
|
|
|
|
<div className="space-y-4">
|
|
<div className="text-xs font-medium uppercase tracking-widest text-muted-foreground">Source control</div>
|
|
<div className="grid gap-4 sm:grid-cols-2">
|
|
<Field label="Branch name" hint="Useful for isolated worktrees">
|
|
<Input
|
|
className="font-mono"
|
|
value={form.branchName}
|
|
onChange={(event) => setForm((current) => current ? { ...current, branchName: event.target.value } : current)}
|
|
placeholder="PAP-946-workspace"
|
|
/>
|
|
</Field>
|
|
|
|
<Field label="Base ref">
|
|
<Input
|
|
className="font-mono"
|
|
value={form.baseRef}
|
|
onChange={(event) => setForm((current) => current ? { ...current, baseRef: event.target.value } : current)}
|
|
placeholder="origin/main"
|
|
/>
|
|
</Field>
|
|
</div>
|
|
|
|
<Field label="Repo URL">
|
|
<Input
|
|
value={form.repoUrl}
|
|
onChange={(event) => setForm((current) => current ? { ...current, repoUrl: event.target.value } : current)}
|
|
placeholder="https://github.com/org/repo"
|
|
/>
|
|
</Field>
|
|
</div>
|
|
|
|
<Separator />
|
|
|
|
{/*
|
|
Both fields name a path on the execution host. Under the
|
|
managed-sandbox-only policy every agent runs in the
|
|
platform-managed environment, which owns the paths, so the
|
|
whole group and its separator disappear, and stay hidden
|
|
until that policy is known.
|
|
*/}
|
|
{!hideHostPaths && (
|
|
<>
|
|
<div className="space-y-4">
|
|
<div className="text-xs font-medium uppercase tracking-widest text-muted-foreground">Paths</div>
|
|
<Field label="Working directory">
|
|
<Input
|
|
className="font-mono"
|
|
value={form.cwd}
|
|
onChange={(event) => setForm((current) => current ? { ...current, cwd: event.target.value } : current)}
|
|
placeholder="/absolute/path/to/workspace"
|
|
/>
|
|
</Field>
|
|
|
|
<Field label="Provider path / ref">
|
|
<Input
|
|
className="font-mono"
|
|
value={form.providerRef}
|
|
onChange={(event) => setForm((current) => current ? { ...current, providerRef: event.target.value } : current)}
|
|
placeholder="/path/to/worktree or provider ref"
|
|
/>
|
|
</Field>
|
|
</div>
|
|
|
|
<Separator />
|
|
</>
|
|
)}
|
|
|
|
{/*
|
|
Every lifecycle command runs a shell on the execution host and
|
|
its placeholder names a host script path. The platform-managed
|
|
environment owns that lifecycle, so the managed-sandbox-only
|
|
policy hides the group and its separator, and keeps them
|
|
hidden until that policy is known.
|
|
*/}
|
|
{!hideHostPaths && (
|
|
<>
|
|
<div className="space-y-4">
|
|
<div className="text-xs font-medium uppercase tracking-widest text-muted-foreground">Lifecycle commands</div>
|
|
<Field label="Provision command" hint="Runs when Paperclip prepares this execution workspace">
|
|
<Textarea
|
|
className="min-h-20 font-mono"
|
|
value={form.provisionCommand}
|
|
onChange={(event) => setForm((current) => current ? { ...current, provisionCommand: event.target.value } : current)}
|
|
placeholder="bash ./scripts/provision-worktree.sh"
|
|
/>
|
|
</Field>
|
|
|
|
<Field
|
|
label="Runtime provision command"
|
|
hint="Runs once before the first runtime-service start. Leave empty to keep eager provisioning."
|
|
>
|
|
<Textarea
|
|
className="min-h-20 font-mono"
|
|
value={form.runtimeProvisionCommand}
|
|
onChange={(event) => setForm((current) => current ? { ...current, runtimeProvisionCommand: event.target.value } : current)}
|
|
placeholder="bash ./scripts/provision-worktree-runtime.sh"
|
|
/>
|
|
</Field>
|
|
|
|
<Field label="Teardown command" hint="Runs when the execution workspace is archived or cleaned up">
|
|
<Textarea
|
|
className="min-h-20 font-mono"
|
|
value={form.teardownCommand}
|
|
onChange={(event) => setForm((current) => current ? { ...current, teardownCommand: event.target.value } : current)}
|
|
placeholder="bash ./scripts/teardown-worktree.sh"
|
|
/>
|
|
</Field>
|
|
|
|
<Field label="Cleanup command" hint="Workspace-specific cleanup before teardown">
|
|
<Textarea
|
|
className="min-h-16 font-mono"
|
|
value={form.cleanupCommand}
|
|
onChange={(event) => setForm((current) => current ? { ...current, cleanupCommand: event.target.value } : current)}
|
|
placeholder="pkill -f vite || true"
|
|
/>
|
|
</Field>
|
|
</div>
|
|
|
|
<Separator />
|
|
</>
|
|
)}
|
|
|
|
<div className="space-y-4">
|
|
<div className="text-xs font-medium uppercase tracking-widest text-muted-foreground">Runtime config</div>
|
|
<div className="rounded-md border border-dashed border-border/70 bg-background px-4 py-3">
|
|
<div className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center sm:justify-between">
|
|
<div className="space-y-1">
|
|
<div className="text-sm font-medium text-foreground">
|
|
Runtime config source
|
|
</div>
|
|
<p className="text-sm text-muted-foreground">
|
|
{runtimeConfigSource === "execution_workspace"
|
|
? "This execution workspace currently overrides the project workspace runtime config."
|
|
: runtimeConfigSource === "project_workspace"
|
|
? "This execution workspace is inheriting the project workspace runtime config."
|
|
: "No runtime config is currently defined on this execution workspace or its project workspace."}
|
|
</p>
|
|
</div>
|
|
<Button
|
|
variant="outline"
|
|
className="w-full sm:w-auto"
|
|
size="sm"
|
|
disabled={!linkedProjectWorkspace?.runtimeConfig?.workspaceRuntime}
|
|
onClick={() =>
|
|
setForm((current) => current ? {
|
|
...current,
|
|
inheritRuntime: true,
|
|
workspaceRuntime: "",
|
|
} : current)
|
|
}
|
|
>
|
|
Reset to inherit
|
|
</Button>
|
|
</div>
|
|
</div>
|
|
|
|
<details className="rounded-md border border-dashed border-border/70 bg-background px-4 py-3">
|
|
<summary className="cursor-pointer text-sm font-medium">Advanced runtime JSON</summary>
|
|
<p className="mt-2 text-sm text-muted-foreground">
|
|
Override the inherited workspace command model only when this execution workspace truly needs different service or job behavior.
|
|
</p>
|
|
<div className="mt-3">
|
|
<Field label="Workspace commands JSON" hint="Legacy `services` arrays still work, but `commands` supports both services and jobs.">
|
|
<div className="mb-2 flex items-center gap-2 text-sm text-muted-foreground">
|
|
<input
|
|
id="inherit-runtime-config"
|
|
type="checkbox"
|
|
className="rounded border-border"
|
|
checked={form.inheritRuntime}
|
|
onChange={(event) => {
|
|
const checked = event.target.checked;
|
|
setForm((current) => {
|
|
if (!current) return current;
|
|
if (!checked && !current.workspaceRuntime.trim() && inheritedRuntimeConfig) {
|
|
return { ...current, inheritRuntime: checked, workspaceRuntime: formatJson(inheritedRuntimeConfig) };
|
|
}
|
|
return { ...current, inheritRuntime: checked };
|
|
});
|
|
}}
|
|
/>
|
|
<label htmlFor="inherit-runtime-config">Inherit project workspace runtime config</label>
|
|
</div>
|
|
<Textarea
|
|
className="min-h-64 font-mono sm:min-h-96"
|
|
value={form.workspaceRuntime}
|
|
onChange={(event) => setForm((current) => current ? { ...current, workspaceRuntime: event.target.value } : current)}
|
|
disabled={form.inheritRuntime}
|
|
placeholder={'{\n "commands": [\n {\n "id": "web",\n "name": "web",\n "kind": "service",\n "command": "pnpm dev",\n "cwd": ".",\n "port": { "type": "auto" }\n },\n {\n "id": "db-migrate",\n "name": "db:migrate",\n "kind": "job",\n "command": "pnpm db:migrate",\n "cwd": "."\n }\n ]\n}'}
|
|
/>
|
|
</Field>
|
|
</div>
|
|
</details>
|
|
|
|
{configuredRuntimeServicePorts.length > 0 ? (
|
|
<div className="space-y-3 rounded-md border border-border bg-muted/20 p-4">
|
|
<div>
|
|
<div className="text-sm font-medium">Service ports</div>
|
|
<p className="mt-1 text-sm text-muted-foreground">
|
|
Set a fixed port for a service or leave it blank to use its configured automatic behavior. Editing an inherited service creates an execution-workspace runtime override.
|
|
</p>
|
|
</div>
|
|
<div className="grid gap-3 sm:grid-cols-2">
|
|
{configuredRuntimeServicePorts.map((service) => (
|
|
<Field key={`${service.collection}-${service.index}`} label={service.name} hint="Fixed port">
|
|
<Input
|
|
type="number"
|
|
min="1"
|
|
max="65535"
|
|
inputMode="numeric"
|
|
value={service.port ?? ""}
|
|
onChange={(event) => {
|
|
setForm((current) => {
|
|
if (!current) return current;
|
|
const parsed = current.inheritRuntime
|
|
? { ok: true as const, value: inheritedRuntimeConfig }
|
|
: parseWorkspaceRuntimeJson(current.workspaceRuntime);
|
|
if (!parsed.ok || !parsed.value) return current;
|
|
return {
|
|
...current,
|
|
inheritRuntime: false,
|
|
workspaceRuntime: formatJson(updateConfiguredRuntimeServicePort({
|
|
runtimeConfig: parsed.value,
|
|
service,
|
|
port: event.target.value,
|
|
})),
|
|
};
|
|
});
|
|
}}
|
|
/>
|
|
</Field>
|
|
))}
|
|
</div>
|
|
{configuredRuntimeServicePortWarnings.length > 0 ? (
|
|
<div className="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-sm text-destructive">
|
|
{configuredRuntimeServicePortWarnings.map((warning) => <p key={warning}>{warning}</p>)}
|
|
</div>
|
|
) : null}
|
|
<p className="text-sm text-muted-foreground">
|
|
Paperclip checks fixed ports again when a service starts and rejects cross-workspace conflicts.
|
|
</p>
|
|
</div>
|
|
) : null}
|
|
</div>
|
|
</div>
|
|
|
|
<div className="mt-6 flex flex-col items-stretch gap-3 sm:flex-row sm:flex-wrap sm:items-center">
|
|
<Button className="w-full sm:w-auto" disabled={!isDirty || updateWorkspace.isPending} onClick={saveChanges}>
|
|
{updateWorkspace.isPending ? <Loader2 className="mr-2 h-4 w-4 animate-spin" /> : null}
|
|
Save changes
|
|
</Button>
|
|
<Button
|
|
variant="outline"
|
|
className="w-full sm:w-auto"
|
|
disabled={!isDirty || updateWorkspace.isPending}
|
|
onClick={() => {
|
|
setForm(initialState);
|
|
setErrorMessage(null);
|
|
setRuntimeActionErrorMessage(null);
|
|
setRuntimeActionMessage(null);
|
|
}}
|
|
>
|
|
Reset
|
|
</Button>
|
|
{errorMessage ? <p className="text-sm text-destructive">{errorMessage}</p> : null}
|
|
{!errorMessage && !isDirty ? <p className="text-sm text-muted-foreground">No unsaved changes.</p> : null}
|
|
</div>
|
|
</CardContent>
|
|
</Card>
|
|
|
|
<Card className="rounded-none">
|
|
<CardHeader>
|
|
<CardTitle>Workspace context</CardTitle>
|
|
<CardDescription>Linked objects and relationships</CardDescription>
|
|
</CardHeader>
|
|
<CardContent>
|
|
<DetailRow label="Project">
|
|
{project ? <Link to={`/projects/${projectRef}`} className="hover:underline">{project.name}</Link> : <MonoValue value={workspace.projectId ?? "No project"} />}
|
|
</DetailRow>
|
|
<DetailRow label="Project workspace">
|
|
{project && linkedProjectWorkspace ? (
|
|
<WorkspaceLink project={project} workspace={linkedProjectWorkspace} />
|
|
) : workspace.projectWorkspaceId ? (
|
|
<MonoValue value={workspace.projectWorkspaceId} />
|
|
) : (
|
|
"None"
|
|
)}
|
|
</DetailRow>
|
|
<DetailRow label="Source task">
|
|
{sourceIssue ? (
|
|
<Link to={issueUrl(sourceIssue)} className="hover:underline">
|
|
{sourceIssue.identifier ?? sourceIssue.id} · {sourceIssue.title}
|
|
</Link>
|
|
) : workspace.sourceIssueId ? (
|
|
<MonoValue value={workspace.sourceIssueId} />
|
|
) : (
|
|
"None"
|
|
)}
|
|
</DetailRow>
|
|
<DetailRow label="Derived from">
|
|
{derivedWorkspace ? (
|
|
<Link to={executionWorkspaceTabPath(derivedWorkspace.id, workspaceIsolationControlsVisible ? "configuration" : "issues")} className="hover:underline">
|
|
{derivedWorkspace.name}
|
|
</Link>
|
|
) : workspace.derivedFromExecutionWorkspaceId ? (
|
|
<MonoValue value={workspace.derivedFromExecutionWorkspaceId} />
|
|
) : (
|
|
"None"
|
|
)}
|
|
</DetailRow>
|
|
<DetailRow label="Runtime provisioning">
|
|
<RuntimeProvisionStatusValue
|
|
status={runtimeProvisionStatus}
|
|
onViewLogs={() => handleTabChange("runtime_logs")}
|
|
/>
|
|
</DetailRow>
|
|
<DetailRow label="Workspace ID">
|
|
<MonoValue value={workspace.id} />
|
|
</DetailRow>
|
|
</CardContent>
|
|
</Card>
|
|
|
|
<Card className="rounded-none">
|
|
<CardHeader>
|
|
<CardTitle>Concrete location</CardTitle>
|
|
<CardDescription>Paths and refs</CardDescription>
|
|
</CardHeader>
|
|
<CardContent>
|
|
<DetailRow label="Working dir">
|
|
{workspace.cwd ? <MonoValue value={workspace.cwd} copy /> : "None"}
|
|
</DetailRow>
|
|
<DetailRow label="Provider ref">
|
|
{workspace.providerRef ? <MonoValue value={workspace.providerRef} copy /> : "None"}
|
|
</DetailRow>
|
|
<DetailRow label="Repo URL">
|
|
{workspace.repoUrl && isSafeExternalUrl(workspace.repoUrl) ? (
|
|
<div className="inline-flex max-w-full items-start gap-2">
|
|
<a href={workspace.repoUrl} target="_blank" rel="noreferrer" className="inline-flex min-w-0 items-center gap-1 break-all hover:underline">
|
|
{workspace.repoUrl}
|
|
<ExternalLink className="h-3.5 w-3.5 shrink-0" />
|
|
</a>
|
|
<CopyText text={workspace.repoUrl} className="shrink-0 text-muted-foreground hover:text-foreground" copiedLabel="Copied">
|
|
<Copy className="h-3.5 w-3.5" />
|
|
</CopyText>
|
|
</div>
|
|
) : workspace.repoUrl ? (
|
|
<MonoValue value={workspace.repoUrl} copy />
|
|
) : (
|
|
"None"
|
|
)}
|
|
</DetailRow>
|
|
<DetailRow label="Base ref">
|
|
{workspace.baseRef ? <MonoValue value={workspace.baseRef} copy /> : "None"}
|
|
</DetailRow>
|
|
<DetailRow label="Branch">
|
|
{workspace.branchName ? <MonoValue value={workspace.branchName} copy /> : "None"}
|
|
</DetailRow>
|
|
<DetailRow label="Opened">{formatDateTime(workspace.openedAt)}</DetailRow>
|
|
<DetailRow label="Last used">{formatDateTime(workspace.lastUsedAt)}</DetailRow>
|
|
<DetailRow label="Cleanup">
|
|
{workspace.cleanupEligibleAt
|
|
? `${formatDateTime(workspace.cleanupEligibleAt)}${workspace.cleanupReason ? ` · ${workspace.cleanupReason}` : ""}`
|
|
: "Not scheduled"}
|
|
</DetailRow>
|
|
</CardContent>
|
|
</Card>
|
|
</div>
|
|
) : activeTab === "runtime_logs" ? (
|
|
<Card className="rounded-none">
|
|
<CardHeader>
|
|
<CardTitle>Runtime and cleanup logs</CardTitle>
|
|
<CardDescription>Recent operations</CardDescription>
|
|
</CardHeader>
|
|
<CardContent>
|
|
{(opsView.kind === "loading" || opsView.kind === "reconnecting") ? (
|
|
<p className="text-sm text-muted-foreground">Loading workspace operations…</p>
|
|
) : opsView.kind === "error" ? (
|
|
<QueryErrorState
|
|
size="inline"
|
|
error={opsView.error}
|
|
action="load workspace operations"
|
|
onRetry={opsView.retry}
|
|
retrying={opsView.isFetching}
|
|
/>
|
|
) : workspaceOperationsQuery.data && workspaceOperationsQuery.data.length > 0 ? (
|
|
<div className="space-y-3">
|
|
{workspaceOperationsQuery.data.map((operation) => (
|
|
<div key={operation.id} className="rounded-none border border-border/80 bg-background px-4 py-3">
|
|
<div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
|
|
<div className="space-y-1">
|
|
<div className="text-sm font-medium">{operation.command ?? workspaceOperationPhaseLabel(operation.phase)}</div>
|
|
<div className="text-xs text-muted-foreground">
|
|
{formatDateTime(operation.startedAt)}
|
|
{operation.finishedAt ? ` → ${formatDateTime(operation.finishedAt)}` : ""}
|
|
</div>
|
|
{operation.stderrExcerpt ? (
|
|
<div className={cn("whitespace-pre-wrap break-words text-xs text-destructive", ANALYTICS_MASK_CLASS)}>{operation.stderrExcerpt}</div>
|
|
) : operation.stdoutExcerpt ? (
|
|
<div className={cn("whitespace-pre-wrap break-words text-xs text-muted-foreground", ANALYTICS_MASK_CLASS)}>{operation.stdoutExcerpt}</div>
|
|
) : null}
|
|
</div>
|
|
<StatusPill className="self-start">{operation.status}</StatusPill>
|
|
</div>
|
|
</div>
|
|
))}
|
|
</div>
|
|
) : (
|
|
<p className="text-sm text-muted-foreground">No workspace operations have been recorded yet.</p>
|
|
)}
|
|
</CardContent>
|
|
</Card>
|
|
) : activeTab === "issues" ? (
|
|
<div className="space-y-6">
|
|
<SummarySlotCard
|
|
companyId={workspace.companyId}
|
|
scopeKind="execution_workspace"
|
|
scopeId={workspace.id}
|
|
title="Workspace summary"
|
|
description="Summarizer keeps the latest workspace status, next step, and operator-needed items here."
|
|
/>
|
|
{linkedIssuesView.kind === "error" ? <QueryErrorState error={linkedIssuesView.error} action="load workspace tasks" onRetry={linkedIssuesView.retry} retrying={linkedIssuesView.isFetching} /> : (
|
|
<ExecutionWorkspaceIssuesList
|
|
companyId={workspace.companyId}
|
|
workspace={workspace}
|
|
issues={linkedIssues}
|
|
isLoading={linkedIssuesView.kind === "loading" || linkedIssuesView.kind === "reconnecting"}
|
|
error={null}
|
|
project={project}
|
|
/>
|
|
)}
|
|
</div>
|
|
) : activePluginTab ? (
|
|
<PluginSlotMount
|
|
slot={activePluginTab.slot}
|
|
context={pluginSlotContext}
|
|
missingBehavior="placeholder"
|
|
/>
|
|
) : isExecutionWorkspacePluginTab(activeTab) && workspacePluginDetailSlotsLoading ? (
|
|
<Card>
|
|
<CardContent className="py-6 text-sm text-muted-foreground">Loading workspace plugin...</CardContent>
|
|
</Card>
|
|
) : isExecutionWorkspacePluginTab(activeTab) && workspacePluginDetailSlotsError ? (
|
|
<Card>
|
|
<CardContent className="py-6 text-sm text-destructive">{workspacePluginDetailSlotsError}</CardContent>
|
|
</Card>
|
|
) : isExecutionWorkspacePluginTab(activeTab) ? (
|
|
<MissingPluginTabPlaceholder
|
|
defaultTabHref={executionWorkspaceTabPath(workspace.id, "issues")}
|
|
defaultTabLabel="Back to tasks"
|
|
/>
|
|
) : activeTab === "routines" ? (
|
|
<ExecutionWorkspaceRoutinesList
|
|
workspace={workspace}
|
|
project={project}
|
|
/>
|
|
) : (
|
|
<LegacyWorkspaceTabRedirect workspaceId={workspace.id} />
|
|
)}
|
|
</div>
|
|
<ExecutionWorkspaceCloseDialog
|
|
workspaceId={workspace.id}
|
|
workspaceName={workspace.name}
|
|
currentStatus={workspace.status}
|
|
open={closeDialogOpen}
|
|
onOpenChange={setCloseDialogOpen}
|
|
onClosed={(nextWorkspace) => {
|
|
queryClient.setQueryData(queryKeys.executionWorkspaces.detail(nextWorkspace.id), nextWorkspace);
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.overview(nextWorkspace.companyId) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.closeReadiness(nextWorkspace.id) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.workspaceOperations(nextWorkspace.id) });
|
|
if (project) {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.projects.detail(project.id) });
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.executionWorkspaces.list(project.companyId, { projectId: project.id }) });
|
|
}
|
|
if (sourceIssue) {
|
|
queryClient.invalidateQueries({ queryKey: queryKeys.issues.detail(sourceIssue.id) });
|
|
}
|
|
}}
|
|
/>
|
|
</>
|
|
);
|
|
}
|