"use client";
import Link from "@/components/routing/app-link";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { IconExternalLink, IconHexagon, IconPlus, IconSearch } from "@tabler/icons-react";
import { Alert, AlertDescription } from "@kandev/ui/alert";
import { Avatar, AvatarFallback, AvatarImage } from "@kandev/ui/avatar";
import { Badge } from "@kandev/ui/badge";
import { Button } from "@kandev/ui/button";
import { Input } from "@kandev/ui/input";
import {
Pagination,
PaginationContent,
PaginationItem,
PaginationNext,
PaginationPrevious,
} from "@kandev/ui/pagination";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@kandev/ui/select";
import { PageTopbar } from "@/components/page-topbar";
import { useLinearAvailable } from "@/hooks/domains/linear/use-linear-availability";
import {
formatRelative,
LinearErrorMessage,
stateBadgeClass,
} from "@/components/linear/linear-issue-common";
import { LinearIssueDialog } from "@/components/linear/linear-issue-dialog";
import { LinearQuickTaskLauncher } from "@/components/linear/linear-quick-task-launcher";
import { getLinearConfig, listLinearTeams, searchLinearIssues } from "@/lib/api/domains/linear-api";
import type { LinearIssue, LinearTeam } from "@/lib/types/linear";
import type { Workflow, WorkflowStep } from "@/lib/types/http";
const PAGE_SIZE = 25;
type LinearPageClientProps = {
workspaceId?: string;
workflows: Workflow[];
steps: WorkflowStep[];
};
function NotConfiguredNotice() {
return (
Linear is not configured.{" "}
Configure Linear
{" "}
to see your issues here.
);
}
function useLinearPageData(workspaceId?: string) {
const [loaded, setLoaded] = useState(false);
const [configured, setConfigured] = useState(false);
const [teams, setTeams] = useState([]);
useEffect(() => {
let cancelled = false;
async function load() {
if (!workspaceId) {
setLoaded(true);
return;
}
try {
const cfg = await getLinearConfig();
if (cancelled) return;
const ok = !!cfg && cfg.hasSecret;
setConfigured(ok);
if (ok) {
try {
const list = await listLinearTeams();
if (!cancelled) setTeams(list.teams ?? []);
} catch {
// Non-fatal: team filter just stays empty.
}
}
} finally {
if (!cancelled) setLoaded(true);
}
}
void load();
return () => {
cancelled = true;
};
}, [workspaceId]);
return { loaded, configured, teams };
}
type SearchState = {
items: LinearIssue[];
loading: boolean;
error: string | null;
page: number;
pageSize: number;
isLast: boolean;
goNext: () => void;
goPrev: () => void;
};
// useIssueSearch is page-based: it caches each page's cursor in `tokensRef` so
// the user can step backward without re-querying from the first page. Linear
// returns no total count, so the UI shows a row range plus a Page N indicator.
function useIssueSearch(
workspaceId: string | undefined,
query: string,
teamKey: string,
assigned: string,
): SearchState {
const [items, setItems] = useState([]);
const [page, setPage] = useState(1);
const [isLast, setIsLast] = useState(true);
const [loading, setLoading] = useState(false);
const [error, setError] = useState(null);
// tokens[i] is the page_token for page i+1; tokens[0] is always "".
const tokensRef = useRef([""]);
const reqRef = useRef(0);
const fetchPage = useCallback(
(p: number) =>
searchLinearIssues({
query: query || undefined,
teamKey: teamKey || undefined,
assigned: assigned || undefined,
pageToken: tokensRef.current[p - 1] || undefined,
maxResults: PAGE_SIZE,
}),
[query, teamKey, assigned],
);
const run = useCallback(
async (p: number) => {
if (!workspaceId) return;
const reqId = ++reqRef.current;
setLoading(true);
setError(null);
try {
const res = await fetchPage(p);
if (reqId !== reqRef.current) return;
setItems(res.issues ?? []);
setIsLast(res.isLast ?? true);
if (!res.isLast && res.nextPageToken) {
tokensRef.current[p] = res.nextPageToken;
}
} catch (err) {
if (reqId !== reqRef.current) return;
setError(err instanceof Error ? err.message : String(err));
} finally {
if (reqId === reqRef.current) setLoading(false);
}
},
[workspaceId, fetchPage],
);
// Reset cursor stack and snap back to page 1 when filters change.
useEffect(() => {
tokensRef.current = [""];
setPage(1);
}, [workspaceId, query, teamKey, assigned]);
// 250ms debounce keeps the keyboard input from firing a request per char.
useEffect(() => {
if (!workspaceId) return;
const id = setTimeout(() => void run(page), 250);
return () => clearTimeout(id);
}, [run, page, workspaceId]);
return {
items,
loading,
error,
page,
pageSize: PAGE_SIZE,
isLast,
goNext: () => {
if (!isLast) setPage((p) => p + 1);
},
goPrev: () => {
setPage((p) => Math.max(1, p - 1));
},
};
}
function AssigneeCell({ issue }: { issue: LinearIssue }) {
if (!issue.assigneeName) {
return Unassigned;
}
return (
{issue.assigneeIcon && }
{issue.assigneeName.charAt(0)}
{issue.assigneeName}
);
}
function IssueRow({
issue,
onOpen,
onStartTask,
}: {
issue: LinearIssue;
onOpen: (i: LinearIssue) => void;
onStartTask: (i: LinearIssue) => void;
}) {
const relative = formatRelative(issue.updated);
return (
);
}
function FilterControls({
query,
setQuery,
teamKey,
setTeamKey,
assigned,
setAssigned,
teams,
}: {
query: string;
setQuery: (v: string) => void;
teamKey: string;
setTeamKey: (v: string) => void;
assigned: string;
setAssigned: (v: string) => void;
teams: LinearTeam[];
}) {
return (
);
}
function PaginationBar({
page,
pageSize,
itemCount,
isLast,
onNext,
onPrev,
}: {
page: number;
pageSize: number;
itemCount: number;
isLast: boolean;
onNext: () => void;
onPrev: () => void;
}) {
if (page === 1 && isLast) return null;
const start = (page - 1) * pageSize + 1;
const end = (page - 1) * pageSize + itemCount;
const prevDisabled = page <= 1;
const nextDisabled = isLast;
return (
{itemCount === 0 ? "No results" : `${start}–${end}`}
{
e.preventDefault();
if (!prevDisabled) onPrev();
}}
aria-disabled={prevDisabled}
className={prevDisabled ? "pointer-events-none opacity-50" : "cursor-pointer"}
/>
Page {page}
{
e.preventDefault();
if (!nextDisabled) onNext();
}}
aria-disabled={nextDisabled}
className={nextDisabled ? "pointer-events-none opacity-50" : "cursor-pointer"}
/>
);
}
function PageShell({ children }: { children: React.ReactNode }) {
return (
);
}
function DisabledNotice() {
return (
Linear integration is disabled.{" "}
Re-enable it in settings
.
);
}
function ResultsArea({
search,
empty,
onOpen,
onStartTask,
}: {
search: SearchState;
empty: boolean;
onOpen: (issue: LinearIssue) => void;
onStartTask: (issue: LinearIssue) => void;
}) {
return (
{search.error && !search.loading && (
)}
{!search.error && empty && (
No issues match your filters.
)}
{search.items.map((issue) => (
))}
{search.loading && search.items.length === 0 && (
Loading issues…
)}
);
}
export function LinearPageClient({ workspaceId, workflows, steps }: LinearPageClientProps) {
const available = useLinearAvailable();
const { loaded, configured, teams } = useLinearPageData(workspaceId);
const [query, setQuery] = useState("");
const [teamKey, setTeamKey] = useState("");
const [assigned, setAssigned] = useState("me");
const search = useIssueSearch(workspaceId, query, teamKey, assigned);
const [openIssue, setOpenIssue] = useState(null);
const [launchIssue, setLaunchIssue] = useState(null);
const empty = useMemo(
() => loaded && configured && !search.loading && search.items.length === 0,
[loaded, configured, search.loading, search.items.length],
);
if (!workspaceId) {
return (
);
}
if (loaded && !configured) {
return (
);
}
if (!available && loaded && configured) {
return (
);
}
return (
!open && setOpenIssue(null)}
workspaceId={workspaceId}
identifier={openIssue?.identifier ?? null}
initialIssue={openIssue}
onStartTask={setLaunchIssue}
/>
setLaunchIssue(null)}
/>
);
}