@postgres.ai/shared 4.0.2-pr-1149 → 4.0.2-pr-1148.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postgres.ai/shared",
-  "version": "4.0.2-pr-1149",
+  "version": "4.0.2-pr-1148.1",
   "main": "index.js",
   "types": "index.d.ts",
   "peerDependencies": {

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

@@ -0,0 +1,11 @@
+/// <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 EnvsEditor: ({ envs, onChange, suggestions, disabled, keyErrors, }: Props) => JSX.Element;
+export {};

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

@@ -0,0 +1,24 @@
+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';
+// 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));
+    return (_jsxs(Box, { mt: 1, "data-testid": "envs-editor", children: [_jsx(Typography, { variant: "subtitle2", children: "Environment variables" }), 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, 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,11 @@
+/// <reference types="react" />
+import { ProposedConfig } from '@postgres.ai/shared/types/api/endpoints/probeSource';
+declare type Props = {
+    proposed: ProposedConfig;
+    applying: boolean;
+    applyError: string | null;
+    onApply: () => void;
+    onEdit: () => void;
+};
+export declare const PreviewCard: ({ proposed, 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, { style: { wordBreak: 'break-all' }, children: value })] }));
+const Callout = ({ children }) => (_jsx(Box, { mt: 1, p: 1, bgcolor: "#fff8e1", borderLeft: "4px solid #f5a623", fontSize: 13, children: children }));
+export const PreviewCard = ({ proposed, applying, applyError, onApply, onEdit, }) => {
+    var _a, _b;
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    const resolvedTag = proposed.dockerTag || mapping.defaultTag || '(latest)';
+    const tuningEntries = Object.entries((_a = proposed.queryTuning) !== null && _a !== void 0 ? _a : {});
+    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: mapping.imageType }), _jsx(Field, { label: "Docker tag", value: resolvedTag }), _jsx(Field, { label: "Postgres major version", value: String(proposed.pgMajorVersion || 'unknown') }), _jsx(Field, { label: "Databases", value: ((_b = proposed.databases) === null || _b === void 0 ? void 0 : _b.join(', ')) || '(none)' }), _jsx(Field, { label: "shared_buffers", value: proposed.sharedBuffers || '' }), _jsx(Field, { label: "shared_preload_libraries", value: proposed.sharedPreloadLibraries || '' })] }), 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." }), _jsxs(Callout, { children: ["We'll ship ", _jsx("code", { children: proposed.sharedPreloadLibraries }), ". 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,14 @@
+/// <reference types="react" />
+import { ProposedConfig } from '@postgres.ai/shared/types/api/endpoints/probeSource';
+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) => FormValues;
+export declare const SimpleMode: (({ instanceId, disabled, onApplied, onEdit }: Props) => JSX.Element) & {
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,107 @@
+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 } from '../configOptions';
+import { genericImagePrefix } from '../dockerCatalog';
+import { PreviewCard } from './PreviewCard';
+// 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.
+export const buildProjectionFromProposed = (proposed, password) => {
+    const mapping = providerKeyToImage(proposed.dockerImage, proposed.pgMajorVersion);
+    const tag = proposed.dockerTag || mapping.defaultTag || '';
+    const isGeneric = mapping.imageType === 'Generic Postgres';
+    const dockerPath = isGeneric ? `${genericImagePrefix}:${tag}` : '';
+    return {
+        debug: false,
+        dockerImage: isGeneric
+            ? String(proposed.pgMajorVersion)
+            : mapping.imageType,
+        dockerImageType: mapping.imageType,
+        dockerPath,
+        dockerTag: tag,
+        sharedBuffers: proposed.sharedBuffers,
+        sharedPreloadLibraries: 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: '',
+        restoreIgnoreErrors: false,
+        restoreConfigs: '',
+        pgDumpCustomOptions: '',
+        pgRestoreCustomOptions: '',
+        retrievalMode: 'logical',
+        physicalTool: '',
+        physicalDockerImage: '',
+        physicalSyncEnabled: false,
+        physicalWalgBackupName: '',
+        physicalPgbackrestStanza: '',
+        physicalPgbackrestDelta: false,
+        physicalEnvs: [],
+    };
+};
+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 [applying, setApplying] = useState(false);
+    const [applyError, setApplyError] = useState(null);
+    const onDetect = async () => {
+        setProbing(true);
+        setProbeError(null);
+        setProposed(null);
+        setApplyError(null);
+        const result = await main.probeSource({ url, password });
+        setProbing(false);
+        if (!result) {
+            setProbeError('Probe is not available on this instance.');
+            return;
+        }
+        if (result.error) {
+            setProbeError(result.error.message);
+            return;
+        }
+        if (result.response)
+            setProposed(result.response);
+    };
+    const onApply = async () => {
+        var _a;
+        if (!proposed)
+            return;
+        setApplying(true);
+        setApplyError(null);
+        const projection = buildProjectionFromProposed(proposed, password);
+        const response = await main.updateConfig(projection, instanceId);
+        setApplying(false);
+        if (!response) {
+            setApplyError((_a = main.configError) !== null && _a !== void 0 ? _a : 'Could not apply the proposed configuration.');
+            return;
+        }
+        onApplied === null || onApplied === void 0 ? void 0 : onApplied();
+    };
+    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 && (_jsx(PreviewCard, { proposed: proposed, 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

@@ -1,3 +1,9 @@
+export declare type ProviderImageMapping = {
+    imageType: string;
+    defaultTag?: string;
+    fallback: boolean;
+};
+export declare const providerKeyToImage: (providerKey: string, pgMajorVersion: number) => ProviderImageMapping;
 export declare const dockerImageOptions: {
     name: string;
     type: string;

package/pages/Instance/Configuration/configOptions.js

@@ -1,3 +1,51 @@
+import { dockerImagesConfig } 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]}`;
+};
+// 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)',

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

@@ -0,0 +1,20 @@
+export declare type ConnectionFields = {
+    host: string;
+    port: string;
+    username: string;
+    dbname: string;
+};
+export declare type ParseResult = {
+    fields: ConnectionFields;
+    portWasExplicit: boolean;
+};
+export declare class ConnectionStringError extends Error {
+}
+export declare const ErrPasswordInConnectionString = "Password must be entered in the Password field, not the connection string.";
+export declare const ErrMultiHost = "Multi-host connection strings are not supported.";
+export declare const ErrInvalidConnectionString = "Could not parse the connection string.";
+export declare const connectionStringToFields: (s: string) => ParseResult;
+export declare type SerializeOptions = {
+    omitDefaultPort?: boolean;
+};
+export declare const connectionStringFromFields: (fields: ConnectionFields, opts?: SerializeOptions) => string;

package/pages/Instance/Configuration/connectionString.js

@@ -0,0 +1,129 @@
+// connectionString.ts — Expert-mode helper that converts between the
+// (host, port, username, dbname) shape stored in `server.yml` and the
+// single URL field the form exposes. The engine remains the source of
+// truth for actual probing (see engine/internal/retrieval/probe/parser.go);
+// this parser only powers the form's load/save round-trip.
+//
+// Accepts both URI form (postgres://user@host:5432/dbname) and DSN form
+// (host=db port=5432 user=app dbname=shop). Rejects any input that carries
+// a password — passwords belong in the masked field, never the URL field.
+export class ConnectionStringError extends Error {
+}
+export const ErrPasswordInConnectionString = 'Password must be entered in the Password field, not the connection string.';
+export const ErrMultiHost = 'Multi-host connection strings are not supported.';
+export const ErrInvalidConnectionString = 'Could not parse the connection string.';
+const URI_SCHEMES = ['postgres:', 'postgresql:'];
+const isUri = (s) => URI_SCHEMES.some((p) => s.toLowerCase().startsWith(p));
+const stripBrackets = (h) => (h.startsWith('[') && h.endsWith(']') ? h.slice(1, -1) : h);
+const parseUri = (s) => {
+    let url;
+    try {
+        url = new URL(s);
+    }
+    catch {
+        throw new ConnectionStringError(ErrInvalidConnectionString);
+    }
+    if (url.password)
+        throw new ConnectionStringError(ErrPasswordInConnectionString);
+    if (!url.hostname)
+        throw new ConnectionStringError(ErrInvalidConnectionString);
+    if (url.hostname.includes(','))
+        throw new ConnectionStringError(ErrMultiHost);
+    const portWasExplicit = url.port !== '';
+    const path = url.pathname.startsWith('/') ? url.pathname.slice(1) : url.pathname;
+    const dbname = path.includes(',') ? '' : decodeURIComponent(path);
+    return {
+        fields: {
+            host: stripBrackets(url.hostname),
+            port: portWasExplicit ? url.port : '5432',
+            username: url.username ? decodeURIComponent(url.username) : '',
+            dbname,
+        },
+        portWasExplicit,
+    };
+};
+// Tokenizer for libpq DSN form: key=value pairs, values may be single-quoted
+// when they contain spaces (libpq spec). Throws on malformed input.
+const tokenizeDsn = (s) => {
+    const out = {};
+    let i = 0;
+    while (i < s.length) {
+        // skip leading whitespace
+        while (i < s.length && /\s/.test(s[i]))
+            i++;
+        if (i >= s.length)
+            break;
+        // read key
+        const keyStart = i;
+        while (i < s.length && s[i] !== '=' && !/\s/.test(s[i]))
+            i++;
+        if (i >= s.length || s[i] !== '=')
+            throw new ConnectionStringError(ErrInvalidConnectionString);
+        const key = s.slice(keyStart, i);
+        i++; // skip '='
+        // read value (possibly quoted)
+        let value = '';
+        if (s[i] === "'") {
+            i++;
+            while (i < s.length && s[i] !== "'") {
+                if (s[i] === '\\' && i + 1 < s.length) {
+                    value += s[i + 1];
+                    i += 2;
+                    continue;
+                }
+                value += s[i];
+                i++;
+            }
+            if (i >= s.length)
+                throw new ConnectionStringError(ErrInvalidConnectionString);
+            i++; // skip closing quote
+        }
+        else {
+            while (i < s.length && !/\s/.test(s[i])) {
+                value += s[i];
+                i++;
+            }
+        }
+        out[key.toLowerCase()] = value;
+    }
+    return out;
+};
+const parseDsn = (s) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const tokens = tokenizeDsn(s);
+    if (tokens.password)
+        throw new ConnectionStringError(ErrPasswordInConnectionString);
+    const host = (_b = (_a = tokens.host) !== null && _a !== void 0 ? _a : tokens.hostaddr) !== null && _b !== void 0 ? _b : '';
+    if (host.includes(','))
+        throw new ConnectionStringError(ErrMultiHost);
+    const portRaw = (_c = tokens.port) !== null && _c !== void 0 ? _c : '';
+    const portWasExplicit = portRaw !== '';
+    return {
+        fields: {
+            host,
+            port: portWasExplicit ? portRaw : '5432',
+            username: (_e = (_d = tokens.user) !== null && _d !== void 0 ? _d : tokens.username) !== null && _e !== void 0 ? _e : '',
+            dbname: (_g = (_f = tokens.dbname) !== null && _f !== void 0 ? _f : tokens.database) !== null && _g !== void 0 ? _g : '',
+        },
+        portWasExplicit,
+    };
+};
+export const connectionStringToFields = (s) => {
+    const trimmed = s.trim();
+    if (!trimmed)
+        throw new ConnectionStringError(ErrInvalidConnectionString);
+    if (isUri(trimmed))
+        return parseUri(trimmed);
+    if (trimmed.includes('='))
+        return parseDsn(trimmed);
+    throw new ConnectionStringError(ErrInvalidConnectionString);
+};
+// formatHost wraps IPv6 literals in brackets so the resulting URI parses cleanly.
+const formatHost = (host) => (host.includes(':') ? `[${host}]` : host);
+export const connectionStringFromFields = (fields, opts = {}) => {
+    const userPart = fields.username ? `${encodeURIComponent(fields.username)}@` : '';
+    const showPort = fields.port && !(opts.omitDefaultPort && fields.port === '5432');
+    const portPart = showPort ? `:${fields.port}` : '';
+    const dbPart = fields.dbname ? `/${encodeURIComponent(fields.dbname)}` : '';
+    return `postgres://${userPart}${formatHost(fields.host)}${portPart}${dbPart}`;
+};

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

@@ -0,0 +1,2 @@
+export declare const genericImagePrefix = "postgresai/extended-postgres";
+export declare const dockerImagesConfig: Record<string, string[]>;

package/pages/Instance/Configuration/dockerCatalog.js

@@ -0,0 +1,19 @@
+// Shared image-catalog constants. Kept in its own module so both
+// `configOptions.ts` and `utils/index.ts` can read them without creating
+// an import cycle (utils → configOptions today).
+export const genericImagePrefix = 'postgresai/extended-postgres';
+// Predefined Docker image catalog for the Generic Postgres image. If a
+// user's config references a tag not listed here, createEnhancedDockerImages
+// in utils/index.ts appends it at runtime.
+export const dockerImagesConfig = {
+    '9.6': ['0.5.3', '0.5.2', '0.5.1'],
+    '10': ['0.5.3', '0.5.2', '0.5.1'],
+    '11': ['0.5.3', '0.5.2', '0.5.1'],
+    '12': ['0.5.3', '0.5.2', '0.5.1'],
+    '13': ['0.5.3', '0.5.2', '0.5.1'],
+    '14': ['0.5.3', '0.5.2', '0.5.1'],
+    '15': ['0.5.3', '0.5.2', '0.5.1'],
+    '16': ['0.5.3', '0.5.2', '0.5.1'],
+    '17': ['0.5.3', '0.5.2', '0.5.1'],
+    '18': ['0.6.1'],
+};

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

@@ -1,9 +1,8 @@
 /// <reference types="react" />
-export declare const Configuration: (({ instanceId, switchActiveTab, reload, isConfigurationActive, disableConfigModification, }: {
+export declare const Configuration: (({ instanceId, switchActiveTab, reload, disableConfigModification, }: {
     instanceId: string;
     switchActiveTab: (_: null, activeTab: number) => void;
     reload: () => void;
-    isConfigurationActive: boolean;
     disableConfigModification?: boolean | undefined;
 }) => JSX.Element) & {
     displayName: string;