ltcai 4.1.0 → 4.3.0

package/frontend/src/api/client.ts

@@ -210,11 +210,20 @@ export const latticeApi = {
   graph: () => get("/knowledge-graph/graph", { nodes: [], edges: [] }),
   graphStats: () => get("/knowledge-graph/stats", { nodes: {}, edges: {}, total_nodes: 0, total_edges: 0 }),
   graphPortability: () => get("/api/knowledge-graph/portability", {}),
+  brainStorage: () => get("/api/brain/storage", {}),
+  backupHealth: () => get("/api/knowledge-graph/backup-health", {}),
+  dockerPostgres: (body: { consent: boolean; dry_run?: boolean; port?: number }) => post("/api/brain/storage/postgres/docker", body, {}),
+  migratePostgres: (body: { dsn: string; schema_name?: string; dry_run?: boolean }) => post("/api/brain/storage/migrate-postgres", body, {}),
   graphProvenance: (limit = 50) => get("/api/knowledge-graph/provenance", { items: [] }, { limit }),
   graphCoverage: () => get("/knowledge-graph/provenance/coverage", {}),
   graphExport: () => post("/api/knowledge-graph/export", {}, {}),
   graphBackup: () => post("/api/knowledge-graph/backup", {}, {}),
   graphImport: (artifact: unknown, dry_run = true) => post("/api/knowledge-graph/import", { artifact, mode: "merge", dry_run }, {}),
+  brainArchive: (body: { path?: string | null; passphrase: string }) => post("/api/knowledge-graph/archive", body, {}),
+  brainArchiveInspect: (body: { path: string; passphrase?: string | null }) => post("/api/knowledge-graph/archive/inspect", body, {}),
+  brainArchiveVerify: (body: { path: string; passphrase: string }) => post("/api/knowledge-graph/archive/verify", body, {}),
+  brainArchiveRestore: (body: { path: string; passphrase: string; dry_run?: boolean; confirm?: boolean }) => post("/api/knowledge-graph/archive/restore", body, {}),
+  brainArchiveImport: (body: { path: string; passphrase: string; dry_run?: boolean; confirm?: boolean }) => post("/api/knowledge-graph/archive/import", body, {}),
   hybridSearch: async (query: string, weights?: unknown) => {
     const res = await post<Record<string, unknown>>("/api/search/hybrid", { query, ...(weights ? { weights } : {}) }, { matches: [] });
     const data = res.data as Record<string, unknown>;
@@ -311,6 +320,7 @@ export const latticeApi = {
   adminAudit: () => get("/admin/audit", { recent_events: [] }),
   adminRoles: () => get("/admin/roles", { roles: [] }),
   adminPolicies: () => get("/admin/policies", { policies: [] }),
+  adminProductHardening: () => get("/admin/product-hardening", {}),
   adminSecurity: () => get("/admin/security/overview", {}),
   vpcStatus: () => get("/vpc/status", {}),
   toolPermissions: () => get("/tools/permissions", { permissions: [] }),

package/frontend/src/api/openapi.ts

@@ -207,6 +207,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/admin/product-hardening": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Admin Product Hardening */
+        get: operations["admin_product_hardening_admin_product_hardening_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/admin/roles": {
         parameters: {
             query?: never;
@@ -892,6 +909,57 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/brain/storage": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Brain Storage Status */
+        get: operations["brain_storage_status_api_brain_storage_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brain/storage/migrate-postgres": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Migrate Sqlite To Postgres */
+        post: operations["migrate_sqlite_to_postgres_api_brain_storage_migrate_postgres_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brain/storage/postgres/docker": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Setup Postgres Docker */
+        post: operations["setup_postgres_docker_api_brain_storage_postgres_docker_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/browser/ingest-current-tab": {
         parameters: {
             query?: never;
@@ -1212,6 +1280,91 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/knowledge-graph/archive": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Encrypted Archive */
+        post: operations["encrypted_archive_api_knowledge_graph_archive_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/knowledge-graph/archive/import": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Import Encrypted Archive */
+        post: operations["import_encrypted_archive_api_knowledge_graph_archive_import_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/knowledge-graph/archive/inspect": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Inspect Encrypted Archive */
+        post: operations["inspect_encrypted_archive_api_knowledge_graph_archive_inspect_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/knowledge-graph/archive/restore": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Restore Encrypted Archive */
+        post: operations["restore_encrypted_archive_api_knowledge_graph_archive_restore_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/knowledge-graph/archive/verify": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Verify Encrypted Archive */
+        post: operations["verify_encrypted_archive_api_knowledge_graph_archive_verify_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/knowledge-graph/backup": {
         parameters: {
             query?: never;
@@ -1229,6 +1382,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/knowledge-graph/backup-health": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Backup Health */
+        get: operations["backup_health_api_knowledge_graph_backup_health_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/knowledge-graph/export": {
         parameters: {
             query?: never;
@@ -5712,6 +5882,62 @@ export interface components {
             /** Text */
             text: string;
         };
+        /** DockerPostgresRequest */
+        DockerPostgresRequest: {
+            /**
+             * Consent
+             * @default false
+             */
+            consent: boolean;
+            /**
+             * Dry Run
+             * @default false
+             */
+            dry_run: boolean;
+            /**
+             * Port
+             * @default 5432
+             */
+            port: number;
+        };
+        /** EncryptedArchiveRequest */
+        EncryptedArchiveRequest: {
+            /** Passphrase */
+            passphrase: string;
+            /** Path */
+            path?: string | null;
+        };
+        /** EncryptedInspectRequest */
+        EncryptedInspectRequest: {
+            /** Passphrase */
+            passphrase?: string | null;
+            /** Path */
+            path: string;
+        };
+        /** EncryptedRestoreRequest */
+        EncryptedRestoreRequest: {
+            /**
+             * Confirm
+             * @default false
+             */
+            confirm: boolean;
+            /**
+             * Dry Run
+             * @default false
+             */
+            dry_run: boolean;
+            /** Passphrase */
+            passphrase: string;
+            /** Path */
+            path: string;
+        };
+        /** EncryptedVerifyRequest */
+        EncryptedVerifyRequest: {
+            /** Passphrase */
+            passphrase: string;
+            /** Path */
+            path: string;
+        };
         /** ExportRequest */
         ExportRequest: {
             /** Filters */
@@ -6272,6 +6498,16 @@ export interface components {
         };
         /** RestoreRequest */
         RestoreRequest: {
+            /**
+             * Confirm
+             * @default false
+             */
+            confirm: boolean;
+            /**
+             * Dry Run
+             * @default false
+             */
+            dry_run: boolean;
             /** Path */
             path: string;
             /**
@@ -6280,6 +6516,21 @@ export interface components {
              */
             verify: boolean;
         };
+        /** SQLiteToPostgresRequest */
+        SQLiteToPostgresRequest: {
+            /**
+             * Dry Run
+             * @default true
+             */
+            dry_run: boolean;
+            /** Dsn */
+            dsn: string;
+            /**
+             * Schema Name
+             * @default lattice_brain
+             */
+            schema_name: string;
+        };
         /** SearchRequest */
         SearchRequest: {
             /**
@@ -7326,6 +7577,26 @@ export interface operations {
             };
         };
     };
+    admin_product_hardening_admin_product_hardening_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
     admin_roles_admin_roles_get: {
         parameters: {
             query?: never;
@@ -8576,6 +8847,92 @@ export interface operations {
             };
         };
     };
+    brain_storage_status_api_brain_storage_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
+    migrate_sqlite_to_postgres_api_brain_storage_migrate_postgres_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SQLiteToPostgresRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    setup_postgres_docker_api_brain_storage_postgres_docker_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DockerPostgresRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     ingest_current_tab_api_browser_ingest_current_tab_post: {
         parameters: {
             query?: never;
@@ -9252,6 +9609,171 @@ export interface operations {
             };
         };
     };
+    encrypted_archive_api_knowledge_graph_archive_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedArchiveRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    import_encrypted_archive_api_knowledge_graph_archive_import_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedRestoreRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    inspect_encrypted_archive_api_knowledge_graph_archive_inspect_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedInspectRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    restore_encrypted_archive_api_knowledge_graph_archive_restore_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedRestoreRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    verify_encrypted_archive_api_knowledge_graph_archive_verify_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["EncryptedVerifyRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     backup_graph_api_knowledge_graph_backup_post: {
         parameters: {
             query?: never;
@@ -9285,6 +9807,26 @@ export interface operations {
             };
         };
     };
+    backup_health_api_knowledge_graph_backup_health_get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+        };
+    };
     export_graph_api_knowledge_graph_export_post: {
         parameters: {
             query?: never;