@postgres.ai/shared 4.1.2 → 4.2.0-pr-1200

package/{dist/pages → pages}/CreateClone/stores/Main.js

@@ -2,7 +2,7 @@ import { makeAutoObservable } from 'mobx';
 import { SnapshotsStore, } from '@postgres.ai/shared/stores/Snapshots';
 import { getTextFromUnknownApiError } from '@postgres.ai/shared/utils/api';
 import { checkIsCloneStable } from '@postgres.ai/shared/utils/clone';
-const UNSTABLE_CLONE_UPDATE_TIMEOUT = 1000;
+import { ClonePoller } from '@postgres.ai/shared/utils/clonePoller';
 export class MainStore {
     constructor(api) {
         this.instance = null;
@@ -11,6 +11,7 @@ export class MainStore {
         this.getSnapshotsError = null;
         this.clone = null;
         this.cloneError = null;
+        this.poller = new ClonePoller();
         this.load = async (instanceId) => {
             var _a, _b;
             const [instance, isLoadedSnapshots] = await Promise.all([
@@ -26,6 +27,7 @@ export class MainStore {
         this.createClone = async (data) => {
             if (!this.instance)
                 return false;
+            this.poller.start();
             const { response, error } = await this.api.createClone({
                 ...data,
                 instanceId: this.instance.id,
@@ -61,13 +63,16 @@ export class MainStore {
                 this.getSnapshotsError = await error.json().then((err) => err);
             return response;
         };
+        this.stopPolling = () => this.poller.stop();
         this.updateCloneUntilStable = async (args) => {
-            window.clearTimeout(this.cloneUpdateTimeout);
+            if (this.poller.isStopped)
+                return;
+            this.poller.cancel();
             const { response, error } = await this.api.getClone(args);
             if (response) {
                 this.clone = response;
                 if (!this.isCloneStable)
-                    this.cloneUpdateTimeout = window.setTimeout(() => this.updateCloneUntilStable(args), UNSTABLE_CLONE_UPDATE_TIMEOUT);
+                    this.poller.scheduleNext(() => this.updateCloneUntilStable(args));
             }
             if (error)
                 this.cloneError = await error.json().then((err) => (err === null || err === void 0 ? void 0 : err.message) || err);

package/pages/Instance/Configuration/PhysicalMode/EnvsEditor/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { PhysicalEnv } from '../../useForm';
+declare type Props = {
+    envs: PhysicalEnv[];
+    onChange: (envs: PhysicalEnv[]) => void;
+    suggestions?: string[];
+    disabled?: boolean;
+    keyErrors?: (string | undefined)[];
+};
+export declare const MASKED_ENV_VALUE = "****";
+export declare const isMaskedEnvValue: (value: string) => boolean;
+export declare const EnvsEditor: ({ envs, onChange, suggestions, disabled, keyErrors, }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/PhysicalMode/EnvsEditor/index.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, IconButton, TextField, Typography } from '@material-ui/core';
+import Box from '@mui/material/Box';
+// MASKED_ENV_VALUE is what the engine returns instead of a stored env value:
+// envs carry WAL-G and pgBackRest credentials, so GET /admin/config lists
+// the keys only. Posting the mask back for a key keeps the stored value.
+export const MASKED_ENV_VALUE = '****';
+export const isMaskedEnvValue = (value) => value === MASKED_ENV_VALUE;
+const MASKED_HINT = 'Stored on the server; kept unless you change it';
+// EnvsEditor renders a rows-of-key/value editor with add/remove and a
+// click-to-add suggestion list. Engine consumes envs as a free-form map
+// (physical.go:76, CopyOptions.Envs map[string]string); the UI is a thin
+// surface over that map.
+export const EnvsEditor = ({ envs, onChange, suggestions = [], disabled, keyErrors = [], }) => {
+    const updateRow = (i, patch) => {
+        const next = envs.slice();
+        next[i] = { ...next[i], ...patch };
+        onChange(next);
+    };
+    const removeRow = (i) => {
+        const next = envs.slice();
+        next.splice(i, 1);
+        onChange(next);
+    };
+    const addRow = (key = '') => {
+        onChange([...envs, { key, value: '' }]);
+    };
+    const usedKeys = new Set(envs.map((e) => e.key));
+    const hasMasked = envs.some((e) => isMaskedEnvValue(e.value));
+    return (_jsxs(Box, { mt: 1, "data-testid": "envs-editor", children: [_jsx(Typography, { variant: "subtitle2", children: "Environment variables" }), hasMasked && (_jsx(Box, { mt: 0.5, children: _jsxs(Typography, { variant: "caption", color: "textSecondary", "data-testid": "envs-masked-hint", children: ["Values shown as ", MASKED_ENV_VALUE, " are stored on the server and are kept unless you change them. Renaming such a variable requires entering its value again."] }) })), envs.length === 0 ? (_jsx(Box, { mt: 1, mb: 1, children: _jsx(Typography, { variant: "caption", color: "textSecondary", children: "No environment variables set. Use suggestions below or click \"Add\"." }) })) : (envs.map((env, i) => (_jsxs(Box, { display: "flex", alignItems: "center", mt: 1, "data-testid": `envs-row-${i}`, children: [_jsx(TextField, { size: "small", label: "Name", value: env.key, disabled: disabled, error: Boolean(keyErrors[i]), helperText: keyErrors[i], onChange: (e) => updateRow(i, { key: e.target.value }), inputProps: { 'data-testid': `envs-key-${i}` } }), _jsx(Box, { mx: 1, children: _jsx(TextField, { size: "small", label: "Value", value: env.value, disabled: disabled, helperText: isMaskedEnvValue(env.value) ? MASKED_HINT : undefined, onChange: (e) => updateRow(i, { value: e.target.value }), inputProps: { 'data-testid': `envs-value-${i}` } }) }), _jsx(IconButton, { size: "small", "aria-label": "remove env", disabled: disabled, onClick: () => removeRow(i), "data-testid": `envs-remove-${i}`, children: "\u00D7" })] }, i)))), _jsx(Box, { mt: 1, children: _jsx(Button, { size: "small", variant: "outlined", disabled: disabled, onClick: () => addRow(), "data-testid": "envs-add", children: "+ Add" }) }), suggestions.length > 0 && (_jsxs(Box, { mt: 1, children: [_jsx(Typography, { variant: "caption", color: "textSecondary", children: "Suggestions:" }), _jsx(Box, { mt: 0.5, children: suggestions.map((s) => (_jsx(Button, { size: "small", variant: "text", disabled: disabled || usedKeys.has(s), onClick: () => addRow(s), "data-testid": `envs-suggest-${s}`, children: s }, s))) })] }))] }));
+};

package/pages/Instance/Configuration/PhysicalMode/PgBackRest/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { FormValues } from '../../useForm';
+declare type Props = {
+    values: FormValues;
+    onChange: <K extends keyof FormValues>(key: K, value: FormValues[K]) => void;
+    disabled?: boolean;
+    envsKeyErrors?: (string | undefined)[];
+};
+export declare const PgBackRest: ({ values, onChange, disabled, envsKeyErrors, }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/PhysicalMode/PgBackRest/index.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Checkbox, FormControlLabel, TextField, Typography, } from '@material-ui/core';
+import Box from '@mui/material/Box';
+import { EnvsEditor } from '../EnvsEditor';
+// pgBackRest exposes two structured fields (stanza, delta); repo paths, S3
+// keys, archive options all live in the envs map. See
+// engine/internal/retrieval/engine/postgres/physical/pgbackrest.go:23-26 and
+// the example envs in config.example.physical_pgbackrest.yml:84-99.
+const PGBACKREST_ENV_SUGGESTIONS = [
+    'PGBACKREST_REPO',
+    'PGBACKREST_REPO1_TYPE',
+    'PGBACKREST_REPO1_PATH',
+    'PGBACKREST_REPO1_HOST',
+    'PGBACKREST_REPO1_HOST_USER',
+    'PGBACKREST_REPO1_S3_BUCKET',
+    'PGBACKREST_REPO1_S3_ENDPOINT',
+    'PGBACKREST_REPO1_S3_KEY',
+    'PGBACKREST_REPO1_S3_KEY_SECRET',
+    'PGBACKREST_REPO1_S3_REGION',
+    'PGBACKREST_LOG_LEVEL_CONSOLE',
+    'PGBACKREST_PROCESS_MAX',
+];
+export const PgBackRest = ({ values, onChange, disabled, envsKeyErrors, }) => {
+    const onEnvsChange = (envs) => onChange('physicalEnvs', envs);
+    return (_jsxs(Box, { mt: 2, "data-testid": "pgbackrest-form", children: [_jsx(Typography, { variant: "subtitle1", children: "pgBackRest" }), _jsx(Box, { mt: 1, children: _jsx(TextField, { fullWidth: true, label: "Stanza", placeholder: "my-stanza", value: values.physicalPgbackrestStanza, disabled: disabled, onChange: (e) => onChange('physicalPgbackrestStanza', e.target.value), helperText: "Stanza name (must match the stanza configured in your pgBackRest setup).", inputProps: { 'data-testid': 'pgbackrest-stanza' } }) }), _jsx(Box, { mt: 1, children: _jsx(FormControlLabel, { control: _jsx(Checkbox, { checked: values.physicalPgbackrestDelta, disabled: disabled, onChange: (e) => onChange('physicalPgbackrestDelta', e.target.checked), inputProps: {
+                            'aria-label': 'delta',
+                            'data-testid': 'pgbackrest-delta',
+                        } }), label: "Delta restore" }) }), _jsx(EnvsEditor, { envs: values.physicalEnvs, onChange: onEnvsChange, suggestions: PGBACKREST_ENV_SUGGESTIONS, disabled: disabled, keyErrors: envsKeyErrors })] }));
+};

package/pages/Instance/Configuration/PhysicalMode/Sync/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { FormValues } from '../../useForm';
+declare type Props = {
+    values: FormValues;
+    onChange: <K extends keyof FormValues>(key: K, value: FormValues[K]) => void;
+    disabled?: boolean;
+};
+export declare const Sync: ({ values, onChange, disabled }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/PhysicalMode/Sync/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Checkbox, FormControlLabel, TextField, Typography, } from '@material-ui/core';
+import Box from '@mui/material/Box';
+// Shared section rendered below WAL-G / pgBackRest with the structured fields
+// that apply across all physical sub-tools (sync.enabled and dockerImage). The
+// engine surfaces more knobs (sync.healthCheck, sync.configs, recovery target,
+// custom restore command), but they remain YAML-only for 4.2 to keep the
+// projection footprint flat.
+export const Sync = ({ values, onChange, disabled }) => {
+    return (_jsxs(Box, { mt: 2, "data-testid": "physical-sync", children: [_jsx(Typography, { variant: "subtitle1", children: "Sync container & image" }), _jsx(Box, { mt: 1, children: _jsx(TextField, { fullWidth: true, label: "Docker image", placeholder: "postgresai/extended-postgres:18-0.6.2", value: values.physicalDockerImage, disabled: disabled, onChange: (e) => onChange('physicalDockerImage', e.target.value), helperText: "Postgres image for restore/sync containers. Major version must match the source.", inputProps: { 'data-testid': 'physical-docker-image' } }) }), _jsx(Box, { mt: 1, children: _jsx(FormControlLabel, { control: _jsx(Checkbox, { checked: values.physicalSyncEnabled, disabled: disabled, onChange: (e) => onChange('physicalSyncEnabled', e.target.checked), inputProps: {
+                            'aria-label': 'sync enabled',
+                            'data-testid': 'physical-sync-enabled',
+                        } }), label: "Run sync container" }) }), _jsx(Box, { mt: 1, children: _jsx(Typography, { variant: "caption", color: "textSecondary", children: "For advanced sync settings (health check, sync postgres configs, recovery target), edit the YAML config directly." }) })] }));
+};

package/pages/Instance/Configuration/PhysicalMode/Walg/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { FormValues } from '../../useForm';
+declare type Props = {
+    values: FormValues;
+    onChange: <K extends keyof FormValues>(key: K, value: FormValues[K]) => void;
+    disabled?: boolean;
+    envsKeyErrors?: (string | undefined)[];
+};
+export declare const Walg: ({ values, onChange, disabled, envsKeyErrors }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/PhysicalMode/Walg/index.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TextField, Typography } from '@material-ui/core';
+import Box from '@mui/material/Box';
+import { EnvsEditor } from '../EnvsEditor';
+// WAL-G has one structured field (BackupName, defaulting to "LATEST"); storage
+// backend, bucket, prefix, and credentials all live in the envs map. See
+// engine/internal/retrieval/engine/postgres/physical/wal_g.go:36-38 and the
+// example envs in config.example.physical_walg.yml:84-86.
+const WALG_ENV_SUGGESTIONS = [
+    'WALG_GS_PREFIX',
+    'WALG_S3_PREFIX',
+    'WALG_FILE_PREFIX',
+    'GOOGLE_APPLICATION_CREDENTIALS',
+    'AWS_ACCESS_KEY_ID',
+    'AWS_SECRET_ACCESS_KEY',
+    'AWS_REGION',
+];
+export const Walg = ({ values, onChange, disabled, envsKeyErrors }) => {
+    const onEnvsChange = (envs) => onChange('physicalEnvs', envs);
+    return (_jsxs(Box, { mt: 2, "data-testid": "walg-form", children: [_jsx(Typography, { variant: "subtitle1", children: "WAL-G" }), _jsx(Box, { mt: 1, children: _jsx(TextField, { fullWidth: true, label: "Backup name", placeholder: "LATEST", value: values.physicalWalgBackupName, disabled: disabled, onChange: (e) => onChange('physicalWalgBackupName', e.target.value), helperText: 'Which backup to restore. "LATEST" picks the most recent.', inputProps: { 'data-testid': 'walg-backup-name' } }) }), _jsx(Box, { mt: 2, children: _jsx(Typography, { variant: "caption", color: "textSecondary", children: "Storage backend, bucket, prefix, and credentials all live in the envs map. Do not paste credentials into the backup name field or any URL." }) }), _jsx(EnvsEditor, { envs: values.physicalEnvs, onChange: onEnvsChange, suggestions: WALG_ENV_SUGGESTIONS, disabled: disabled, keyErrors: envsKeyErrors })] }));
+};

package/pages/Instance/Configuration/PhysicalMode/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { FormValues } from '../useForm';
+declare type Props = {
+    values: FormValues;
+    onChange: <K extends keyof FormValues>(key: K, value: FormValues[K]) => void;
+    disabled?: boolean;
+    envsKeyErrors?: (string | undefined)[];
+};
+export declare const PhysicalMode: ({ values, onChange, disabled, envsKeyErrors, }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/PhysicalMode/index.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FormControl, FormControlLabel, Radio, RadioGroup, Typography, } from '@material-ui/core';
+import Box from '@mui/material/Box';
+import { PgBackRest } from './PgBackRest';
+import { Sync } from './Sync';
+import { Walg } from './Walg';
+// Physical-mode restore tool selector + sub-form. Two values surface in the
+// UI: WAL-G and pgBackRest, the two tool values the engine accepts outside
+// customTool. pg_basebackup is invoked via the customTool path and remains
+// YAML-only; when the loaded projection has `tool: customTool` we render a
+// banner instead of the sub-form, keeping the user from accidentally wiping a
+// hand-edited customTool config.
+export const PhysicalMode = ({ values, onChange, disabled, envsKeyErrors, }) => {
+    const tool = values.physicalTool;
+    const isCustomTool = tool === 'customTool';
+    return (_jsxs(Box, { mt: 1, "data-testid": "physical-mode", children: [_jsx(Typography, { variant: "subtitle2", children: "Restore tool" }), isCustomTool ? (_jsx(Box, { mt: 1, "data-testid": "physical-custom-tool-banner", children: _jsx(Typography, { variant: "body2", color: "textSecondary", children: "This config uses a custom restore tool (e.g. pg_basebackup). The UI cannot edit customTool configurations \u2014 edit the YAML directly." }) })) : (_jsx(FormControl, { children: _jsxs(RadioGroup, { row: true, value: tool, onChange: (_, value) => onChange('physicalTool', value), "aria-label": "physical restore tool", children: [_jsx(FormControlLabel, { value: "walg", control: _jsx(Radio, { disabled: disabled }), label: "WAL-G" }), _jsx(FormControlLabel, { value: "pgbackrest", control: _jsx(Radio, { disabled: disabled }), label: "pgBackRest" })] }) })), !isCustomTool && tool === 'walg' && (_jsx(Walg, { values: values, onChange: onChange, disabled: disabled, envsKeyErrors: envsKeyErrors })), !isCustomTool && tool === 'pgbackrest' && (_jsx(PgBackRest, { values: values, onChange: onChange, disabled: disabled, envsKeyErrors: envsKeyErrors })), !isCustomTool && tool && (_jsx(Sync, { values: values, onChange: onChange, disabled: disabled }))] }));
+};

package/pages/Instance/Configuration/SimpleMode/PreviewCard.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { ProposedConfig } from '@postgres.ai/shared/types/api/endpoints/probeSource';
+import { ResolvedImage } from '../configOptions';
+declare type Props = {
+    proposed: ProposedConfig;
+    resolved: ResolvedImage;
+    applying: boolean;
+    applyError: string | null;
+    onApply: () => void;
+    onEdit: () => void;
+};
+export declare const PreviewCard: ({ proposed, resolved, applying, applyError, onApply, onEdit, }: Props) => JSX.Element;
+export {};

package/pages/Instance/Configuration/SimpleMode/PreviewCard.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Link, Typography } from '@material-ui/core';
+import Box from '@mui/material/Box';
+import { Spinner } from '@postgres.ai/shared/components/Spinner';
+import { providerKeyToImage } from '../configOptions';
+const Field = ({ label, value }) => (_jsxs(Box, { display: "flex", mb: 0.5, children: [_jsx(Box, { minWidth: 220, fontWeight: 600, children: label }), _jsx(Box, { minWidth: 0, style: { overflowWrap: 'anywhere' }, children: value })] }));
+const Callout = ({ children }) => (_jsx(Box, { mt: 1, p: 1, bgcolor: "#fff8e1", borderLeft: "4px solid #f5a623", fontSize: 13, style: { overflowWrap: 'anywhere' }, children: children }));
+export const PreviewCard = ({ proposed, resolved, applying, applyError, onApply, onEdit, }) => {
+    var _a, _b, _c;
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    const preloadLibraries = (_a = resolved.sharedPreloadLibraries) !== null && _a !== void 0 ? _a : proposed.sharedPreloadLibraries;
+    const tuningEntries = Object.entries((_b = proposed.queryTuning) !== null && _b !== void 0 ? _b : {});
+    return (_jsxs(Box, { mt: 2, p: 2, border: "1px solid #e0e0e0", borderRadius: 4, "data-testid": "preview-card", children: [_jsx(Typography, { variant: "h6", children: "Proposed configuration" }), _jsxs(Box, { mt: 2, children: [_jsx(Field, { label: "Detected provider", value: proposed.detectedProvider || 'unknown' }), _jsx(Field, { label: "Docker image", value: resolved.dockerPath || mapping.imageType }), _jsx(Field, { label: "Postgres major version", value: String(proposed.pgMajorVersion || 'unknown') }), _jsx(Field, { label: "Databases", value: ((_c = proposed.databases) === null || _c === void 0 ? void 0 : _c.join(', ')) || '(none)' }), _jsx(Field, { label: "shared_buffers", value: proposed.sharedBuffers || '' }), _jsx(Field, { label: "shared_preload_libraries", value: preloadLibraries || '' })] }), tuningEntries.length > 0 && (_jsxs(Box, { mt: 2, children: [_jsx(Typography, { variant: "subtitle2", children: "Query tuning" }), _jsx(Box, { component: "table", mt: 1, style: { borderCollapse: 'collapse' }, children: _jsx("tbody", { children: tuningEntries.map(([k, v]) => (_jsxs("tr", { children: [_jsx("td", { style: { padding: '2px 16px 2px 0', fontWeight: 600 }, children: k }), _jsx("td", { style: { padding: '2px 0' }, children: v })] }, k))) }) })] })), _jsxs(Box, { mt: 2, children: [(mapping.fallback || proposed.detectedProvider === 'generic') && (_jsx(Callout, { children: "Could not detect a managed cloud provider; using the generic Postgres image. Switch to Expert mode if your source runs on a managed service and we missed it." })), !proposed.memoryProbed && (_jsxs(Callout, { children: ["Could not detect host memory; ", _jsx("code", { children: "shared_buffers" }), " is set to a 1\u00A0GB safe default. Adjust in Expert mode if your host has more RAM."] })), _jsx(Callout, { children: "Query tuning is copied from your source. If you use the RDS refresh tool, these values may not match production \u2014 review in Expert mode after the first retrieval run." }), resolved.isSe ? (_jsxs(Callout, { children: ["Shipping the ", _jsx("code", { children: resolved.dockerPath }), " image with its curated ", _jsx("code", { children: "shared_preload_libraries" }), " preset, so the detected extensions are bundled."] })) : (_jsxs(Callout, { children: ["We'll ship ", _jsx("code", { children: preloadLibraries }), ". If the chosen image does not bundle one of these libraries, the clone container will fail to start with a \"could not load library\" error \u2014 check", ' ', _jsx("code", { children: "docker logs dblab_server" }), " after Apply."] }))] }), _jsxs(Box, { mt: 2, display: "flex", alignItems: "center", children: [_jsxs(Button, { variant: "contained", color: "secondary", onClick: onApply, disabled: applying, "data-testid": "preview-apply", children: ["Apply & start retrieval", applying && _jsx(Spinner, { size: "sm" })] }), _jsx(Box, { ml: 2, children: _jsx(Link, { component: "button", type: "button", onClick: onEdit, "data-testid": "preview-edit", children: "Edit before applying" }) })] }), applyError && (_jsx(Box, { mt: 1, color: "#d32f2f", fontSize: 13, "data-testid": "apply-error", children: applyError }))] }));
+};

package/pages/Instance/Configuration/SimpleMode/index.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { SeImages } from '@postgres.ai/shared/types/api/endpoints/getSeImages';
+import { ProposedConfig } from '@postgres.ai/shared/types/api/endpoints/probeSource';
+import { ResolvedImage } from '../configOptions';
+import { FormValues } from '../useForm';
+declare type Props = {
+    instanceId: string;
+    disabled?: boolean;
+    onApplied?: () => void;
+    onEdit?: (proposed: ProposedConfig, password: string) => void;
+};
+export declare const buildProjectionFromProposed: (proposed: ProposedConfig, password: string, resolved?: ResolvedImage) => FormValues;
+export declare const resolveProbeImage: (proposed: ProposedConfig, getSeImages: (args: {
+    packageGroup: string;
+}) => Promise<SeImages[] | null | undefined>) => Promise<ResolvedImage>;
+export declare const SimpleMode: (({ instanceId, disabled, onApplied, onEdit }: Props) => JSX.Element) & {
+    displayName: string;
+};
+export {};

package/pages/Instance/Configuration/SimpleMode/index.js

@@ -0,0 +1,166 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { observer } from 'mobx-react-lite';
+import { Button, TextField, Typography } from '@material-ui/core';
+import Box from '@mui/material/Box';
+import { Spinner } from '@postgres.ai/shared/components/Spinner';
+import { useStores } from '@postgres.ai/shared/pages/Instance/context';
+import { providerKeyToImage, resolveDockerImagePath, selectSeImage, } from '../configOptions';
+import { PreviewCard } from './PreviewCard';
+// genericFallbackImage resolves the generic CE image for a probed source. Used
+// when no SE image is available (CE, or a managed provider with no SE image for
+// the detected major version).
+const genericFallbackImage = (proposed) => {
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    const isGeneric = mapping.imageType === 'Generic Postgres';
+    return {
+        dockerPath: resolveDockerImagePath(proposed.dockerImage, proposed.pgMajorVersion, proposed.dockerTag),
+        dockerTag: isGeneric ? proposed.dockerTag || mapping.defaultTag || '' : '',
+        sharedPreloadLibraries: proposed.sharedPreloadLibraries,
+        isSe: false,
+    };
+};
+// Translates a ProposedConfig from POST /admin/probe-source into the
+// FormValues shape the Expert form uses. Both Apply (→ updateConfig) and
+// Edit (→ formik.setValues) consume it, so the engine receives the same
+// projection regardless of which flow the user picks. The resolved image (SE
+// or generic) is passed in so the preview and the applied config never diverge.
+export const buildProjectionFromProposed = (proposed, password, resolved) => {
+    var _a;
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    const isGeneric = mapping.imageType === 'Generic Postgres';
+    const image = resolved !== null && resolved !== void 0 ? resolved : genericFallbackImage(proposed);
+    return {
+        debug: false,
+        dockerImage: isGeneric
+            ? String(proposed.pgMajorVersion)
+            : mapping.imageType,
+        dockerImageType: mapping.imageType,
+        dockerPath: image.dockerPath,
+        dockerTag: image.dockerTag,
+        sharedBuffers: proposed.sharedBuffers,
+        sharedPreloadLibraries: (_a = image.sharedPreloadLibraries) !== null && _a !== void 0 ? _a : proposed.sharedPreloadLibraries,
+        // tuningParams is typed as string on FormValues but updateConfig.ts
+        // spreads it as a key-value object; cast matches the Expert form's
+        // formatTuningParamsToObj(...) as unknown as string pattern.
+        tuningParams: { ...proposed.queryTuning },
+        timetable: '0 0 * * *',
+        dbname: proposed.source.dbname,
+        host: proposed.source.host,
+        port: String(proposed.source.port),
+        username: proposed.source.username,
+        password,
+        databases: proposed.databases.join(' '),
+        dumpParallelJobs: '',
+        dumpIgnoreErrors: false,
+        restoreParallelJobs: '',
+        // managed sources reference cloud-only extensions/objects (e.g. supabase_vault)
+        // that are absent from the clone image; best-effort restore skips them.
+        restoreIgnoreErrors: true,
+        restoreConfigs: '',
+        pgDumpCustomOptions: '',
+        // skip ownership and privileges on restore: managed sources (Supabase, RDS)
+        // reference roles that do not exist in the clone, which would abort pg_restore.
+        pgRestoreCustomOptions: '--no-owner --no-privileges --no-tablespaces',
+        retrievalMode: 'logical',
+        physicalTool: '',
+        physicalDockerImage: '',
+        physicalSyncEnabled: false,
+        physicalWalgBackupName: '',
+        physicalPgbackrestStanza: '',
+        physicalPgbackrestDelta: false,
+        physicalEnvs: [],
+    };
+};
+// resolveProbeImage selects the platform SE image for a managed provider when
+// the SE catalog is reachable — SE/Enterprise instances expose it (platformUrl
+// set), CE returns undefined. Falls back to the generic image for CE and for
+// managed providers with no SE image at the detected major version.
+export const resolveProbeImage = async (proposed, getSeImages) => {
+    var _a;
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    if (mapping.imageType !== 'Generic Postgres') {
+        const seImages = await getSeImages({ packageGroup: mapping.imageType });
+        const se = selectSeImage(seImages, proposed.pgMajorVersion);
+        if (se) {
+            return {
+                dockerPath: se.location,
+                dockerTag: se.tag,
+                sharedPreloadLibraries: (_a = se.pg_config_presets) === null || _a === void 0 ? void 0 : _a.shared_preload_libraries,
+                isSe: true,
+            };
+        }
+    }
+    return genericFallbackImage(proposed);
+};
+export const SimpleMode = observer(({ instanceId, disabled, onApplied, onEdit }) => {
+    const stores = useStores();
+    const main = stores.main;
+    const [url, setUrl] = useState('');
+    const [password, setPassword] = useState('');
+    const [probing, setProbing] = useState(false);
+    const [probeError, setProbeError] = useState(null);
+    const [proposed, setProposed] = useState(null);
+    const [resolved, setResolved] = useState(null);
+    const [applying, setApplying] = useState(false);
+    const [applyError, setApplyError] = useState(null);
+    const onDetect = async () => {
+        setProbing(true);
+        setProbeError(null);
+        setProposed(null);
+        setResolved(null);
+        setApplyError(null);
+        const result = await main.probeSource({ url, password });
+        if (!result) {
+            setProbing(false);
+            setProbeError('Probe is not available on this instance.');
+            return;
+        }
+        if (result.error) {
+            setProbing(false);
+            setProbeError(result.error.message);
+            return;
+        }
+        if (result.response) {
+            const image = await resolveProbeImage(result.response, main.getSeImages);
+            setResolved(image);
+            setProposed(result.response);
+        }
+        setProbing(false);
+    };
+    const onApply = async () => {
+        var _a;
+        if (!proposed || !resolved)
+            return;
+        setApplying(true);
+        setApplyError(null);
+        try {
+            const projection = buildProjectionFromProposed(proposed, password, resolved);
+            const response = await main.updateConfig(projection, instanceId);
+            if (!response) {
+                setApplyError((_a = main.configError) !== null && _a !== void 0 ? _a : 'Could not apply the proposed configuration.');
+                return;
+            }
+            const refresh = await main.fullRefresh(instanceId);
+            if (refresh === null || refresh === void 0 ? void 0 : refresh.error) {
+                setApplyError(`Configuration applied, but starting data retrieval failed: ${refresh.error.message}`);
+                return;
+            }
+            onApplied === null || onApplied === void 0 ? void 0 : onApplied();
+        }
+        catch (err) {
+            setApplyError(err instanceof Error
+                ? err.message
+                : 'Could not apply the proposed configuration.');
+        }
+        finally {
+            setApplying(false);
+        }
+    };
+    const handleEdit = () => {
+        if (proposed)
+            onEdit === null || onEdit === void 0 ? void 0 : onEdit(proposed, password);
+    };
+    const canDetect = !probing && url.trim().length > 0 && password.length > 0 && !disabled;
+    return (_jsxs(Box, { mt: 2, mb: 2, "data-testid": "simple-mode", children: [!proposed && (_jsxs(Box, { children: [_jsx(Typography, { variant: "h6", children: "Simple configuration" }), _jsx(Typography, { variant: "body2", children: "Paste your source connection string and password. We'll probe the source, propose a configuration, and let you review before starting retrieval." }), _jsx(Box, { mt: 2, children: _jsx(TextField, { label: "Connection string", placeholder: "postgres://user@host:5432/dbname", value: url, onChange: (e) => setUrl(e.target.value), fullWidth: true, disabled: probing || disabled, inputProps: { 'data-testid': 'simple-url' } }) }), _jsx(Box, { mt: 2, children: _jsx(TextField, { label: "Password", type: "password", value: password, onChange: (e) => setPassword(e.target.value), fullWidth: true, disabled: probing || disabled, inputProps: { 'data-testid': 'simple-password' } }) }), _jsx(Box, { mt: 2, children: _jsxs(Button, { variant: "contained", color: "secondary", onClick: onDetect, disabled: !canDetect, "data-testid": "simple-detect", children: ["Detect & preview", probing && _jsx(Spinner, { size: "sm" })] }) }), probeError && (_jsx(Box, { mt: 1, color: "#d32f2f", fontSize: 13, "data-testid": "probe-error", children: probeError }))] })), proposed && resolved && (_jsx(PreviewCard, { proposed: proposed, resolved: resolved, applying: applying, applyError: applyError, onApply: onApply, onEdit: handleEdit }))] }));
+});

package/pages/Instance/Configuration/configMode.d.ts

@@ -0,0 +1,2 @@
+export declare type ConfigMode = 'simple' | 'expert';
+export declare const getInitialConfigMode: (host: string | undefined, retrievalMode?: string) => ConfigMode;

package/pages/Instance/Configuration/configMode.js

@@ -0,0 +1,7 @@
+// Picks the default Configuration tab when the page first finishes loading
+// the server config. An unconfigured instance lands on Simple; an instance
+// that already has a source host filled in OR a non-logical retrieval mode
+// configured lands on Expert so the user sees the form they previously
+// interacted with. Physical-mode users do not have a host field but still
+// need to land on Expert because Simple-mode targets logical retrieval.
+export const getInitialConfigMode = (host, retrievalMode) => (host || retrievalMode === 'physical' ? 'expert' : 'simple');

package/pages/Instance/Configuration/configOptions.d.ts

@@ -0,0 +1,25 @@
+import { SeImages } from '@postgres.ai/shared/types/api/endpoints/getSeImages';
+export declare type ProviderImageMapping = {
+    imageType: string;
+    defaultTag?: string;
+    fallback: boolean;
+};
+export declare const genericImagePathForVersion: (pgMajorVersion: number) => string;
+export declare type ResolvedImage = {
+    dockerPath: string;
+    dockerTag: string;
+    sharedPreloadLibraries?: string;
+    isSe: boolean;
+};
+export declare const selectSeImage: (seImages: SeImages[] | null | undefined, pgMajorVersion: number) => SeImages | undefined;
+export declare const resolveDockerImagePath: (providerKey: string, pgMajorVersion: number, dockerTag?: string) => string;
+export declare const providerKeyToImage: (providerKey: string, pgMajorVersion: number) => ProviderImageMapping;
+export declare const dockerImageOptions: {
+    name: string;
+    type: string;
+}[];
+export declare const imagePgOptions: {
+    optionType: string;
+    pgDumpOptions: string[];
+    pgRestoreOptions: never[];
+}[];

package/pages/Instance/Configuration/configOptions.js

@@ -0,0 +1,130 @@
+import { dockerImagesConfig, genericImagePrefix } from './dockerCatalog';
+// Mapping from the engine probe's provider key (probe.Provider) to a
+// dockerImageOptions.type value the form already understands. Keys must
+// match the values defined in engine/internal/retrieval/probe/provider.go
+// (ProviderRDS, ProviderAurora, etc.) — see Task 18 in the plan.
+const providerKeyToImageType = {
+    generic: 'Generic Postgres',
+    rds: 'rds',
+    aurora: 'aurora',
+    cloudsql: 'google-cloud-sql',
+    supabase: 'supabase',
+    heroku: 'heroku',
+    timescale: 'timescale-cloud',
+};
+// Reads the most recent tag for a given PG major from the shared catalog.
+// SE images (rds, aurora, etc.) require the platform-only getSeImages call
+// and have no entry here — they return defaultTag: undefined.
+const genericDefaultTag = (pgMajorVersion) => {
+    if (!pgMajorVersion)
+        return undefined;
+    const version = String(pgMajorVersion);
+    const tags = dockerImagesConfig[version];
+    if (!tags || tags.length === 0)
+        return undefined;
+    return `${version}-${tags[0]}`;
+};
+// genericImagePathForVersion returns a pullable generic extended-postgres
+// reference for a PG major version, or '' when the version is unknown. Simple
+// mode uses it as the CE fallback for managed providers, whose SE images are
+// only resolvable through the platform-only getSeImages call.
+export const genericImagePathForVersion = (pgMajorVersion) => {
+    const tag = genericDefaultTag(pgMajorVersion);
+    return tag ? `${genericImagePrefix}:${tag}` : '';
+};
+// selectSeImage picks the SE catalog entry matching the detected major version.
+// Returns undefined when the catalog is empty (CE) or has no matching version,
+// which signals the caller to fall back to the generic image.
+export const selectSeImage = (seImages, pgMajorVersion) => seImages === null || seImages === void 0 ? void 0 : seImages.find((image) => image.pg_major_version === String(pgMajorVersion));
+// resolveDockerImagePath returns the concrete image reference Simple mode ships
+// for a probed source. Managed providers fall back to the generic image in CE,
+// so both the Apply payload and the preview show the same value.
+export const resolveDockerImagePath = (providerKey, pgMajorVersion, dockerTag) => {
+    const mapping = providerKeyToImage(providerKey, pgMajorVersion);
+    const tag = dockerTag || mapping.defaultTag || '';
+    if (mapping.imageType === 'Generic Postgres') {
+        return tag ? `${genericImagePrefix}:${tag}` : '';
+    }
+    return genericImagePathForVersion(pgMajorVersion);
+};
+// Resolves a probe provider key to a concrete docker image type the
+// Configuration form can write into the projection. Unknown keys (including
+// "azure", which has no matching SE image today) fall back to the generic
+// Postgres image and set fallback=true so the UI can warn.
+export const providerKeyToImage = (providerKey, pgMajorVersion) => {
+    const known = providerKeyToImageType[providerKey];
+    if (!known) {
+        return {
+            imageType: 'Generic Postgres',
+            defaultTag: genericDefaultTag(pgMajorVersion),
+            fallback: true,
+        };
+    }
+    if (known === 'Generic Postgres') {
+        return {
+            imageType: 'Generic Postgres',
+            defaultTag: genericDefaultTag(pgMajorVersion),
+            fallback: false,
+        };
+    }
+    return { imageType: known, defaultTag: undefined, fallback: false };
+};
+export const dockerImageOptions = [
+    {
+        name: 'Generic PostgreSQL (postgresai/extended-postgres)',
+        type: 'Generic Postgres',
+    },
+    { name: 'Generic PostgreSQL with PostGIS', type: 'postgis' },
+    { name: 'Amazon RDS for PostgreSQL', type: 'rds' },
+    { name: 'Amazon RDS Aurora for PostgreSQL', type: 'aurora' },
+    { name: 'Heroku PostgreSQL', type: 'heroku' },
+    { name: 'Supabase PostgreSQL', type: 'supabase' },
+    { name: 'Google Cloud SQL for PostgreSQL', type: 'google-cloud-sql' },
+    {
+        name: 'Timescale Cloud',
+        type: 'timescale-cloud',
+    },
+    { name: 'Custom image', type: 'custom' },
+];
+export const imagePgOptions = [
+    {
+        optionType: 'Generic Postgres',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'postgis',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'rds',
+        pgDumpOptions: ['--exclude-schema=awsdms'],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'aurora',
+        pgDumpOptions: ['--exclude-schema=awsdms'],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'heroku',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'supabase',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'google-cloud-sql',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+    {
+        optionType: 'timescale-cloud',
+        pgDumpOptions: [],
+        pgRestoreOptions: [],
+    },
+];