@jini-ai/admin 0.3.9 → 0.4.0

package/dist/source-control/controllers/source-control.controller.js

@@ -0,0 +1,70 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection, sourceControlSummary, sourceControlErrorMessage } from '../rules.js';
+export function createSourceControlController({ api, permissions = [] }, _optional = {}) {
+    const grants = new Set(permissions), store = createControllerStore({ initial: { providers: [], credentials: [], drafts: {}, loading: false, loaded: false, error: null, catalogError: null } });
+    let generation = 0, credentialRevision = 0;
+    const canRead = () => !store.signal.aborted && grants.has('source-control.read');
+    const canWrite = () => canRead() && grants.has('source-control.credentials.write');
+    function patchDraft(id, patch) { const state = store.getSnapshot(); store.set({ patch: { drafts: { ...state.drafts, [id]: { ...(state.drafts[id] ?? blankSourceControlDraft({})), ...patch } } } }); }
+    async function load(_required, _optional = {}) {
+        if (!canRead())
+            return;
+        const ticket = ++generation, revision = credentialRevision;
+        store.set({ patch: { loading: true } });
+        // Catalog failure must not hide saved connections; retain each successful store independently.
+        await Promise.all([
+            (async () => { try {
+                const credentials = await api.list({}, { signal: store.signal });
+                if (ticket === generation && revision === credentialRevision)
+                    store.set({ patch: { credentials: credentials.map(row => sourceControlSummary({ row })), loaded: true, error: null } });
+            }
+            catch {
+                if (ticket === generation)
+                    store.set({ patch: { error: 'Connections unavailable' } });
+            } })(),
+            (async () => { try {
+                const providers = await api.providers({}, { signal: store.signal });
+                if (ticket === generation)
+                    store.set({ patch: { providers, catalogError: null } });
+            }
+            catch {
+                if (ticket === generation)
+                    store.set({ patch: { catalogError: 'Provider catalog unavailable' } });
+            } })(),
+        ]);
+        if (ticket === generation)
+            store.set({ patch: { loading: false } });
+    }
+    async function save({ providerId }, _optional = {}) {
+        const state = store.getSnapshot(), draft = state.drafts[providerId] ?? blankSourceControlDraft({});
+        const info = sourceControlProviders({ providers: state.providers, credentials: state.credentials }).find(p => p.id === providerId);
+        if (!canWrite() || !state.loaded || draft.saving || !info || !sourceControlReady({ info, draft }))
+            return false;
+        const current = defaultSourceControlCredential({ credentials: state.credentials, providerId }), connection = buildSourceControlConnection({ info, draft });
+        patchDraft(providerId, { saving: true, error: null });
+        try {
+            const row = current ? await api.update({ id: current.id, patch: { connection } }, { signal: store.signal }) : await api.create({ label: 'default', connection }, { signal: store.signal });
+            if (store.signal.aborted)
+                return false;
+            credentialRevision++;
+            // One round trip per write: splice the summary, then erase accepted secret drafts immediately.
+            const credentials = store.getSnapshot().credentials, summary = sourceControlSummary({ row });
+            // Preserve server order: the first row is the defensive default when no row is marked default.
+            store.set({ patch: { credentials: Object.freeze(credentials.some(c => c.id === row.id) ? credentials.map(c => c.id === row.id ? summary : c) : [...credentials, summary]) } });
+            patchDraft(providerId, blankSourceControlDraft({}));
+            return true;
+        }
+        catch (error) {
+            patchDraft(providerId, { saving: false, error: sourceControlErrorMessage({ error }) });
+            return false;
+        }
+    }
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe, load, save,
+        setToken({ providerId, value }, _optional = {}) { if (canWrite() && !store.getSnapshot().drafts[providerId]?.saving)
+            patchDraft(providerId, { token: value }); },
+        setField({ providerId, name, value }, _optional = {}) { const draft = store.getSnapshot().drafts[providerId] ?? blankSourceControlDraft({}); if (canWrite() && !draft.saving)
+            patchDraft(providerId, { values: { ...draft.values, [name]: value } }); },
+        dispose(_required = {}, _optional = {}) { generation++; store.set({ patch: { drafts: {} } }); store.dispose(); },
+    };
+}
+//# sourceMappingURL=source-control.controller.js.map

package/dist/source-control/index.d.ts

@@ -0,0 +1,8 @@
+export { sourceControlModule } from './source-control.module.js';
+export { createSourceControlController } from './controllers/source-control.controller.js';
+export { sourceControlApiToken } from './ports.js';
+export type { SourceControlApiPort, SourceControlTransportPort } from './ports.js';
+export type * from './models.js';
+export { sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection } from './rules.js';
+export { sourceControlMessagesEn } from './messages.en.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/source-control/index.js

@@ -0,0 +1,6 @@
+export { sourceControlModule } from './source-control.module.js';
+export { createSourceControlController } from './controllers/source-control.controller.js';
+export { sourceControlApiToken } from './ports.js';
+export { sourceControlProviders, defaultSourceControlCredential, sourceControlReady, buildSourceControlConnection } from './rules.js';
+export { sourceControlMessagesEn } from './messages.en.js';
+//# sourceMappingURL=index.js.map

package/dist/source-control/messages.en.d.ts

@@ -0,0 +1,11 @@
+export declare const sourceControlMessagesEn: Readonly<{
+    title: "Source Control";
+    providers: "Providers";
+    description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+    denied: "Permission denied";
+    saved: "Token saved";
+    replace: "Replace token";
+    manage: "Create access token";
+    loading: "Loading connections…";
+}>;
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/source-control/messages.en.js

@@ -0,0 +1,2 @@
+export const sourceControlMessagesEn = Object.freeze({ title: 'Source Control', providers: 'Providers', description: 'Connect an account to read repositories and push to them later. Content versioning is a separate feature.', denied: 'Permission denied', saved: 'Token saved', replace: 'Replace token', manage: 'Create access token', loading: 'Loading connections…' });
+//# sourceMappingURL=messages.en.js.map

package/dist/source-control/models.d.ts

@@ -0,0 +1,70 @@
+export interface SourceControlField {
+    readonly name: string;
+    readonly label: string;
+    readonly secret?: boolean;
+    readonly required?: boolean;
+    readonly hint?: string;
+    readonly userHelp?: string;
+    readonly help?: string;
+}
+export interface SourceControlProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly credential?: {
+        readonly tokenField: string;
+        readonly fields: readonly SourceControlField[];
+        readonly tokenPageUrl?: string;
+        readonly help?: string;
+    };
+}
+export interface SourceControlCredential {
+    readonly id: string;
+    readonly providerId: string;
+    readonly label: string;
+    readonly configured: true;
+    readonly isDefault: boolean;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type SourceControlConnection = {
+    providerId: string;
+    token: string;
+} & Readonly<Record<string, string>>;
+export interface SourceControlCredentialInput {
+    readonly label: string;
+    readonly connection: SourceControlConnection;
+    readonly isDefault?: boolean;
+}
+export interface SourceControlCredentialPatch {
+    readonly label?: string;
+    readonly connection?: SourceControlConnection;
+    readonly isDefault?: boolean;
+}
+export interface SourceControlDraft {
+    readonly token: string;
+    readonly values: Readonly<Record<string, string>>;
+    readonly saving: boolean;
+    readonly error: string | null;
+}
+export interface SourceControlProviderInfo {
+    readonly id: string;
+    readonly label: string;
+    readonly listed: boolean;
+    readonly tokenLabel: string;
+    readonly fields: readonly SourceControlField[];
+    readonly tokenPageUrl: string;
+    readonly help: string;
+}
+export interface SourceControlState {
+    readonly providers: readonly SourceControlProvider[];
+    readonly credentials: readonly SourceControlCredential[];
+    readonly drafts: Readonly<Record<string, SourceControlDraft>>;
+    readonly loading: boolean;
+    readonly loaded: boolean;
+    readonly error: string | null;
+    readonly catalogError: string | null;
+}
+export interface SourceControlRequestOptions {
+    readonly signal?: AbortSignal;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/source-control/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/source-control/ports.d.ts

@@ -0,0 +1,23 @@
+import type { SourceControlProvider, SourceControlCredential, SourceControlCredentialInput, SourceControlCredentialPatch, SourceControlRequestOptions } from './models.js';
+export interface SourceControlApiPort {
+    providers(required: Record<string, never>, optional?: SourceControlRequestOptions): Promise<readonly SourceControlProvider[]>;
+    list(required: Record<string, never>, optional?: SourceControlRequestOptions): Promise<readonly SourceControlCredential[]>;
+    create(required: SourceControlCredentialInput, optional?: SourceControlRequestOptions): Promise<SourceControlCredential>;
+    update(required: {
+        id: string;
+        patch: SourceControlCredentialPatch;
+    }, optional?: SourceControlRequestOptions): Promise<SourceControlCredential>;
+    /** Idempotent; intentionally not offered by the connection page UI. */
+    remove(required: {
+        id: string;
+    }, optional?: SourceControlRequestOptions): Promise<void>;
+}
+export interface SourceControlTransportPort {
+    request<T>(required: {
+        path: string;
+        method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+        body?: unknown;
+    }, optional?: SourceControlRequestOptions): Promise<T>;
+}
+export declare const sourceControlApiToken: import("../core/module/token.js").AdminPortToken<SourceControlApiPort, "admin.source-control.api">;
+//# sourceMappingURL=ports.d.ts.map

package/dist/source-control/ports.js

@@ -0,0 +1,3 @@
+import { adminPort } from '../core/module/token.js';
+export const sourceControlApiToken = adminPort({ id: 'admin.source-control.api' });
+//# sourceMappingURL=ports.js.map

package/dist/source-control/react/components/SourceControlCredentialFields.d.ts

@@ -0,0 +1,5 @@
+import type { SourceControlRowView } from '../hooks/ProvidersTab.hooks.js';
+export declare function SourceControlCredentialFields({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): import("react").JSX.Element;
+//# sourceMappingURL=SourceControlCredentialFields.d.ts.map

package/dist/source-control/react/components/SourceControlCredentialFields.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Notice, TextField } from '@jini-ai/ui-kit/react';
+import { useSourceControlCredentialFields } from '../hooks/SourceControlCredentialFields.hooks.js';
+export function SourceControlCredentialFields({ row }, _optional = {}) {
+    const vm = useSourceControlCredentialFields({ row });
+    return _jsxs(_Fragment, { children: [_jsx(TextField, { label: vm.tokenLabel, type: "password", value: vm.token, onValueChange: vm.onToken, disabled: vm.saving, ref: vm.tokenRef }), _jsx("p", { children: vm.hint }), vm.hasGuidance && _jsxs("details", { children: [_jsx("summary", { children: "Which token do I need?" }), _jsxs("p", { children: [vm.help, " ", vm.tokenPageUrl && _jsx("a", { href: vm.tokenPageUrl, target: "_blank", rel: "noreferrer", children: "Create a token" })] })] }), vm.fields.map(field => _jsxs("div", { children: [_jsx(TextField, { label: field.label, type: field.secret ? 'password' : 'text', value: field.value, onValueChange: field.onValueChange, disabled: vm.saving, required: field.required, ref: field.ref }), field.hint && _jsx("p", { children: field.hint })] }, field.name)), _jsxs(Button, { onPress: vm.save, disabled: vm.disabled, pending: vm.saving, children: ["Save ", vm.label, " token"] }), vm.error && _jsx(Notice, { tone: "danger", children: vm.error })] });
+}
+//# sourceMappingURL=SourceControlCredentialFields.js.map

package/dist/source-control/react/components/SourceControlProviderRow.d.ts

@@ -0,0 +1,5 @@
+import type { SourceControlRowView } from '../hooks/ProvidersTab.hooks.js';
+export declare function SourceControlProviderRow({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): import("react").JSX.Element;
+//# sourceMappingURL=SourceControlProviderRow.d.ts.map

package/dist/source-control/react/components/SourceControlProviderRow.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Notice } from '@jini-ai/ui-kit/react';
+import { SourceControlCredentialFields } from './SourceControlCredentialFields.js';
+export function SourceControlProviderRow({ row }, _optional = {}) {
+    return _jsxs("details", { name: "jini-source-control-provider", open: row.defaultOpen, "data-jini-part": "source-control.provider", children: [_jsxs("summary", { children: [_jsx("h2", { children: row.heading }), row.saved && _jsxs(_Fragment, { children: [_jsx("span", { children: "Token saved" }), _jsxs("span", { children: ["Saved ", row.saved.updatedAt] }), _jsx("span", { children: "Replace token \u25BE" })] }), !row.saved && _jsx("span", { children: "Expand \u25BE" })] }), row.unlisted ? _jsx(Notice, { children: "Its plugin is off or missing. Manage this token on the Access tokens page." }) : row.canEdit ? _jsx(SourceControlCredentialFields, { row: row }) : _jsx(Notice, { children: "Read-only connection" })] });
+}
+//# sourceMappingURL=SourceControlProviderRow.js.map

package/dist/source-control/react/hooks/ProvidersTab.hooks.d.ts

@@ -0,0 +1,45 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function useProvidersTab({ permissions }: TabViewProps, _optional?: {}): {
+    denied: boolean;
+    loading: boolean;
+    rows: {
+        id: string;
+        label: string;
+        heading: string;
+        saved: import("../../models.js").SourceControlCredential | undefined;
+        defaultOpen: boolean;
+        canEdit: boolean;
+        unlisted: boolean;
+        connected: boolean;
+        token: string;
+        tokenLabel: string;
+        hint: string;
+        saving: boolean;
+        error: string | null;
+        disabled: boolean;
+        help: string;
+        tokenPageUrl: string | undefined;
+        hasGuidance: boolean;
+        fields: {
+            name: string;
+            label: string;
+            value: string;
+            secret: boolean;
+            required: boolean;
+            hint: string | undefined;
+            onValueChange({ value }: {
+                value: string;
+            }): void;
+        }[];
+        onToken({ value }: {
+            value: string;
+        }): void;
+        save(): void;
+    }[];
+    errors: string[];
+    reload(): void;
+    canManage: boolean;
+    manage(): void;
+};
+export type SourceControlRowView = ReturnType<typeof useProvidersTab>['rows'][number];
+//# sourceMappingURL=ProvidersTab.hooks.d.ts.map

package/dist/source-control/react/hooks/ProvidersTab.hooks.js

@@ -0,0 +1,20 @@
+import { useController } from '../../../react/use-controller.js';
+import { createSourceControlController } from '../../controllers/source-control.controller.js';
+import { blankSourceControlDraft, sourceControlProviders, defaultSourceControlCredential, sourceControlReady, safeSourceControlUrl } from '../../rules.js';
+import { useSourceControlPorts } from './SourceControlPorts.hooks.js';
+export function useProvidersTab({ permissions = [] }, _optional = {}) {
+    const ports = useSourceControlPorts({}), key = permissions.join('\0'), canRead = permissions.includes('source-control.read'), canWrite = canRead && permissions.includes('source-control.credentials.write');
+    const { controller, snapshot: state } = useController({ create: () => createSourceControlController({ api: ports.sourceControlApi, permissions }), dependencies: [ports.sourceControlApi, key] }, { start: ({ controller }) => { void controller.load({}); } });
+    const infos = sourceControlProviders({ providers: state?.providers ?? [], credentials: state?.credentials ?? [] });
+    const first = infos.find(p => p.listed && !defaultSourceControlCredential({ credentials: state?.credentials ?? [], providerId: p.id }))?.id;
+    const rows = infos.map(info => {
+        const saved = defaultSourceControlCredential({ credentials: state?.credentials ?? [], providerId: info.id }), draft = state?.drafts[info.id] ?? blankSourceControlDraft({});
+        return { id: info.id, label: info.label, heading: saved ? info.label : `Connect ${info.label}`, saved, defaultOpen: info.id === first, canEdit: canWrite && info.listed, unlisted: !info.listed, connected: !!saved,
+            token: draft.token, tokenLabel: `${info.label} ${info.tokenLabel}`, hint: saved ? 'Leave blank to keep the current token.' : 'Once saved, the token is never displayed again.', saving: draft.saving, error: draft.error,
+            disabled: !canWrite || !sourceControlReady({ info, draft }), help: info.help, tokenPageUrl: safeSourceControlUrl({ url: info.tokenPageUrl }), hasGuidance: !!info.help || !!safeSourceControlUrl({ url: info.tokenPageUrl }),
+            fields: info.fields.map(field => ({ name: field.name, label: `${info.label} ${field.label}`, value: draft.values[field.name] ?? '', secret: !!field.secret, required: !!field.required, hint: field.userHelp ?? field.hint ?? field.help, onValueChange({ value }) { controller?.setField({ providerId: info.id, name: field.name, value }); } })),
+            onToken({ value }) { controller?.setToken({ providerId: info.id, value }); }, save() { void controller?.save({ providerId: info.id }); }, };
+    });
+    return { denied: !canRead, loading: !state || state.loading, rows, errors: [state?.error, state?.catalogError].filter((s) => !!s), reload() { void controller?.load({}); }, canManage: !!ports.sourceControlNavigation, manage() { ports.sourceControlNavigation?.open({ kind: 'source-control' }); } };
+}
+//# sourceMappingURL=ProvidersTab.hooks.js.map

package/dist/source-control/react/hooks/SourceControlCredentialFields.hooks.d.ts

@@ -0,0 +1,43 @@
+import type { SourceControlRowView } from './ProvidersTab.hooks.js';
+/** ui-kit's opaque attrs carry semantic metadata, not arbitrary input attributes.
+ * Use its forwarded input ref for credential autofill policy. Chrome ignores off for
+ * credential-shaped fields, so secret fields explicitly opt into new-password. */
+export declare function useSourceControlCredentialFields({ row }: {
+    row: SourceControlRowView;
+}, _optional?: {}): {
+    tokenRef: (node: HTMLInputElement | null) => void;
+    fields: {
+        ref(node: HTMLInputElement | null): void;
+        name: string;
+        label: string;
+        value: string;
+        secret: boolean;
+        required: boolean;
+        hint: string | undefined;
+        onValueChange({ value }: {
+            value: string;
+        }): void;
+    }[];
+    id: string;
+    label: string;
+    heading: string;
+    saved: import("../../models.js").SourceControlCredential | undefined;
+    defaultOpen: boolean;
+    canEdit: boolean;
+    unlisted: boolean;
+    connected: boolean;
+    token: string;
+    tokenLabel: string;
+    hint: string;
+    saving: boolean;
+    error: string | null;
+    disabled: boolean;
+    help: string;
+    tokenPageUrl: string | undefined;
+    hasGuidance: boolean;
+    onToken({ value }: {
+        value: string;
+    }): void;
+    save(): void;
+};
+//# sourceMappingURL=SourceControlCredentialFields.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlCredentialFields.hooks.js

@@ -0,0 +1,9 @@
+import { useCallback } from 'react';
+/** ui-kit's opaque attrs carry semantic metadata, not arbitrary input attributes.
+ * Use its forwarded input ref for credential autofill policy. Chrome ignores off for
+ * credential-shaped fields, so secret fields explicitly opt into new-password. */
+export function useSourceControlCredentialFields({ row }, _optional = {}) {
+    const tokenRef = useCallback((node) => { node?.setAttribute('autocomplete', 'new-password'); }, []);
+    return { ...row, tokenRef, fields: row.fields.map(field => ({ ...field, ref(node) { node?.setAttribute('autocomplete', field.secret ? 'new-password' : 'off'); } })) };
+}
+//# sourceMappingURL=SourceControlCredentialFields.hooks.js.map

package/dist/source-control/react/hooks/SourceControlPage.hooks.d.ts

@@ -0,0 +1,17 @@
+import type { ModulePageProps } from '../../../react/bind-react.js';
+export declare function useSourceControlPage(props: ModulePageProps, _optional?: {}): {
+    denied: boolean;
+    ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;
+    params: Readonly<Record<string, unknown>>;
+    permissions: readonly string[];
+    active: string;
+    items: {
+        id: string;
+        label: string;
+        content: null;
+    }[];
+    onValueChange({ value }: {
+        value: string;
+    }): void;
+};
+//# sourceMappingURL=SourceControlPage.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlPage.hooks.js

@@ -0,0 +1,5 @@
+export function useSourceControlPage(props, _optional = {}) {
+    const active = props.description.tabs.find(t => t.visible && t.id.endsWith(`.${props.requestedTab ?? 'providers'}`)) ?? props.description.tabs.find(t => t.visible);
+    return { denied: !props.description.visible, ActiveTab: active ? props.tabs.providers : undefined, params: active?.params ?? {}, permissions: props.description.grants, active: 'providers', items: [{ id: 'providers', label: 'Providers', content: null }], onValueChange({ value }) { props.onTabChange?.({ tab: value }); } };
+}
+//# sourceMappingURL=SourceControlPage.hooks.js.map

package/dist/source-control/react/hooks/SourceControlPorts.hooks.d.ts

@@ -0,0 +1,9 @@
+import type { SourceControlApiPort } from '../../ports.js';
+import type { CredentialManagementPort } from '../../../contracts/credential-management.js';
+export interface SourceControlPorts {
+    readonly sourceControlApi: SourceControlApiPort;
+    readonly sourceControlNavigation?: CredentialManagementPort;
+}
+export declare const SourceControlPortsContext: import("react").Context<SourceControlPorts | null>;
+export declare function useSourceControlPorts(_required?: Record<string, never>, _optional?: {}): SourceControlPorts;
+//# sourceMappingURL=SourceControlPorts.hooks.d.ts.map

package/dist/source-control/react/hooks/SourceControlPorts.hooks.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const SourceControlPortsContext = createContext(null);
+export function useSourceControlPorts(_required = {}, _optional = {}) { const ports = useContext(SourceControlPortsContext); if (!ports)
+    throw new AdminConfigError({ issues: ['React scope unavailable: source-control'] }); return ports; }
+//# sourceMappingURL=SourceControlPorts.hooks.js.map

package/dist/source-control/react/index.d.ts

@@ -0,0 +1,156 @@
+export { useSourceControlPorts } from './hooks/SourceControlPorts.hooks.js';
+export declare function sourceControl(_required: Record<string, never>, _optional?: {}): {
+    id: "source-control";
+    requires: {
+        readonly sourceControlApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").SourceControlApiPort, "admin.source-control.api">;
+    };
+    optional: {
+        readonly sourceControlNavigation: import("../../core/module/token.js").AdminPortToken<import("../../contracts/credential-management.js").CredentialManagementPort, "admin.credentials.management">;
+    };
+    messages: Readonly<{
+        title: "Source Control";
+        providers: "Providers";
+        description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+        denied: "Permission denied";
+        saved: "Token saved";
+        replace: "Replace token";
+        manage: "Create access token";
+        loading: "Loading connections…";
+    }>;
+    pages: {
+        readonly sourceControl: {
+            readonly path: "/source-control";
+            readonly label: "Source Control";
+            readonly permissions: readonly ["source-control.read"];
+            readonly nav: {
+                readonly group: "operations";
+                readonly icon: "git";
+            };
+            readonly tabs: {
+                readonly providers: {
+                    readonly label: "Providers";
+                };
+            };
+        };
+    };
+} & {
+    react: {
+        module: {
+            id: "source-control";
+            requires: {
+                readonly sourceControlApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").SourceControlApiPort, "admin.source-control.api">;
+            };
+            optional: {
+                readonly sourceControlNavigation: import("../../core/module/token.js").AdminPortToken<import("../../contracts/credential-management.js").CredentialManagementPort, "admin.credentials.management">;
+            };
+            messages: Readonly<{
+                title: "Source Control";
+                providers: "Providers";
+                description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+                denied: "Permission denied";
+                saved: "Token saved";
+                replace: "Replace token";
+                manage: "Create access token";
+                loading: "Loading connections…";
+            }>;
+            pages: {
+                readonly sourceControl: {
+                    readonly path: "/source-control";
+                    readonly label: "Source Control";
+                    readonly permissions: readonly ["source-control.read"];
+                    readonly nav: {
+                        readonly group: "operations";
+                        readonly icon: "git";
+                    };
+                    readonly tabs: {
+                        readonly providers: {
+                            readonly label: "Providers";
+                        };
+                    };
+                };
+            };
+        };
+        pages: {
+            readonly sourceControl: {
+                Page: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").ModulePageProps>>;
+                tabs: {
+                    readonly providers: import("react").LazyExoticComponent<import("react").ComponentType<import("../../react/bind-react.js").TabViewProps>>;
+                };
+            };
+        };
+        Provider: ({ admin, children }: {
+            admin: import("../../core/module/types.js").AdminInstance;
+            children: import("react").ReactNode;
+        }, _optional?: Record<string, never>) => import("react").FunctionComponentElement<import("react").ProviderProps<import("../../core/module/types.js").ScopedPorts<{
+            id: "source-control";
+            requires: {
+                readonly sourceControlApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").SourceControlApiPort, "admin.source-control.api">;
+            };
+            optional: {
+                readonly sourceControlNavigation: import("../../core/module/token.js").AdminPortToken<import("../../contracts/credential-management.js").CredentialManagementPort, "admin.credentials.management">;
+            };
+            messages: Readonly<{
+                title: "Source Control";
+                providers: "Providers";
+                description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+                denied: "Permission denied";
+                saved: "Token saved";
+                replace: "Replace token";
+                manage: "Create access token";
+                loading: "Loading connections…";
+            }>;
+            pages: {
+                readonly sourceControl: {
+                    readonly path: "/source-control";
+                    readonly label: "Source Control";
+                    readonly permissions: readonly ["source-control.read"];
+                    readonly nav: {
+                        readonly group: "operations";
+                        readonly icon: "git";
+                    };
+                    readonly tabs: {
+                        readonly providers: {
+                            readonly label: "Providers";
+                        };
+                    };
+                };
+            };
+        }> | null>>;
+        usePorts: (_required?: Record<string, never>, _optional?: Record<string, never>) => import("../../core/module/types.js").ScopedPorts<{
+            id: "source-control";
+            requires: {
+                readonly sourceControlApi: import("../../core/module/token.js").AdminPortToken<import("../ports.js").SourceControlApiPort, "admin.source-control.api">;
+            };
+            optional: {
+                readonly sourceControlNavigation: import("../../core/module/token.js").AdminPortToken<import("../../contracts/credential-management.js").CredentialManagementPort, "admin.credentials.management">;
+            };
+            messages: Readonly<{
+                title: "Source Control";
+                providers: "Providers";
+                description: "Connect an account to read repositories and push to them later. Content versioning is a separate feature.";
+                denied: "Permission denied";
+                saved: "Token saved";
+                replace: "Replace token";
+                manage: "Create access token";
+                loading: "Loading connections…";
+            }>;
+            pages: {
+                readonly sourceControl: {
+                    readonly path: "/source-control";
+                    readonly label: "Source Control";
+                    readonly permissions: readonly ["source-control.read"];
+                    readonly nav: {
+                        readonly group: "operations";
+                        readonly icon: "git";
+                    };
+                    readonly tabs: {
+                        readonly providers: {
+                            readonly label: "Providers";
+                        };
+                    };
+                };
+            };
+        }>;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/source-control/react/index.js

@@ -0,0 +1,10 @@
+import { bindReact } from '../../react/bind-react.js';
+import { sourceControlModule } from '../source-control.module.js';
+import { SourceControlPortsContext } from './hooks/SourceControlPorts.hooks.js';
+export { useSourceControlPorts } from './hooks/SourceControlPorts.hooks.js';
+export function sourceControl(_required, _optional = {}) {
+    const module = { ...sourceControlModule };
+    const react = bindReact({ module, views: { sourceControl: { page: () => import('./pages/SourceControlPage.js'), tabs: { providers: () => import('./tabs/ProvidersTab.js') } } } }, { context: SourceControlPortsContext });
+    return Object.assign(module, { react });
+}
+//# sourceMappingURL=index.js.map

package/dist/source-control/react/pages/SourceControlPage.d.ts

@@ -0,0 +1,4 @@
+import type { ModulePageProps } from '../../../react/bind-react.js';
+export declare function SourceControlPage(props: ModulePageProps, _optional?: {}): import("react").JSX.Element;
+export default SourceControlPage;
+//# sourceMappingURL=SourceControlPage.d.ts.map

package/dist/source-control/react/pages/SourceControlPage.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense } from 'react';
+import { Notice, Spinner, Tabs } from '@jini-ai/ui-kit/react';
+import { useSourceControlPage } from '../hooks/SourceControlPage.hooks.js';
+import { sourceControlMessagesEn as m } from '../../messages.en.js';
+export function SourceControlPage(props, _optional = {}) {
+    const vm = useSourceControlPage(props);
+    return _jsxs("section", { "data-jini-part": "source-control.page", children: [_jsx("p", { children: "Operations" }), _jsx("h1", { children: props.description.label }), vm.denied ? _jsx(Notice, { tone: "danger", children: m.denied }) : _jsxs(_Fragment, { children: [_jsx("p", { children: m.description }), _jsx(Tabs, { label: "Source control views", value: vm.active, items: vm.items, onValueChange: vm.onValueChange }), _jsx(Suspense, { fallback: _jsx(Spinner, { label: m.loading }), children: vm.ActiveTab && _jsx(vm.ActiveTab, { params: vm.params, permissions: vm.permissions }) })] })] });
+}
+export default SourceControlPage;
+//# sourceMappingURL=SourceControlPage.js.map

package/dist/source-control/react/tabs/ProvidersTab.d.ts

@@ -0,0 +1,4 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function ProvidersTab(props: TabViewProps, _optional?: {}): import("react").JSX.Element;
+export default ProvidersTab;
+//# sourceMappingURL=ProvidersTab.d.ts.map

package/dist/source-control/react/tabs/ProvidersTab.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Notice, Spinner } from '@jini-ai/ui-kit/react';
+import { useProvidersTab } from '../hooks/ProvidersTab.hooks.js';
+import { SourceControlProviderRow } from '../components/SourceControlProviderRow.js';
+export function ProvidersTab(props, _optional = {}) {
+    const vm = useProvidersTab(props);
+    return vm.denied ? _jsx(Notice, { tone: "danger", children: "Permission denied" }) : _jsxs("section", { children: [vm.errors.map(error => _jsx(Notice, { tone: "danger", children: error }, error)), vm.loading && _jsx(Spinner, { label: "Loading connections\u2026" }), _jsx(Button, { onPress: vm.reload, disabled: vm.loading, children: "Reload connections" }), vm.rows.map(row => _jsx(SourceControlProviderRow, { row: row }, row.id)), vm.canManage && _jsxs("p", { children: ["Need a second named token or want to rename one? ", _jsx(Button, { variant: "ghost", onPress: vm.manage, children: "Create access token" })] })] });
+}
+export default ProvidersTab;
+//# sourceMappingURL=ProvidersTab.js.map