@kortix/ui 0.0.0-stage → 0.14.4

package/dist/workspace/sidebar/invitations-menu-group.js

@@ -0,0 +1,56 @@
+'use client';
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, } from '../../primitives/dropdown-menu.js';
+import { EntityAvatar } from '../../primitives/entity-avatar.js';
+import Loading from '../../primitives/loading.js';
+import { errorToast } from '../../primitives/toast.js';
+import { inviteLandingPath } from '../project-selector/project-selector-model.js';
+import { useMyInvites } from '../../internal/hooks/account/use-my-invites.js';
+import { useTranslations } from '../../i18n/index.js';
+import { useCurrentAccountStore } from '../../internal/stores/current-account-store.js';
+import { acceptAccountInviteAndLand } from '@kortix/sdk';
+import { qk } from '@kortix/sdk/react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useUiRouter } from '../../providers/ui-provider.js';
+/**
+ * Pending invites at the top of the Switch Project menu. A user who already
+ * has a project lands in it, not on the chooser, so this is where an invite
+ * that arrives later is found. Renders nothing when there are none.
+ */
+export function InvitationsMenuGroup() {
+    const t = useTranslations('projectChooser');
+    const router = useUiRouter();
+    const queryClient = useQueryClient();
+    const setSelectedAccountId = useCurrentAccountStore((state) => state.setSelectedAccountId);
+    const invitesQuery = useMyInvites();
+    const invites = invitesQuery.data ?? [];
+    const join = useMutation({
+        mutationFn: (invite) => acceptAccountInviteAndLand(invite.invite_id, invite),
+        onSuccess: async ({ landing }) => {
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey: qk.accounts.scope() }),
+                queryClient.invalidateQueries({ queryKey: qk.projects.scope() }),
+            ]);
+            setSelectedAccountId(landing.accountId);
+            // A workspace invite lands on the joined account's door; the plain door
+            // reopened the project this browser remembered (KRTX-1731).
+            router.push(inviteLandingPath(landing));
+        },
+        onError: (error) => {
+            errorToast(error instanceof Error ? error.message : t('joinError'));
+        },
+    });
+    if (invites.length === 0)
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsxs(DropdownMenuGroup, { className: "p-0.5", "data-testid": "switcher-invitations", children: [_jsxs(DropdownMenuLabel, { className: "px-1.5 text-sm", children: [t('invitations'), " \u00B7 ", invites.length] }), invites.map((invite) => {
+                        const workspace = invite.account_name ?? t('unnamedWorkspace');
+                        const title = invite.projects.length > 0 ? invite.projects.map((p) => p.name).join(', ') : workspace;
+                        const joining = join.isPending && join.variables?.invite_id === invite.invite_id;
+                        return (_jsxs(DropdownMenuItem, { className: "cursor-pointer px-1.5", disabled: join.isPending, 
+                            // Keep the menu open while the join runs; navigation closes it.
+                            onSelect: (event) => {
+                                event.preventDefault();
+                                join.mutate(invite);
+                            }, children: [_jsx(EntityAvatar, { label: title, size: "sm" }), _jsx("span", { className: "min-w-0 flex-1 truncate text-sm font-medium", children: title }), joining ? (_jsx(Loading, { className: "text-muted-foreground size-3.5" })) : (_jsx("span", { className: "text-muted-foreground text-xs", children: t('join') }))] }, invite.invite_id));
+                    })] }), _jsx(DropdownMenuSeparator, {})] }));
+}

package/dist/workspace/sidebar/modal/rename-session-modal.d.ts

@@ -0,0 +1,10 @@
+interface RenameSessionModalProps {
+    projectId: string;
+    sessionId: string | null;
+    currentName?: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSaved?: () => void;
+}
+export declare function RenameSessionModal({ projectId, sessionId, currentName, open, onOpenChange, onSaved, }: RenameSessionModalProps): import("react").JSX.Element;
+export {};

package/dist/workspace/sidebar/modal/rename-session-modal.js

@@ -0,0 +1,41 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../../primitives/button.js';
+import { Input } from '../../../primitives/input.js';
+import Loading from '../../../primitives/loading.js';
+import { Modal, ModalBody, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalTitle, } from '../../../primitives/modal.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { useEffect, useState } from 'react';
+import { MAX_SESSION_NAME_LENGTH, useRenameSession } from '../../../session/actions/use-rename-session.js';
+export function RenameSessionModal({ projectId, sessionId, currentName, open, onOpenChange, onSaved, }) {
+    const tI18nHardcoded = useTranslations('hardcodedUi');
+    const [value, setValue] = useState(currentName ?? '');
+    useEffect(() => {
+        if (open)
+            setValue(currentName ?? '');
+    }, [open, currentName]);
+    const renameMutation = useRenameSession(projectId, sessionId, {
+        onSuccess: () => {
+            onSaved?.();
+            onOpenChange(false);
+        },
+    });
+    const trimmed = value.trim();
+    const isUnchanged = trimmed === (currentName ?? '').trim();
+    const submit = () => {
+        if (!sessionId || renameMutation.isPending || isUnchanged)
+            return;
+        renameMutation.mutate(trimmed);
+    };
+    return (_jsx(Modal, { open: open, onOpenChange: (o) => {
+            if (!renameMutation.isPending)
+                onOpenChange(o);
+        }, children: _jsxs(ModalContent, { className: "lg:max-w-md", children: [_jsxs(ModalHeader, { children: [_jsx(ModalTitle, { children: tI18nHardcoded.raw('autoFeaturesCoWorkerProjectSidebarModalRenameSessionModalJsx265e123d') }), _jsx(ModalDescription, { children: tI18nHardcoded.raw('autoFeaturesCoWorkerProjectSidebarModalRenameSessionModalJsx19d80686') })] }), _jsx(ModalBody, { children: _jsx(Input, { autoFocus: true, value: value, maxLength: MAX_SESSION_NAME_LENGTH, placeholder: tI18nHardcoded.raw('autoFeaturesCoWorkerProjectSidebarModalRenameSessionModalJsx2412472b'), onChange: (e) => setValue(e.target.value), onKeyDown: (e) => {
+                            if (e.nativeEvent.isComposing)
+                                return;
+                            if (e.key === 'Enter') {
+                                e.preventDefault();
+                                submit();
+                            }
+                        } }) }), _jsxs(ModalFooter, { className: "sm:justify-between", children: [_jsx(Button, { variant: "outline-ghost", size: "sm", className: "w-full sm:w-auto", onClick: () => onOpenChange(false), disabled: renameMutation.isPending, children: tI18nHardcoded.raw('i18nComplete.text19766ed6ccb2') }), _jsxs(Button, { size: "sm", className: "w-full sm:w-auto", onClick: submit, disabled: renameMutation.isPending || isUnchanged, children: [renameMutation.isPending ? _jsx(Loading, { className: "size-4 shrink-0" }) : null, tI18nHardcoded.raw('i18nComplete.text1509f561f241')] })] })] }) }));
+}

package/dist/workspace/sidebar/modal/session-labels-modal.d.ts

@@ -0,0 +1,13 @@
+import { type ProjectSession } from '@kortix/sdk';
+interface SessionLabelsModalProps {
+    projectId: string;
+    session: Pick<ProjectSession, 'session_id' | 'labels'> | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+/**
+ * Edit a session's free-form labels. Enter or comma adds the typed label;
+ * Backspace in an empty field removes the last one. Save replaces the list.
+ */
+export declare function SessionLabelsModal({ projectId, session, open, onOpenChange }: SessionLabelsModalProps): import("react").JSX.Element;
+export {};

package/dist/workspace/sidebar/modal/session-labels-modal.js

@@ -0,0 +1,91 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '../../../primitives/badge.js';
+import { Button } from '../../../primitives/button.js';
+import { Input } from '../../../primitives/input.js';
+import Loading from '../../../primitives/loading.js';
+import { Modal, ModalBody, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalTitle, } from '../../../primitives/modal.js';
+import { errorToast, successToast } from '../../../primitives/toast.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { updateProjectSession } from '@kortix/sdk';
+import { qk } from '@kortix/sdk/react';
+import { XIcon } from '@phosphor-icons/react';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useState } from 'react';
+import { addSessionLabel, sameLabels } from './session-labels.js';
+/**
+ * Edit a session's free-form labels. Enter or comma adds the typed label;
+ * Backspace in an empty field removes the last one. Save replaces the list.
+ */
+export function SessionLabelsModal({ projectId, session, open, onOpenChange }) {
+    const t = useTranslations('sidebar.labels');
+    const queryClient = useQueryClient();
+    const [labels, setLabels] = useState([]);
+    const [draft, setDraft] = useState('');
+    const [problem, setProblem] = useState(null);
+    // Reset the form each time the modal opens for a session (state adjusted
+    // during render, not in an effect: no extra paint with stale labels).
+    const openFor = open && session ? session.session_id : null;
+    const [loadedFor, setLoadedFor] = useState(null);
+    if (openFor !== loadedFor) {
+        setLoadedFor(openFor);
+        if (openFor) {
+            setLabels(session?.labels ?? []);
+            setDraft('');
+            setProblem(null);
+        }
+    }
+    const save = useMutation({
+        mutationFn: (next) => {
+            if (!session)
+                throw new Error('No session selected');
+            return updateProjectSession(projectId, session.session_id, { labels: next });
+        },
+        onSuccess: () => {
+            successToast(t('saved'));
+            onOpenChange(false);
+        },
+        onError: (err) => errorToast(err instanceof Error ? err.message : t('failed')),
+        // Label filters are server-side, so every filtered list must refetch.
+        onSettled: () => queryClient.invalidateQueries({ queryKey: qk.project.sessionsScope(projectId) }),
+    });
+    const commitDraft = () => {
+        const result = addSessionLabel(labels, draft);
+        if ('problem' in result) {
+            setProblem(result.problem);
+            return null;
+        }
+        setProblem(null);
+        setLabels(result.labels);
+        setDraft('');
+        return result.labels;
+    };
+    const submit = () => {
+        if (save.isPending)
+            return;
+        const next = draft.trim() ? commitDraft() : labels;
+        if (next)
+            save.mutate(next);
+    };
+    const unchanged = !draft.trim() && sameLabels(labels, session?.labels ?? []);
+    return (_jsx(Modal, { open: open, onOpenChange: (next) => {
+            if (!save.isPending)
+                onOpenChange(next);
+        }, children: _jsxs(ModalContent, { className: "lg:max-w-md", children: [_jsxs(ModalHeader, { children: [_jsx(ModalTitle, { children: t('title') }), _jsx(ModalDescription, { children: t('description') })] }), _jsxs(ModalBody, { className: "space-y-3", children: [_jsx(Input, { autoFocus: true, value: draft, maxLength: 64, placeholder: t('placeholder'), "aria-label": t('placeholder'), "aria-invalid": problem !== null, onChange: (event) => {
+                                setDraft(event.target.value);
+                                setProblem(null);
+                            }, onKeyDown: (event) => {
+                                if (event.nativeEvent.isComposing)
+                                    return;
+                                if (event.key === 'Enter' || event.key === ',') {
+                                    event.preventDefault();
+                                    if (draft.trim())
+                                        commitDraft();
+                                    else if (event.key === 'Enter')
+                                        submit();
+                                }
+                                else if (event.key === 'Backspace' && !draft && labels.length > 0) {
+                                    setLabels(labels.slice(0, -1));
+                                }
+                            } }), problem ? _jsx("p", { className: "text-destructive text-xs", children: t(problem) }) : null, labels.length > 0 ? (_jsx("ul", { className: "flex flex-wrap gap-1.5", "aria-label": t('title'), children: labels.map((label) => (_jsx("li", { children: _jsxs(Badge, { variant: "outline", size: "sm", className: "gap-1 pr-0.5", children: [_jsx("span", { className: "max-w-60 truncate", children: label }), _jsx("button", { type: "button", className: "text-muted-foreground hover:text-foreground rounded-sm transition-colors duration-fast", "aria-label": t('remove', { label }), onClick: () => setLabels(labels.filter((item) => item !== label)), children: _jsx(XIcon, { className: "size-3" }) })] }) }, label))) })) : (_jsx("p", { className: "text-muted-foreground text-xs", children: t('empty') }))] }), _jsxs(ModalFooter, { className: "sm:justify-between", children: [_jsx(Button, { variant: "outline-ghost", size: "sm", className: "w-full sm:w-auto", onClick: () => onOpenChange(false), disabled: save.isPending, children: t('cancel') }), _jsxs(Button, { size: "sm", className: "w-full sm:w-auto", onClick: submit, disabled: save.isPending || unchanged, children: [save.isPending ? _jsx(Loading, { className: "size-4 shrink-0" }) : null, t('save')] })] })] }) }));
+}

package/dist/workspace/sidebar/modal/session-labels.d.ts

@@ -0,0 +1,10 @@
+/** Mirrors `SessionLabelsSchema` in `@kortix/api-contract`: the server refuses anything else. */
+export declare const MAX_SESSION_LABELS = 20;
+export declare const MAX_SESSION_LABEL_LENGTH = 64;
+/** Add one typed label. A duplicate is a no-op; an empty draft changes nothing. */
+export declare function addSessionLabel(labels: readonly string[], draft: string): {
+    labels: string[];
+} | {
+    problem: 'tooLong' | 'tooMany';
+};
+export declare function sameLabels(a: readonly string[], b: readonly string[]): boolean;

package/dist/workspace/sidebar/modal/session-labels.js

@@ -0,0 +1,17 @@
+/** Mirrors `SessionLabelsSchema` in `@kortix/api-contract`: the server refuses anything else. */
+export const MAX_SESSION_LABELS = 20;
+export const MAX_SESSION_LABEL_LENGTH = 64;
+/** Add one typed label. A duplicate is a no-op; an empty draft changes nothing. */
+export function addSessionLabel(labels, draft) {
+    const label = draft.trim();
+    if (!label || labels.includes(label))
+        return { labels: [...labels] };
+    if (label.length > MAX_SESSION_LABEL_LENGTH)
+        return { problem: 'tooLong' };
+    if (labels.length >= MAX_SESSION_LABELS)
+        return { problem: 'tooMany' };
+    return { labels: [...labels, label] };
+}
+export function sameLabels(a, b) {
+    return a.length === b.length && a.every((label, i) => label === b[i]);
+}

package/dist/workspace/sidebar/modal/session-public-link-section.d.ts

@@ -0,0 +1,13 @@
+/**
+ * "Public link" in the Share dialog: a read-only, sign-in-free link to this
+ * session's conversation. One live link per session (the API returns the
+ * existing one on a second create), so the section shows either that link with
+ * Copy and Revoke, or the one button that creates it.
+ *
+ * Mounted inside `ModalContent`, so the share list is read only while the
+ * dialog is open.
+ */
+export declare function SessionPublicLinkSection({ projectId, sessionId, }: {
+    projectId: string;
+    sessionId: string;
+}): import("react").JSX.Element;

package/dist/workspace/sidebar/modal/session-public-link-section.js

@@ -0,0 +1,66 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PublicShareLinkConfirm } from '../../../internal/share/public-share-link-confirm.js';
+import { Button } from '../../../primitives/button.js';
+import { ConfirmDialog } from '../../../primitives/confirm-dialog.js';
+import Hint from '../../../primitives/hint.js';
+import { Label } from '../../../primitives/label.js';
+import Loading from '../../../primitives/loading.js';
+import { errorToast, successToast } from '../../../primitives/toast.js';
+import { usePublicShareLink } from '../../../internal/share/use-public-share-link.js';
+import { publicShareUrl, useRevokePublicShare, useSessionPublicShares, } from '../../../internal/share/use-session-public-shares.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { findActiveTranscriptShare } from '@kortix/sdk';
+import { CheckIcon, CopyIcon, LinkSimpleIcon } from '@phosphor-icons/react';
+import { useEffect, useRef, useState } from 'react';
+// Module-level so `usePublicShareLink` sees one stable input object.
+const TRANSCRIPT_SHARE_INPUT = { transcript: true };
+/**
+ * "Public link" in the Share dialog: a read-only, sign-in-free link to this
+ * session's conversation. One live link per session (the API returns the
+ * existing one on a second create), so the section shows either that link with
+ * Copy and Revoke, or the one button that creates it.
+ *
+ * Mounted inside `ModalContent`, so the share list is read only while the
+ * dialog is open.
+ */
+export function SessionPublicLinkSection({ projectId, sessionId, }) {
+    const t = useTranslations('hardcodedUi.publicTranscriptShare');
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const { shares, isLoading, isError } = useSessionPublicShares(projectId, sessionId);
+    const link = usePublicShareLink({ projectId, sessionId, input: TRANSCRIPT_SHARE_INPUT });
+    const { revoke, revokingId } = useRevokePublicShare(projectId, sessionId);
+    const [confirmRevoke, setConfirmRevoke] = useState(false);
+    const [copied, setCopied] = useState(false);
+    const copiedTimer = useRef(null);
+    useEffect(() => () => {
+        if (copiedTimer.current)
+            clearTimeout(copiedTimer.current);
+    }, []);
+    const active = findActiveTranscriptShare(shares);
+    const url = active ? publicShareUrl(active.public_path) : null;
+    const isRevoking = !!active && revokingId === active.share_id;
+    const copy = async () => {
+        if (!url)
+            return;
+        try {
+            await navigator.clipboard.writeText(url);
+            setCopied(true);
+            successToast(tI18nComplete.raw('textd0f24de8dbc6'));
+            if (copiedTimer.current)
+                clearTimeout(copiedTimer.current);
+            copiedTimer.current = setTimeout(() => setCopied(false), 2000);
+        }
+        catch {
+            errorToast(tI18nComplete.raw('text167c96824acb'));
+        }
+    };
+    return (_jsxs("section", { className: "space-y-2", "data-testid": "session-public-link", children: [_jsxs("div", { className: "space-y-1", children: [_jsx(Label, { children: t('sectionTitle') }), _jsx("p", { className: "text-muted-foreground text-xs", children: t('sectionDescription') })] }), isLoading ? (_jsx("div", { className: "flex justify-center py-2", children: _jsx(Loading, { className: "size-4 shrink-0" }) })) : isError ? (
+            // The list 403s for a member who is neither the session's creator nor
+            // a project manager. "Create" would show a link state we cannot read.
+            _jsx("p", { className: "text-muted-foreground text-xs", children: tI18nComplete.raw('text93bce1d8f18d') })) : active ? (_jsxs("div", { className: "bg-popover flex items-center gap-2 rounded-md border py-1 pr-1 pl-3", children: [_jsx("span", { className: "text-muted-foreground min-w-0 flex-1 truncate font-mono text-xs", children: url }), _jsx(Hint, { label: copied ? tI18nComplete.raw('textd12860c21e78') : tI18nComplete.raw('textdbf362d4f210'), side: "bottom", children: _jsx(Button, { variant: "ghost", size: "icon-sm", "aria-label": tI18nComplete.raw('textdbf362d4f210'), disabled: !url, onClick: () => void copy(), children: copied ? (_jsx(CheckIcon, { className: "text-kortix-green size-4" })) : (_jsx(CopyIcon, { className: "size-4" })) }) }), _jsxs(Button, { variant: "ghost", size: "sm", disabled: isRevoking, onClick: () => setConfirmRevoke(true), children: [isRevoking ? _jsx(Loading, { className: "size-4 shrink-0" }) : null, tI18nComplete.raw('text87e6d00bbf53')] })] })) : (_jsxs(Button, { variant: "outline", size: "sm", onClick: link.copyLink, disabled: !link.canShare || link.isPending, children: [link.isPending ? (_jsx(Loading, { className: "size-4 shrink-0" })) : (_jsx(LinkSimpleIcon, { className: "size-4 shrink-0" })), t('create')] })), _jsx(PublicShareLinkConfirm, { confirmation: link.confirmation }), _jsx(ConfirmDialog, { open: confirmRevoke, onOpenChange: setConfirmRevoke, title: tI18nComplete.raw('text3d3b295854fe'), description: t('revokeDescription'), confirmLabel: tI18nComplete.raw('text87e6d00bbf53'), confirmVariant: "destructive", onConfirm: () => {
+                    if (active)
+                        revoke(active.share_id);
+                    setConfirmRevoke(false);
+                } })] }));
+}

package/dist/workspace/sidebar/modal/share-session-access.d.ts

@@ -0,0 +1,33 @@
+import type { ProjectSession } from '@kortix/sdk';
+import type { SharingMode } from '../../../access/sharing-intent.js';
+/**
+ * How the viewer stands to ONE session's access policy.
+ *
+ * `owner`    — created it. Picks any mode, including "Only you".
+ * `delegate` — does not own it but governs it anyway, because nobody human
+ *              does: a trigger/agent run is stamped with a service account, so
+ *              the API hands the policy to project managers instead.
+ * `viewer`   — it was shared with them. They read who else has access; they do
+ *              not change it.
+ */
+export type SessionAccessRole = 'owner' | 'delegate' | 'viewer';
+export interface SessionAccessView {
+    role: SessionAccessRole;
+    canEdit: boolean;
+    /**
+     * Modes the viewer must not pick because saving one would revoke their OWN
+     * access with no way back. Only "Only you" does that, and only for someone
+     * who is not the owner — "you" in that label is always the OWNER, never the
+     * person editing.
+     */
+    disabledModes: SharingMode[];
+    /** Whose session this is, in the second person when it is the viewer's. */
+    ownerLabel: string;
+}
+type SessionOwnership = Pick<ProjectSession, 'is_owner' | 'can_manage_sharing' | 'owner_name' | 'owner_email' | 'visibility' | 'sharing'>;
+/** The owner's name for display. "You" when the viewer owns it. */
+export declare function sessionOwnerName(session: SessionOwnership): string;
+export declare function sessionAccessView(session: SessionOwnership): SessionAccessView;
+/** One sentence naming exactly who can open the session right now. */
+export declare function sessionAccessSummary(session: SessionOwnership): string;
+export {};

package/dist/workspace/sidebar/modal/share-session-access.js

@@ -0,0 +1,44 @@
+/** The owner's name for display. "You" when the viewer owns it. */
+export function sessionOwnerName(session) {
+    if (session.is_owner !== false)
+        return 'You';
+    return session.owner_name || session.owner_email || 'Another member';
+}
+export function sessionAccessView(session) {
+    // `can_manage_sharing` is the server's verdict and the only one that matters —
+    // the Save button is decoration if the PUT 403s. Absent on older payloads, so
+    // only an explicit `false` withholds editing.
+    const canEdit = session.can_manage_sharing !== false;
+    const isOwner = session.is_owner !== false;
+    const role = isOwner ? 'owner' : canEdit ? 'delegate' : 'viewer';
+    return {
+        role,
+        canEdit,
+        disabledModes: isOwner ? [] : ['private'],
+        ownerLabel: sessionOwnerName(session),
+    };
+}
+function countPhrase(count, singular) {
+    if (count <= 0)
+        return null;
+    return `${count} ${count === 1 ? singular : `${singular}s`}`;
+}
+/** One sentence naming exactly who can open the session right now. */
+export function sessionAccessSummary(session) {
+    const owner = sessionOwnerName(session);
+    if (session.visibility === 'project')
+        return 'Every member of this project can open it.';
+    if (session.visibility === 'restricted') {
+        const sharing = session.sharing;
+        const memberIds = sharing && sharing.mode === 'members' ? (sharing.memberIds ?? []) : [];
+        const groupIds = sharing && sharing.mode === 'members' ? (sharing.groupIds ?? []) : [];
+        const parts = [countPhrase(memberIds.length, 'member'), countPhrase(groupIds.length, 'group')]
+            .filter((part) => part !== null)
+            .join(' and ');
+        const holder = owner === 'You' ? 'you' : owner;
+        if (!parts)
+            return `Only ${holder} can open it.`;
+        return `${holder === 'you' ? 'You' : holder} and ${parts} can open it.`;
+    }
+    return owner === 'You' ? 'Only you can open it.' : `Only ${owner} can open it.`;
+}

package/dist/workspace/sidebar/modal/share-session-cache.d.ts

@@ -0,0 +1,15 @@
+import type { QueryClient } from '@tanstack/react-query';
+/**
+ * What a share changes besides who can open the session: its pooled provider
+ * keys.
+ *
+ * The gateway uses nobody's personal keys in a shared session, so the API
+ * switches a selection the shared session could not use to the keys shared
+ * with the whole project (`PUT /projects/:id/sessions/:id/sharing`). The
+ * Provider keys panel reads the selection from `useSessionProviderSecretPools`
+ * (@kortix/sdk/react), whose key sits outside `qk.project.sessionsScope`, so
+ * the share dialog's session refresh never reached it. The panel kept the
+ * pre-share selection and showed it as "unavailable"; saving that stale view
+ * would store an empty selection and stop the session's model.
+ */
+export declare function refreshAfterShare(queryClient: QueryClient, projectId: string, sessionId: string): Promise<void>;

package/dist/workspace/sidebar/modal/share-session-cache.js

@@ -0,0 +1,16 @@
+/**
+ * What a share changes besides who can open the session: its pooled provider
+ * keys.
+ *
+ * The gateway uses nobody's personal keys in a shared session, so the API
+ * switches a selection the shared session could not use to the keys shared
+ * with the whole project (`PUT /projects/:id/sessions/:id/sharing`). The
+ * Provider keys panel reads the selection from `useSessionProviderSecretPools`
+ * (@kortix/sdk/react), whose key sits outside `qk.project.sessionsScope`, so
+ * the share dialog's session refresh never reached it. The panel kept the
+ * pre-share selection and showed it as "unavailable"; saving that stale view
+ * would store an empty selection and stop the session's model.
+ */
+export function refreshAfterShare(queryClient, projectId, sessionId) {
+    return queryClient.invalidateQueries({ queryKey: ['session-provider-secret-pools', projectId, sessionId] });
+}

package/dist/workspace/sidebar/modal/share-session-modal.d.ts

@@ -0,0 +1,8 @@
+import { type ProjectSession } from '@kortix/sdk';
+export declare function ShareSessionModal({ projectId, session, open, onOpenChange, onSaved, }: {
+    projectId: string;
+    session: ProjectSession | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSaved?: () => void;
+}): import("react").JSX.Element;

package/dist/workspace/sidebar/modal/share-session-modal.js

@@ -0,0 +1,109 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from '../../../primitives/button.js';
+import { InfoBanner } from '../../../primitives/info-banner.js';
+import Loading from '../../../primitives/loading.js';
+import { Modal, ModalBody, ModalContent, ModalDescription, ModalFooter, ModalHeader, ModalTitle, } from '../../../primitives/modal.js';
+import { errorToast, successToast } from '../../../primitives/toast.js';
+import { SharingPicker, intentToSelection, isSharingComplete, selectionToIntent, } from '../../../access/sharing-picker.js';
+import { useTranslations } from '../../../i18n/index.js';
+import { useUiHostConfig } from '../../../providers/ui-provider.js';
+import { getSessionOversight, setProjectSessionSharing } from '@kortix/sdk';
+import { sessionOversightQueryKey } from '../../../access/iam/session-oversight-card.js';
+import { ShieldCheckIcon } from '@phosphor-icons/react';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useEffect, useState } from 'react';
+import { SessionPublicLinkSection } from './session-public-link-section.js';
+import { sessionAccessSummary, sessionAccessView } from './share-session-access.js';
+import { refreshAfterShare } from './share-session-cache.js';
+/**
+ * The three options, worded from the EDITOR's seat.
+ *
+ * "Only you" is the trap this copy exists to avoid repeating: the stored value
+ * is `visibility: 'private'`, which means "the session's OWNER only". Rendered
+ * to somebody who is not the owner it promised the opposite of what saving it
+ * did — they lost the session. A non-owner therefore gets the honest label
+ * below, disabled, instead of a second-person one that lies.
+ */
+const SESSION_SHARING_COPY = {
+    heading: 'Who can open this session',
+    project: { label: 'Whole project', desc: 'Every member of this project.' },
+    private: { label: 'Only you', desc: 'Nobody else can open this session.' },
+    members: { label: 'Specific people', desc: 'Only the members and groups you choose.' },
+};
+function delegateCopy(ownerLabel, tI18nComplete) {
+    return {
+        ...SESSION_SHARING_COPY,
+        private: {
+            label: tI18nComplete('text0df9df285277', { value0: ownerLabel }),
+            desc: tI18nComplete.raw('text38b08d83da73'),
+        },
+    };
+}
+export function ShareSessionModal({ projectId, session, open, onOpenChange, onSaved, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const tI18nHardcoded = useTranslations('hardcodedUi');
+    const tOversight = useTranslations('sessionOversight');
+    const [sharing, setSharing] = useState({
+        mode: 'private',
+        memberIds: [],
+        groupIds: [],
+    });
+    useEffect(() => {
+        if (!open || !session)
+            return;
+        setSharing(intentToSelection(session.sharing ?? { mode: 'private', ownerId: '' }));
+    }, [open, session]);
+    // Disclose the account's session-oversight policy: while it is on, account
+    // owners and admins can open this session whatever is picked below. Read only
+    // while the dialog is open (a user action), and silently absent on any error
+    // — the IAM read never toasts (`showErrors: false`).
+    const accountId = session?.account_id ?? null;
+    const { accountApiEnabled, publicSharesEnabled } = useUiHostConfig();
+    const oversightQuery = useQuery({
+        queryKey: sessionOversightQueryKey(accountId ?? ''),
+        queryFn: () => getSessionOversight(accountId),
+        enabled: open && !!accountId && accountApiEnabled,
+        staleTime: 30_000,
+        retry: false,
+    });
+    const oversightOn = oversightQuery.data?.enabled === true;
+    const queryClient = useQueryClient();
+    const save = useMutation({
+        mutationFn: () => {
+            if (!isSharingComplete(sharing)) {
+                throw new Error('Pick at least one member, or choose another option.');
+            }
+            return setProjectSessionSharing(projectId, session.session_id, selectionToIntent(sharing));
+        },
+        onSuccess: () => {
+            successToast(tI18nHardcoded.raw('i18nComplete.textd8b630796604'));
+            // A share can switch the session's provider keys (share-session-cache.ts).
+            void refreshAfterShare(queryClient, projectId, session.session_id);
+            onSaved?.();
+            onOpenChange(false);
+        },
+        onError: (err) => errorToast(err.message || tI18nHardcoded.raw('i18nComplete.text68d66e06fd0f')),
+    });
+    const view = session
+        ? sessionAccessView(session)
+        : { role: 'owner', canEdit: true, disabledModes: [], ownerLabel: 'You' };
+    // Never let the editor save a mode they are not allowed to pick. A
+    // machine-owned session opens on `private`, and that is exactly the one a
+    // delegate must not keep — saving it would revoke their own access.
+    const blockedSelection = view.disabledModes.includes(sharing.mode);
+    return (_jsx(Modal, { open: open, onOpenChange: (o) => {
+            if (!save.isPending)
+                onOpenChange(o);
+        }, children: _jsxs(ModalContent, { className: "lg:max-w-md", children: [_jsxs(ModalHeader, { children: [_jsx(ModalTitle, { children: tI18nHardcoded('autoFeaturesCoWorkerProjectSidebarModalShareSessionModalJsxc5c9cc41') }), _jsx(ModalDescription, { children: view.role === 'owner'
+                                ? tI18nHardcoded('autoFeaturesCoWorkerProjectSidebarModalShareSessionModalJsxb29062b4')
+                                : view.role === 'delegate'
+                                    ? tI18nHardcoded('autoFeaturesWorkspaceProjectSidebarModalShareSessionModalDelegateDescription', { owner: view.ownerLabel })
+                                    : tI18nHardcoded('autoFeaturesWorkspaceProjectSidebarModalShareSessionModalViewerDescription', { owner: view.ownerLabel }) })] }), _jsxs(ModalBody, { className: "max-h-[60vh] space-y-5 overflow-y-auto", children: [view.canEdit ? (_jsx(SharingPicker, { projectId: projectId, value: sharing, onChange: setSharing, copy: view.role === 'owner'
+                                ? SESSION_SHARING_COPY
+                                : delegateCopy(view.ownerLabel, tI18nComplete), disabledModes: view.disabledModes })) : (
+                        // Read-only, not hidden: a person a session was shared with should
+                        // still be able to see who else is in it. Withholding that is what
+                        // sent people to the editable dialog in the first place.
+                        _jsx("p", { className: "text-foreground text-sm", "data-testid": "session-access-summary", children: session ? sessionAccessSummary(session) : null })), oversightOn ? (_jsx(InfoBanner, { tone: "neutral", icon: ShieldCheckIcon, "data-testid": "session-oversight-disclosure", children: tOversight.raw('shareDisclosure') })) : null, view.canEdit && session && publicSharesEnabled ? (_jsx(SessionPublicLinkSection, { projectId: projectId, sessionId: session.session_id })) : null] }), _jsxs(ModalFooter, { className: "sm:justify-between", children: [_jsx(Button, { variant: "outline-ghost", size: "sm", className: "w-full sm:w-auto", onClick: () => onOpenChange(false), disabled: save.isPending, children: view.canEdit ? 'Cancel' : 'Close' }), view.canEdit && (_jsxs(Button, { size: "sm", onClick: () => save.mutate(), disabled: save.isPending || !isSharingComplete(sharing) || blockedSelection, className: "w-full sm:w-auto", children: [save.isPending && _jsx(Loading, {}), tI18nHardcoded.raw('i18nComplete.text1509f561f241')] }))] })] }) }));
+}

package/dist/workspace/sidebar/nav-row-meta.d.ts

@@ -0,0 +1,14 @@
+import type { SidebarNavItemId } from '../../internal/stores/sidebar-nav-store.js';
+import { type ReactNode } from 'react';
+export interface NavRowMeta {
+    label: string;
+    icon: ReactNode;
+    href: string;
+}
+/**
+ * Label, glyph, destination and availability of every customizable nav row,
+ * read through the same gates the sidebar rows use. A row this project does
+ * not offer (flag off, permission denied) is absent from the result, so the
+ * Customize sidebar modal and the More menu never list a dead row.
+ */
+export declare function useNavRowMeta(projectId: string): Partial<Record<SidebarNavItemId, NavRowMeta>>;