@kortix/sdk 0.9.98

package/dist/react/use-kortix-master.js

@@ -0,0 +1,958 @@
+'use client';
+/**
+ * kortix-master React Query layer — the generic (host-agnostic) hooks over
+ * the `./kortix-master` transport client: query keys, caching/polling config,
+ * optimistic-update/invalidation wiring, and the pure normalization/derivation
+ * helpers that used to live inline in six apps/web hook files
+ * (`use-credentials.ts`, `use-kortix-projects.ts`, `use-kortix-tasks.ts`,
+ * `use-kortix-tickets.ts`, `use-milestones.ts`, `use-sandbox-services.ts`).
+ *
+ * Everything here is transport + cache plumbing — it has zero knowledge of
+ * any host's auth stack. The one thing the original web hooks pulled from
+ * `useAuth()`/`getUserHandle()` (the current human's id + derived @handle,
+ * used to partition query-cache keys and to stamp audit/authorship fields on
+ * ticket mutations) is threaded through as an explicit `identity` parameter
+ * (`KortixMasterIdentity`) instead — see that type below. Any host (web,
+ * mobile, whitelabel-demo, …) supplies its own identity and gets the same
+ * hooks.
+ *
+ * The "active server" resolution (which sandbox these calls hit) does NOT
+ * need injecting: `useServerStore`/`getActiveOpenCodeUrl` (`../state/server-store`)
+ * is already a host-agnostic part of this SDK — apps/web's
+ * `@/stores/server-store` is already just a re-export of it. Hooks here use
+ * it directly, exactly like the existing `./use-runtime-reconnect` and
+ * `./use-opencode-events` SDK hooks do.
+ *
+ * Query keys below are copied VERBATIM from the pre-migration web hooks
+ * (array literal contents, ordering, and types unchanged) — this is a hard
+ * cache-compatibility requirement, not a style choice.
+ */
+import { useMutation, useQuery, useQueryClient, keepPreviousData, } from '@tanstack/react-query';
+import { useServerStore } from '../state/server-store.js';
+import { 
+// Credentials
+listCredentials, listCredentialEvents, upsertCredential, revealCredential, deleteCredential, 
+// Projects
+listKortixProjects, getKortixProject, getKortixProjectBySession, listKortixProjectSessions, deleteKortixProject, patchKortixProject, 
+// Tasks
+listTasks, getTask, listTaskEvents, getTaskStatus, createTask, updateTask, startTask, approveTask, deleteTask, 
+// Tickets
+listTickets, getTicket, listTicketEvents, createTicket, updateTicket, updateTicketStatus, assignTicket, unassignTicket, commentTicket, deleteTicket, listColumns, replaceColumns, listFields, replaceFields, listTemplates, replaceTemplates, ensurePmSession, listProjectAgents, createProjectAgent, updateProjectAgent, deleteProjectAgent, getAgentPersona, getProjectActivity, 
+// Milestones
+listMilestones, getMilestone, listMilestoneEvents, createMilestone, updateMilestone, closeMilestone, reopenMilestone, deleteMilestone, 
+// Services
+listServices, listServiceTemplates, getServiceLogs, serviceAction as sdkServiceAction, reconcileServices, registerService, systemReload, } from '../opencode/client.js';
+// ═════════════════════════════════════════════════════════════════════════
+// Credentials — /kortix/projects/:id/credentials
+// ═════════════════════════════════════════════════════════════════════════
+export const credentialKeys = {
+    list: (pid) => ['kortix', 'credentials', pid ?? ''],
+    events: (pid, name) => ['kortix', 'credentials', pid, name, 'events'],
+};
+export function useCredentials(projectId) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: credentialKeys.list(projectId),
+        queryFn: () => listCredentials(serverUrl, projectId),
+        enabled: !!projectId,
+        refetchInterval: 10_000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useCredentialEvents(projectId, name) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: credentialKeys.events(projectId ?? '', name ?? ''),
+        queryFn: () => listCredentialEvents(serverUrl, projectId, name),
+        enabled: !!projectId && !!name,
+        refetchInterval: 10_000,
+    });
+}
+export function useUpsertCredential() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ...body }) => upsertCredential(serverUrl, projectId, body),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: credentialKeys.list(vars.projectId) });
+        },
+    });
+}
+/** Reveal returns the decrypted value. Each call is audit-logged as a read. */
+export function useRevealCredential() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, name }) => revealCredential(serverUrl, projectId, name),
+        onSuccess: (_res, vars) => {
+            // Refresh list so last_read_at updates on the card
+            qc.invalidateQueries({ queryKey: credentialKeys.list(vars.projectId) });
+            qc.invalidateQueries({ queryKey: credentialKeys.events(vars.projectId, vars.name) });
+        },
+    });
+}
+export function useDeleteCredential() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, name }) => deleteCredential(serverUrl, projectId, name),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: credentialKeys.list(vars.projectId) });
+        },
+    });
+}
+// ═════════════════════════════════════════════════════════════════════════
+// Kortix projects — /kortix/projects
+// ═════════════════════════════════════════════════════════════════════════
+export const kortixKeys = {
+    projects: () => ['kortix', 'projects'],
+    project: (id) => ['kortix', 'projects', id],
+};
+export function useKortixProjects(identity, _args, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: [...kortixKeys.projects(), identity.userId ?? 'anonymous', serverUrl],
+        queryFn: () => listKortixProjects(serverUrl),
+        enabled: !identity.isLoading && !!identity.userId && !!serverUrl && (options.enabled ?? true),
+        staleTime: 30_000,
+        gcTime: 5 * 60 * 1000,
+        refetchOnWindowFocus: true,
+        retry: 3,
+        retryDelay: (attempt) => Math.min(1000 * 2 ** attempt, 10000),
+    });
+}
+export function useKortixProject(identity, id) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: [...kortixKeys.project(id), identity.userId ?? 'anonymous', serverUrl],
+        queryFn: () => getKortixProject(serverUrl, id),
+        enabled: !identity.isLoading && !!identity.userId && !!serverUrl && !!id,
+        staleTime: 15_000,
+        gcTime: 5 * 60 * 1000,
+        retry: 2,
+        // Keep previous data while a new query (e.g. from a runtime URL change)
+        // is loading. Prevents the skeleton flash.
+        placeholderData: keepPreviousData,
+    });
+}
+export function useKortixProjectForSession(identity, sessionId, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ['kortix', 'projects', 'by-session', sessionId, identity.userId ?? 'anonymous', serverUrl],
+        queryFn: async () => {
+            try {
+                return await getKortixProjectBySession(serverUrl, sessionId);
+            }
+            catch {
+                return null;
+            }
+        },
+        enabled: !identity.isLoading && !!identity.userId && !!serverUrl && !!sessionId && (options.enabled ?? true),
+        staleTime: 15_000,
+        gcTime: 5 * 60 * 1000,
+        placeholderData: keepPreviousData,
+    });
+}
+/**
+ * Fetch sessions linked to a specific project.
+ * Returns OpenCode session objects enriched with title, time, etc.
+ */
+export function useKortixProjectSessions(identity, projectId, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    // `listKortixProjectSessions` itself returns `unknown[]` (its enriched
+    // OpenCode-session shape isn't schema-typed at the source) — mirror that
+    // here rather than lying about the element shape with `any`.
+    return useQuery({
+        queryKey: ['kortix', 'projects', projectId, 'sessions', identity.userId ?? 'anonymous', serverUrl],
+        queryFn: () => listKortixProjectSessions(serverUrl, projectId),
+        enabled: !identity.isLoading && !!identity.userId && !!serverUrl && !!projectId && (options.enabled ?? true),
+        staleTime: 15_000,
+        gcTime: 5 * 60 * 1000,
+        refetchOnWindowFocus: true,
+        retry: 2,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useDeleteProject() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (id) => deleteKortixProject(serverUrl, id),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: kortixKeys.projects() });
+        },
+    });
+}
+export function usePatchProject() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, ...body }) => patchKortixProject(serverUrl, id, body),
+        onSuccess: (_d, vars) => {
+            qc.invalidateQueries({ queryKey: kortixKeys.project(vars.id) });
+            qc.invalidateQueries({ queryKey: kortixKeys.projects() });
+        },
+    });
+}
+const taskKeys = {
+    all: ['kortix', 'tasks'],
+    byProject: (projectId) => ['kortix', 'tasks', projectId],
+    single: (id) => ['kortix', 'tasks', 'detail', id],
+    events: (id) => ['kortix', 'tasks', 'events', id],
+    status: (id) => ['kortix', 'tasks', 'status', id],
+};
+const VALID_STATUSES = [
+    'todo', 'in_progress', 'input_needed', 'awaiting_review',
+    'completed', 'cancelled',
+];
+/** Pure — the daemon's `status` isn't schema-validated, so this normalizes
+ * raw rows (defaulting an unrecognized status to `'todo'`) before trusting
+ * `KortixTask['status']`. `raw` is genuinely unvalidated wire data — duck-type
+ * via `unknown` rather than assume the shape. Exported for direct unit testing. */
+export function normalizeTask(raw) {
+    const r = (raw && typeof raw === 'object' ? raw : {});
+    const status = VALID_STATUSES.includes(r.status)
+        ? r.status
+        : 'todo';
+    return {
+        id: r.id,
+        project_id: r.project_id,
+        title: r.title || '',
+        description: r.description || '',
+        verification_condition: r.verification_condition || '',
+        status,
+        result: r.result ?? null,
+        verification_summary: r.verification_summary ?? null,
+        blocking_question: r.blocking_question ?? null,
+        owner_session_id: r.owner_session_id ?? null,
+        owner_agent: r.owner_agent ?? null,
+        requested_by_session_id: r.requested_by_session_id ?? null,
+        started_at: r.started_at ?? null,
+        completed_at: r.completed_at ?? null,
+        created_at: r.created_at,
+        updated_at: r.updated_at,
+    };
+}
+export function useKortixTasks(projectId, status, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: [...taskKeys.all, projectId, status],
+        queryFn: async () => {
+            const rows = await listTasks(serverUrl, { projectId, status });
+            return Array.isArray(rows) ? rows.map(normalizeTask) : [];
+        },
+        enabled: !!projectId && (options.enabled ?? true),
+        refetchInterval: options.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useKortixTask(id, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: taskKeys.single(id),
+        queryFn: async () => {
+            const raw = await getTask(serverUrl, id);
+            return normalizeTask(raw);
+        },
+        enabled: !!id && (options.enabled ?? true),
+        refetchInterval: options.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useKortixTaskEvents(id, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: taskKeys.events(id),
+        queryFn: async () => {
+            const rows = await listTaskEvents(serverUrl, id);
+            return Array.isArray(rows) ? rows : [];
+        },
+        enabled: !!id && (options.enabled ?? true),
+        refetchInterval: options.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useKortixTaskStatus(id, options = {}) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: taskKeys.status(id),
+        queryFn: async () => {
+            return getTaskStatus(serverUrl, id);
+        },
+        enabled: !!id && (options.enabled ?? true),
+        refetchInterval: options.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useCreateKortixTask() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (data) => createTask(serverUrl, data),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: taskKeys.all });
+        },
+    });
+}
+export function useUpdateKortixTask() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, ...data }) => updateTask(serverUrl, id, data),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: taskKeys.all });
+        },
+    });
+}
+export function useStartKortixTask() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id }) => startTask(serverUrl, id),
+        onSuccess: (task) => {
+            qc.invalidateQueries({ queryKey: taskKeys.all });
+            qc.invalidateQueries({ queryKey: ['kortix', 'projects'] });
+            if (task?.project_id) {
+                qc.invalidateQueries({ queryKey: ['kortix', 'projects', task.project_id] });
+                qc.invalidateQueries({ queryKey: ['kortix', 'projects', task.project_id, 'sessions'] });
+            }
+        },
+    });
+}
+export function useApproveKortixTask() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (id) => approveTask(serverUrl, id),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: taskKeys.all });
+        },
+    });
+}
+export function useDeleteKortixTask() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (id) => deleteTask(serverUrl, id),
+        onSuccess: () => {
+            qc.invalidateQueries({ queryKey: taskKeys.all });
+        },
+    });
+}
+// ═════════════════════════════════════════════════════════════════════════
+// Tickets — /kortix/tickets, plus columns/fields/templates/agents/pm-session
+// /activity project sub-routes
+// ═════════════════════════════════════════════════════════════════════════
+export const ticketKeys = {
+    tickets: (pid) => ['kortix', 'tickets', pid ?? ''],
+    ticket: (id) => ['kortix', 'ticket', id],
+    events: (id) => ['kortix', 'ticket', id, 'events'],
+    columns: (pid) => ['kortix', 'columns', pid],
+    fields: (pid) => ['kortix', 'fields', pid],
+    templates: (pid) => ['kortix', 'templates', pid],
+    agents: (pid) => ['kortix', 'agents', pid],
+};
+export function useTickets(projectId, opts) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.tickets(projectId),
+        queryFn: () => listTickets(serverUrl, projectId),
+        enabled: !!projectId && (opts?.enabled ?? true),
+        refetchInterval: opts?.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useTicket(id, opts) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.ticket(id ?? ''),
+        queryFn: () => getTicket(serverUrl, id),
+        enabled: !!id && (opts?.enabled ?? true),
+        refetchInterval: opts?.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useTicketEvents(id, opts) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.events(id ?? ''),
+        queryFn: () => listTicketEvents(serverUrl, id),
+        enabled: !!id && (opts?.enabled ?? true),
+        refetchInterval: opts?.pollingEnabled === false ? false : 3000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useCreateTicket(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (body) => createTicket(serverUrl, {
+            ...body,
+            actor_type: 'user',
+            actor_id: handle,
+            created_by_type: 'user',
+            created_by_id: handle,
+        }),
+        onSuccess: (_d, vars) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(vars.project_id) });
+        },
+    });
+}
+export function useUpdateTicket(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, ...body }) => updateTicket(serverUrl, id, { ...body, actor_type: 'user', actor_id: handle }),
+        onSuccess: (t) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(t.project_id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.ticket(t.id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.events(t.id) });
+        },
+    });
+}
+export function useUpdateTicketStatus(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, status }) => updateTicketStatus(serverUrl, id, { status, actor_type: 'user', actor_id: handle }),
+        onSuccess: (r) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(r.ticket.project_id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.ticket(r.ticket.id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.events(r.ticket.id) });
+        },
+    });
+}
+export function useAssignTicket(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, assignee_type, assignee_id }) => assignTicket(serverUrl, id, { assignee_type, assignee_id, actor_type: 'user', actor_id: handle }),
+        onSuccess: (r) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(r.ticket.project_id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.ticket(r.ticket.id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.events(r.ticket.id) });
+        },
+    });
+}
+export function useUnassignTicket(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, assignee_type, assignee_id }) => unassignTicket(serverUrl, id, { assignee_type, assignee_id, actor_type: 'user', actor_id: handle }),
+        onSuccess: (r) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(r.ticket.project_id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.ticket(r.ticket.id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.events(r.ticket.id) });
+        },
+    });
+}
+export function useCommentTicket(identity) {
+    const qc = useQueryClient();
+    const handle = identity.handle;
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ id, body }) => commentTicket(serverUrl, id, { body, actor_type: 'user', actor_id: handle }),
+        onSuccess: (_d, vars) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.events(vars.id) });
+            qc.invalidateQueries({ queryKey: ticketKeys.ticket(vars.id) });
+        },
+    });
+}
+export function useDeleteTicket() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: (id) => deleteTicket(serverUrl, id),
+        onSuccess: () => { qc.invalidateQueries({ queryKey: ['kortix', 'tickets'] }); },
+    });
+}
+// ── Columns ──────────────────────────────────────────────────────────────────
+export function useColumns(projectId) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.columns(projectId ?? ''),
+        queryFn: () => listColumns(serverUrl, projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+    });
+}
+export function useReplaceColumns() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, columns }) => replaceColumns(serverUrl, projectId, columns),
+        onSuccess: (_d, vars) => {
+            qc.invalidateQueries({ queryKey: ticketKeys.columns(vars.projectId) });
+            qc.invalidateQueries({ queryKey: ticketKeys.tickets(vars.projectId) });
+        },
+    });
+}
+// ── Fields ───────────────────────────────────────────────────────────────────
+export function useFields(projectId) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.fields(projectId ?? ''),
+        queryFn: () => listFields(serverUrl, projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+    });
+}
+export function useReplaceFields() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, fields }) => replaceFields(serverUrl, projectId, fields),
+        onSuccess: (_d, vars) => { qc.invalidateQueries({ queryKey: ticketKeys.fields(vars.projectId) }); },
+    });
+}
+// ── Templates ────────────────────────────────────────────────────────────────
+export function useTemplates(projectId) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.templates(projectId ?? ''),
+        queryFn: () => listTemplates(serverUrl, projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+    });
+}
+export function useReplaceTemplates() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, templates }) => replaceTemplates(serverUrl, projectId, templates),
+        onSuccess: (_d, vars) => { qc.invalidateQueries({ queryKey: ticketKeys.templates(vars.projectId) }); },
+    });
+}
+// ── PM chat session ──────────────────────────────────────────────────────────
+/**
+ * Ensure (create-if-missing) a project-level session bound to the Project
+ * Manager agent. Idempotent on the backend — first call creates + binds,
+ * subsequent calls return the existing session id so the thread continues.
+ */
+export function useEnsurePmSession() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId }) => ensurePmSession(serverUrl, projectId),
+    });
+}
+// ── Agents (team) ────────────────────────────────────────────────────────────
+export function useProjectAgents(projectId) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ticketKeys.agents(projectId ?? ''),
+        queryFn: () => listProjectAgents(serverUrl, projectId),
+        enabled: !!projectId,
+        staleTime: 30_000,
+    });
+}
+export function useCreateProjectAgent() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, slug, name, body_md, execution_mode, tool_groups, default_assignee_columns, default_model, color_hue, icon, }) => createProjectAgent(serverUrl, projectId, {
+            slug, name, body_md, execution_mode, tool_groups, default_assignee_columns, default_model, color_hue, icon,
+        }),
+        onSuccess: (_d, vars) => { qc.invalidateQueries({ queryKey: ticketKeys.agents(vars.projectId) }); },
+    });
+}
+export function useUpdateProjectAgent() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, slug, ...body }) => updateProjectAgent(serverUrl, projectId, slug, body),
+        onSuccess: (_d, vars) => { qc.invalidateQueries({ queryKey: ticketKeys.agents(vars.projectId) }); },
+    });
+}
+export function useDeleteProjectAgent() {
+    const qc = useQueryClient();
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useMutation({
+        mutationFn: ({ projectId, slug }) => deleteProjectAgent(serverUrl, projectId, slug),
+        onSuccess: (_d, vars) => { qc.invalidateQueries({ queryKey: ticketKeys.agents(vars.projectId) }); },
+    });
+}
+export function useAgentPersona(projectId, slug, opts) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ['kortix', 'agent-persona', projectId ?? '', slug ?? ''],
+        queryFn: () => getAgentPersona(serverUrl, projectId, slug),
+        enabled: !!projectId && !!slug && (opts?.enabled ?? true),
+    });
+}
+// ── Project activity / notifications ─────────────────────────────────────────
+export function useProjectActivity(projectId, opts) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: ['kortix', 'project-activity', projectId ?? ''],
+        queryFn: () => getProjectActivity(serverUrl, projectId, 200),
+        enabled: !!projectId && (opts?.enabled ?? true),
+        refetchInterval: opts?.pollingEnabled === false ? false : 10_000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+/**
+ * Count events that are meaningful for the current human:
+ *   - they were assigned to this user (user.assignee_id === handle)
+ *   - they were @-mentioned in a comment body (message contains `@handle`)
+ *   - a teammate commented on a ticket the user is tracking (not implemented;
+ *     for v1 the assignment/@-mention covers the critical surface).
+ *
+ * Filters out events the user themselves produced. Uses the client-side
+ * `sinceIso` (usually localStorage last-seen for the project) as the cutoff.
+ *
+ * Pure — takes `handle` as an explicit parameter rather than reading it from
+ * an auth hook. Exported for direct unit testing.
+ */
+export function computeUnread(events, handle, sinceIso) {
+    const byTicket = new Map();
+    let latest = null;
+    let total = 0;
+    if (!events)
+        return { total, byTicket, latestAt: null };
+    const h = handle.toLowerCase();
+    const mentionRe = new RegExp(`(^|\\s)@${h.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\b`, 'i');
+    for (const ev of events) {
+        if (sinceIso && ev.created_at <= sinceIso)
+            continue;
+        if (!latest || ev.created_at > latest)
+            latest = ev.created_at;
+        // Skip events the user themselves initiated (actor_type=user,actor_id=handle).
+        if (ev.actor_type === 'user' && (ev.actor_id ?? '').toLowerCase() === h)
+            continue;
+        let hit = false;
+        if (ev.type === 'assigned') {
+            try {
+                const p = ev.payload_json ? JSON.parse(ev.payload_json) : null;
+                if (p?.assignee_type === 'user' && (p.assignee_id ?? '').toLowerCase() === h)
+                    hit = true;
+            }
+            catch { }
+        }
+        else if (ev.type === 'comment' && ev.message && mentionRe.test(ev.message)) {
+            hit = true;
+        }
+        if (!hit)
+            continue;
+        total++;
+        byTicket.set(ev.ticket_id, (byTicket.get(ev.ticket_id) ?? 0) + 1);
+    }
+    return { total, byTicket, latestAt: latest };
+}
+/**
+ * Turn the raw activity stream into a list of user-facing notifications.
+ * Scoped to assignments + @mentions, same rule set as computeUnread — we
+ * just keep the event itself so the UI can render actor avatars, ticket
+ * titles, relative times, and the comment body that caused a mention.
+ *
+ * Pure — same `handle`-as-parameter shape as {@link computeUnread}.
+ */
+export function computeNotifications(events, handle, sinceIso) {
+    if (!events)
+        return [];
+    const h = handle.toLowerCase();
+    const mentionRe = new RegExp(`(^|\\s)@${h.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')}\\b`, 'i');
+    const out = [];
+    for (const ev of events) {
+        if (sinceIso && ev.created_at <= sinceIso)
+            continue;
+        if (ev.actor_type === 'user' && (ev.actor_id ?? '').toLowerCase() === h)
+            continue;
+        if (ev.type === 'assigned') {
+            try {
+                const p = ev.payload_json ? JSON.parse(ev.payload_json) : null;
+                if (p?.assignee_type === 'user' && (p.assignee_id ?? '').toLowerCase() === h) {
+                    out.push({ event: ev, ticket_id: ev.ticket_id, kind: 'assigned' });
+                }
+            }
+            catch { }
+        }
+        else if (ev.type === 'comment' && ev.message && mentionRe.test(ev.message)) {
+            out.push({ event: ev, ticket_id: ev.ticket_id, kind: 'mention', relatedComment: ev });
+        }
+    }
+    return out;
+}
+const LAST_SEEN_KEY = (projectId, handle) => `kortix:activity-last-seen:${projectId}:${handle}`;
+export const LAST_SEEN_EVENT = 'kortix:last-seen-changed';
+export function readLastSeen(projectId, handle) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        return window.localStorage.getItem(LAST_SEEN_KEY(projectId, handle));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLastSeen(projectId, handle, iso) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        window.localStorage.setItem(LAST_SEEN_KEY(projectId, handle), iso);
+        // Same-tab listeners (e.g. the sidebar project rows) don't receive the
+        // native 'storage' event — emit a custom one so they refresh instantly.
+        window.dispatchEvent(new CustomEvent(LAST_SEEN_EVENT, { detail: { projectId, handle, iso } }));
+    }
+    catch { }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+export function safeParseJsonArray(s) {
+    if (!s)
+        return [];
+    try {
+        const v = JSON.parse(s);
+        return Array.isArray(v) ? v.map(String) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function parseCustomFields(json) {
+    if (!json)
+        return {};
+    try {
+        const v = JSON.parse(json);
+        return v && typeof v === 'object' ? v : {};
+    }
+    catch {
+        return {};
+    }
+}
+// ═════════════════════════════════════════════════════════════════════════
+// Milestones — /kortix/projects/:id/milestones
+// ═════════════════════════════════════════════════════════════════════════
+export const milestoneKeys = {
+    list: (pid, status = 'all') => ['kortix', 'milestones', pid ?? '', status],
+    detail: (pid, ref) => ['kortix', 'milestone', pid, ref],
+    events: (pid, ref) => ['kortix', 'milestone', pid, ref, 'events'],
+};
+export function useMilestones(projectId, statusFilter = 'all') {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: milestoneKeys.list(projectId, statusFilter),
+        queryFn: () => listMilestones(serverUrl, projectId, statusFilter),
+        enabled: !!projectId,
+        refetchInterval: 5000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useMilestone(projectId, ref) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: milestoneKeys.detail(projectId ?? '', ref ?? ''),
+        queryFn: () => getMilestone(serverUrl, projectId, ref),
+        enabled: !!projectId && !!ref,
+        refetchInterval: 5000,
+        refetchIntervalInBackground: false,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useMilestoneEvents(projectId, ref) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: milestoneKeys.events(projectId ?? '', ref ?? ''),
+        queryFn: () => listMilestoneEvents(serverUrl, projectId, ref),
+        enabled: !!projectId && !!ref,
+        refetchInterval: 5000,
+        placeholderData: keepPreviousData,
+    });
+}
+export function useCreateMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ...body }) => createMilestone(serverUrl, projectId, body),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+        },
+    });
+}
+export function useUpdateMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ref, patch }) => updateMilestone(serverUrl, projectId, ref, patch),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+            qc.invalidateQueries({ queryKey: milestoneKeys.detail(vars.projectId, vars.ref) });
+        },
+    });
+}
+export function useCloseMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ref, summary_md, cancelled }) => closeMilestone(serverUrl, projectId, ref, { summary_md, cancelled }),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+            qc.invalidateQueries({ queryKey: milestoneKeys.detail(vars.projectId, vars.ref) });
+        },
+    });
+}
+export function useReopenMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ref }) => reopenMilestone(serverUrl, projectId, ref),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+            qc.invalidateQueries({ queryKey: milestoneKeys.detail(vars.projectId, vars.ref) });
+        },
+    });
+}
+export function useDeleteMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ projectId, ref }) => deleteMilestone(serverUrl, projectId, ref),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+        },
+    });
+}
+/** Link or unlink a ticket's milestone. Goes through PATCH /kortix/tickets/:id. */
+export function useSetTicketMilestone() {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const qc = useQueryClient();
+    return useMutation({
+        mutationFn: ({ ticketId, milestoneId }) => updateTicket(serverUrl, ticketId, { milestone_id: milestoneId }),
+        onSuccess: (_res, vars) => {
+            qc.invalidateQueries({ queryKey: ['kortix', 'milestones', vars.projectId] });
+            qc.invalidateQueries({ queryKey: ['kortix', 'tickets', vars.projectId] });
+            qc.invalidateQueries({ queryKey: ['kortix', 'ticket', vars.ticketId] });
+        },
+    });
+}
+// ═════════════════════════════════════════════════════════════════════════
+// Sandbox services — /kortix/services
+// ═════════════════════════════════════════════════════════════════════════
+const getActiveServerUrl = () => {
+    return useServerStore.getState().getActiveServerUrl();
+};
+export const serviceKeys = {
+    all: ['sandbox-services'],
+    list: (serverUrl, includeAll) => ['sandbox-services', serverUrl, includeAll ? 'all' : 'visible'],
+    logs: (serverUrl, serviceId) => ['sandbox-services', serverUrl, 'logs', serviceId],
+    templates: (serverUrl) => ['sandbox-services', serverUrl, 'templates'],
+};
+export function useSandboxServices(identity, options) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    const includeAll = options?.includeAll ?? false;
+    return useQuery({
+        queryKey: [...serviceKeys.list(serverUrl, includeAll), identity.userId ?? 'anonymous'],
+        queryFn: async () => {
+            if (!serverUrl)
+                return [];
+            return listServices(serverUrl, includeAll);
+        },
+        enabled: (options?.enabled ?? true) && !identity.isLoading && !!identity.userId && !!serverUrl,
+        staleTime: 5_000,
+        gcTime: 60_000,
+        refetchInterval: 5_000,
+        refetchIntervalInBackground: false,
+        refetchOnWindowFocus: true,
+    });
+}
+export function useSandboxServiceTemplates(identity, options) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: [...serviceKeys.templates(serverUrl), identity.userId ?? 'anonymous'],
+        queryFn: async () => {
+            if (!serverUrl)
+                return [];
+            return listServiceTemplates(serverUrl);
+        },
+        enabled: (options?.enabled ?? true) && !identity.isLoading && !!identity.userId && !!serverUrl,
+        staleTime: 60_000,
+        gcTime: 5 * 60_000,
+    });
+}
+export function useSandboxServiceLogs(identity, serviceId, options) {
+    const serverUrl = useServerStore((s) => s.getActiveServerUrl());
+    return useQuery({
+        queryKey: serviceId
+            ? [...serviceKeys.logs(serverUrl, serviceId), identity.userId ?? 'anonymous']
+            : ['sandbox-services', serverUrl, 'logs', 'none', identity.userId ?? 'anonymous'],
+        queryFn: async () => {
+            if (!serverUrl || !serviceId)
+                return [];
+            return getServiceLogs(serverUrl, serviceId);
+        },
+        enabled: (options?.enabled ?? true) && !identity.isLoading && !!identity.userId && !!serverUrl && !!serviceId,
+        staleTime: 3_000,
+        gcTime: 60_000,
+        refetchInterval: serviceId ? 3_000 : false,
+        refetchIntervalInBackground: false,
+    });
+}
+export function useSandboxServiceAction() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ serviceId, action }) => {
+            const serverUrl = getActiveServerUrl();
+            if (!serverUrl)
+                throw new Error('No active instance selected');
+            return sdkServiceAction(serverUrl, serviceId, action);
+        },
+        onSuccess: () => {
+            const serverUrl = getActiveServerUrl();
+            queryClient.invalidateQueries({ queryKey: serviceKeys.all });
+            if (serverUrl) {
+                queryClient.invalidateQueries({ queryKey: serviceKeys.templates(serverUrl) });
+            }
+        },
+    });
+}
+export function useSandboxServiceReconcile() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ reload } = {}) => {
+            const serverUrl = getActiveServerUrl();
+            if (!serverUrl)
+                throw new Error('No active instance selected');
+            return reconcileServices(serverUrl, reload);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: serviceKeys.all });
+        },
+    });
+}
+export function useRegisterSandboxService() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (payload) => {
+            const serverUrl = getActiveServerUrl();
+            if (!serverUrl)
+                throw new Error('No active instance selected');
+            return registerService(serverUrl, payload);
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: serviceKeys.all });
+        },
+    });
+}
+// Reload already has a home in the SDK (`systemReload` in `../opencode/client`,
+// backing `POST /kortix/services/system/reload`) — reused directly rather
+// than duplicated here. It resolves the active runtime URL itself (the same
+// zustand state `getActiveServerUrl()` above reads).
+export function useSandboxRuntimeReload() {
+    return useMutation({
+        mutationFn: ({ mode }) => systemReload(mode),
+    });
+}
+//# sourceMappingURL=use-kortix-master.js.map