@lanonasis/cli 3.9.4 → 3.9.6

package/dist/index.js

@@ -53,6 +53,18 @@ program
         process.env.MEMORY_API_URL = opts.apiUrl;
     }
     process.env.CLI_OUTPUT_FORMAT = opts.output;
+    const forceApiFromEnv = process.env.LANONASIS_FORCE_API === 'true' ||
+        process.env.CLI_FORCE_API === 'true' ||
+        process.env.ONASIS_FORCE_API === 'true';
+    const forceApiFromConfig = cliConfig.get('forceApi') === true ||
+        cliConfig.get('connectionTransport') === 'api';
+    const forceDirectApi = forceApiFromEnv || forceApiFromConfig || opts.mcp === false;
+    if (process.env.CLI_VERBOSE === 'true') {
+        console.log(colors.muted(`transport flags: env=${forceApiFromEnv} config=${forceApiFromConfig} no_mcp=${opts.mcp === false}`));
+    }
+    if (forceDirectApi) {
+        process.env.LANONASIS_FORCE_API = 'true';
+    }
     const skipOnboarding = actionCommand.name() === 'init' ||
         actionCommand.name() === 'auth' ||
         actionCommand.parent?.name?.() === 'auth';
@@ -76,7 +88,9 @@ program
         actionCommand.parent?.name?.() === 'mcp' ||
         actionCommand.name() === 'mcp-server' ||
         actionCommand.parent?.name?.() === 'mcp-server';
-    if (opts.mcp !== false && !isMcpFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
+    const isConfigFlow = actionCommand.name() === 'config' ||
+        actionCommand.parent?.name?.() === 'config';
+    if (!forceDirectApi && !isMcpFlow && !isConfigFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
         try {
             const client = getMCPClient();
             if (!client.isConnectedToServer()) {
@@ -94,6 +108,9 @@ program
             }
         }
     }
+    else if (forceDirectApi && process.env.CLI_VERBOSE === 'true') {
+        console.log(colors.muted('MCP auto-connect skipped (force direct API enabled)'));
+    }
 });
 // Enhanced global error handler
 process.on('uncaughtException', (error) => {
@@ -399,11 +416,10 @@ const topicCmd = program
     .description('Topic management commands');
 requireAuth(topicCmd);
 topicCommands(topicCmd);
-// Configuration commands (require auth)
+// Configuration commands (no auth required)
 const configCmd = program
     .command('config')
     .description('Configuration management');
-requireAuth(configCmd);
 configCommands(configCmd);
 // Organization commands (require auth)
 const orgCmd = program
@@ -614,18 +630,30 @@ program
     .description('Show overall system status')
     .action(async () => {
     await cliConfig.init();
-    const isAuth = await cliConfig.isAuthenticated();
+    const verification = await cliConfig.verifyCurrentCredentialsWithServer().catch((error) => ({
+        valid: false,
+        method: 'none',
+        endpoint: undefined,
+        reason: error instanceof Error ? error.message : String(error)
+    }));
+    const isAuth = verification.valid;
     const apiUrl = cliConfig.getApiUrl();
     console.log(chalk.blue.bold('MaaS CLI Status'));
     console.log(`API URL: ${apiUrl}`);
     console.log(`Authenticated: ${isAuth ? chalk.green('Yes') : chalk.red('No')}`);
+    if (process.env.CLI_VERBOSE === 'true' && verification.endpoint) {
+        console.log(`Verified via: ${verification.endpoint}`);
+    }
     if (isAuth) {
         const user = await cliConfig.getCurrentUser();
         if (user) {
             console.log(`User: ${user.email}`);
             console.log(`Plan: ${user.plan}`);
         }
+        return;
     }
+    console.log(chalk.yellow(`Auth check: ${verification.reason || 'Credential validation failed'}`));
+    console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
 });
 // Health command using the healthCheck function
 program

package/dist/mcp/schemas/tool-schemas.d.ts

@@ -14,16 +14,16 @@ export declare const MemoryCreateSchema: z.ZodObject<{
     title?: string;
     content?: string;
     tags?: string[];
+    memory_type?: "context" | "reference" | "note";
     topic_id?: string;
     metadata?: Record<string, any>;
-    memory_type?: "context" | "reference" | "note";
 }, {
     title?: string;
     content?: string;
     tags?: string[];
+    memory_type?: "context" | "reference" | "note";
     topic_id?: string;
     metadata?: Record<string, any>;
-    memory_type?: "context" | "reference" | "note";
 }>;
 export declare const MemorySearchSchema: z.ZodObject<{
     query: z.ZodString;
@@ -36,16 +36,16 @@ export declare const MemorySearchSchema: z.ZodObject<{
     query?: string;
     tags?: string[];
     limit?: number;
+    memory_type?: "context" | "reference" | "note";
     topic_id?: string;
     threshold?: number;
-    memory_type?: "context" | "reference" | "note";
 }, {
     query?: string;
     tags?: string[];
     limit?: number;
+    memory_type?: "context" | "reference" | "note";
     topic_id?: string;
     threshold?: number;
-    memory_type?: "context" | "reference" | "note";
 }>;
 export declare const MemoryUpdateSchema: z.ZodObject<{
     memory_id: z.ZodString;
@@ -58,16 +58,16 @@ export declare const MemoryUpdateSchema: z.ZodObject<{
     title?: string;
     content?: string;
     tags?: string[];
+    memory_type?: "context" | "reference" | "note";
     memory_id?: string;
     metadata?: Record<string, any>;
-    memory_type?: "context" | "reference" | "note";
 }, {
     title?: string;
     content?: string;
     tags?: string[];
+    memory_type?: "context" | "reference" | "note";
     memory_id?: string;
     metadata?: Record<string, any>;
-    memory_type?: "context" | "reference" | "note";
 }>;
 export declare const MemoryDeleteSchema: z.ZodObject<{
     memory_id: z.ZodString;
@@ -90,17 +90,17 @@ export declare const MemoryListSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     tags?: string[];
     limit?: number;
-    topic_id?: string;
-    memory_type?: "context" | "reference" | "note";
     offset?: number;
+    memory_type?: "context" | "reference" | "note";
+    topic_id?: string;
     sort_by?: "title" | "created_at" | "updated_at";
     order?: "desc" | "asc";
 }, {
     tags?: string[];
     limit?: number;
-    topic_id?: string;
-    memory_type?: "context" | "reference" | "note";
     offset?: number;
+    memory_type?: "context" | "reference" | "note";
+    topic_id?: string;
     sort_by?: "title" | "created_at" | "updated_at";
     order?: "desc" | "asc";
 }>;
@@ -201,14 +201,14 @@ export declare const SystemConfigSchema: z.ZodObject<{
     scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
 }, "strip", z.ZodTypeAny, {
     value?: any;
-    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
+    key?: string;
 }, {
     value?: any;
-    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
+    key?: string;
 }>;
 export declare const BulkOperationSchema: z.ZodObject<{
     operation: z.ZodEnum<["create", "update", "delete"]>;
@@ -386,16 +386,16 @@ export declare const MCPSchemas: {
             title?: string;
             content?: string;
             tags?: string[];
+            memory_type?: "context" | "reference" | "note";
             topic_id?: string;
             metadata?: Record<string, any>;
-            memory_type?: "context" | "reference" | "note";
         }, {
             title?: string;
             content?: string;
             tags?: string[];
+            memory_type?: "context" | "reference" | "note";
             topic_id?: string;
             metadata?: Record<string, any>;
-            memory_type?: "context" | "reference" | "note";
         }>;
         search: z.ZodObject<{
             query: z.ZodString;
@@ -408,16 +408,16 @@ export declare const MCPSchemas: {
             query?: string;
             tags?: string[];
             limit?: number;
+            memory_type?: "context" | "reference" | "note";
             topic_id?: string;
             threshold?: number;
-            memory_type?: "context" | "reference" | "note";
         }, {
             query?: string;
             tags?: string[];
             limit?: number;
+            memory_type?: "context" | "reference" | "note";
             topic_id?: string;
             threshold?: number;
-            memory_type?: "context" | "reference" | "note";
         }>;
         update: z.ZodObject<{
             memory_id: z.ZodString;
@@ -430,16 +430,16 @@ export declare const MCPSchemas: {
             title?: string;
             content?: string;
             tags?: string[];
+            memory_type?: "context" | "reference" | "note";
             memory_id?: string;
             metadata?: Record<string, any>;
-            memory_type?: "context" | "reference" | "note";
         }, {
             title?: string;
             content?: string;
             tags?: string[];
+            memory_type?: "context" | "reference" | "note";
             memory_id?: string;
             metadata?: Record<string, any>;
-            memory_type?: "context" | "reference" | "note";
         }>;
         delete: z.ZodObject<{
             memory_id: z.ZodString;
@@ -462,17 +462,17 @@ export declare const MCPSchemas: {
         }, "strip", z.ZodTypeAny, {
             tags?: string[];
             limit?: number;
-            topic_id?: string;
-            memory_type?: "context" | "reference" | "note";
             offset?: number;
+            memory_type?: "context" | "reference" | "note";
+            topic_id?: string;
             sort_by?: "title" | "created_at" | "updated_at";
             order?: "desc" | "asc";
         }, {
             tags?: string[];
             limit?: number;
-            topic_id?: string;
-            memory_type?: "context" | "reference" | "note";
             offset?: number;
+            memory_type?: "context" | "reference" | "note";
+            topic_id?: string;
             sort_by?: "title" | "created_at" | "updated_at";
             order?: "desc" | "asc";
         }>;
@@ -579,14 +579,14 @@ export declare const MCPSchemas: {
             scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
         }, "strip", z.ZodTypeAny, {
             value?: any;
-            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
+            key?: string;
         }, {
             value?: any;
-            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
+            key?: string;
         }>;
     };
     operations: {

package/dist/utils/api.d.ts

@@ -54,11 +54,15 @@ export interface UpdateMemoryRequest {
     metadata?: Record<string, unknown>;
 }
 export interface GetMemoriesParams {
+    page?: number;
     limit?: number;
     offset?: number;
     memory_type?: MemoryType;
     tags?: string[] | string;
     topic_id?: string;
+    user_id?: string;
+    sort?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count' | 'title';
+    order?: 'asc' | 'desc';
     sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
     sort_order?: 'asc' | 'desc';
 }
@@ -148,6 +152,8 @@ export interface ApiErrorResponse {
 export declare class APIClient {
     private client;
     private config;
+    private normalizeMemoryEntry;
+    private shouldUseLegacyMemoryRpcFallback;
     constructor();
     login(email: string, password: string): Promise<AuthResponse>;
     register(email: string, password: string, organizationName?: string): Promise<AuthResponse>;

package/dist/utils/api.js

@@ -5,6 +5,41 @@ import { CLIConfig } from './config.js';
 export class APIClient {
     client;
     config;
+    normalizeMemoryEntry(payload) {
+        // API responses are inconsistent across gateways:
+        // - Some return the memory entry directly
+        // - Some wrap it in `{ data: <memory>, message?: string }`
+        if (payload && typeof payload === 'object') {
+            const obj = payload;
+            const directId = obj.id;
+            if (typeof directId === 'string' && directId.length > 0) {
+                return payload;
+            }
+            const data = obj.data;
+            if (data && typeof data === 'object') {
+                const dataObj = data;
+                if (typeof dataObj.id === 'string' && dataObj.id.length > 0) {
+                    return data;
+                }
+            }
+        }
+        return payload;
+    }
+    shouldUseLegacyMemoryRpcFallback(error) {
+        const status = error?.response?.status;
+        const errorData = error?.response?.data;
+        const message = `${errorData?.error || ''} ${errorData?.message || ''}`.toLowerCase();
+        if (status === 405) {
+            return true;
+        }
+        if (status === 400 && message.includes('memory id is required')) {
+            return true;
+        }
+        if (status === 400 && message.includes('method not allowed')) {
+            return true;
+        }
+        return false;
+    }
     constructor() {
         this.config = new CLIConfig();
         this.client = axios.create({
@@ -13,6 +48,8 @@ export class APIClient {
         // Setup request interceptor to add auth token and headers
         this.client.interceptors.request.use(async (config) => {
             await this.config.init();
+            // Keep OAuth sessions alive automatically (prevents intermittent "auth required" cutouts).
+            await this.config.refreshTokenIfNeeded();
             // Service Discovery
             await this.config.discoverServices();
             // Use appropriate base URL based on endpoint and auth method
@@ -20,17 +57,28 @@ export class APIClient {
             const discoveredServices = this.config.get('discoveredServices');
             const authMethod = this.config.get('authMethod');
             const vendorKey = await this.config.getVendorKeyAsync();
+            const token = this.config.getToken();
+            const isMemoryEndpoint = typeof config.url === 'string' && config.url.startsWith('/api/v1/memories');
+            const forceApiFromEnv = process.env.LANONASIS_FORCE_API === 'true'
+                || process.env.CLI_FORCE_API === 'true'
+                || process.env.ONASIS_FORCE_API === 'true';
+            const forceApiFromConfig = this.config.get('forceApi') === true
+                || this.config.get('connectionTransport') === 'api';
+            // Memory CRUD/search endpoints should always use the API gateway path.
+            const forceDirectApi = forceApiFromEnv || forceApiFromConfig || isMemoryEndpoint;
+            const prefersTokenAuth = Boolean(token) && (authMethod === 'jwt' || authMethod === 'oauth' || authMethod === 'oauth2');
+            const useVendorKeyAuth = Boolean(vendorKey) && !prefersTokenAuth;
             // Determine the correct API base URL:
             // - Auth endpoints -> auth.lanonasis.com
             // - JWT auth (no vendor key) -> mcp.lanonasis.com (supports JWT tokens)
             // - Vendor key auth -> api.lanonasis.com (requires vendor key)
             let apiBaseUrl;
-            const useMcpServer = !vendorKey && (authMethod === 'jwt' || authMethod === 'oauth' || authMethod === 'oauth2');
+            const useMcpServer = !forceDirectApi && prefersTokenAuth && !useVendorKeyAuth;
             if (isAuthEndpoint) {
                 apiBaseUrl = discoveredServices?.auth_base || 'https://auth.lanonasis.com';
             }
-            else if (vendorKey) {
-                // Vendor key works with api.lanonasis.com
+            else if (forceDirectApi) {
+                // Force direct REST API mode to bypass MCP routing for troubleshooting.
                 apiBaseUrl = this.config.getApiUrl();
             }
             else if (useMcpServer) {
@@ -51,8 +99,22 @@ export class APIClient {
                 config.headers['X-Project-Scope'] = 'lanonasis-maas';
             }
             // Enhanced Authentication Support
-            const token = this.config.getToken();
-            if (vendorKey) {
+            // Even in forced direct-API mode, prefer bearer token auth when available.
+            // This avoids accidentally sending an OAuth access token as X-API-Key (we store it
+            // in secure storage for MCP/WebSocket usage), which can cause 401s.
+            const preferVendorKeyInDirectApiMode = forceDirectApi && Boolean(vendorKey) && !prefersTokenAuth;
+            if (preferVendorKeyInDirectApiMode) {
+                // Vendor key authentication (validated server-side)
+                // Send raw key - server handles hashing for comparison
+                config.headers['X-API-Key'] = vendorKey;
+                config.headers['X-Auth-Method'] = 'vendor_key';
+            }
+            else if (prefersTokenAuth) {
+                // JWT/OAuth token authentication takes precedence when both are present.
+                config.headers.Authorization = `Bearer ${token}`;
+                config.headers['X-Auth-Method'] = 'jwt';
+            }
+            else if (vendorKey) {
                 // Vendor key authentication (validated server-side)
                 // Send raw key - server handles hashing for comparison
                 config.headers['X-API-Key'] = vendorKey;
@@ -69,7 +131,10 @@ export class APIClient {
             // Add project scope for Golden Contract compliance
             config.headers['X-Project-Scope'] = 'lanonasis-maas';
             if (process.env.CLI_VERBOSE === 'true') {
+                const transportMode = forceDirectApi ? 'api-forced' : (useMcpServer ? 'mcp-http' : 'api');
+                config.headers['X-Transport-Mode'] = transportMode;
                 console.log(chalk.dim(`→ ${config.method?.toUpperCase()} ${config.url} [${requestId}]`));
+                console.log(chalk.dim(`  transport=${transportMode} baseURL=${config.baseURL}`));
             }
             return config;
         });
@@ -84,7 +149,7 @@ export class APIClient {
                 const { status, data } = error.response;
                 if (status === 401) {
                     console.error(chalk.red('✖ Authentication failed'));
-                    console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+                    console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
                     process.exit(1);
                 }
                 if (status === 403) {
@@ -127,22 +192,207 @@ export class APIClient {
     // All memory endpoints use /api/v1/memories path (plural, per REST conventions)
     async createMemory(data) {
         const response = await this.client.post('/api/v1/memories', data);
-        return response.data;
+        return this.normalizeMemoryEntry(response.data);
     }
     async getMemories(params = {}) {
-        const response = await this.client.get('/api/v1/memories', { params });
-        return response.data;
+        try {
+            const response = await this.client.get('/api/v1/memories', { params });
+            return response.data;
+        }
+        catch (error) {
+            // Backward-compatible fallback: newer API contracts may reject GET list.
+            if (error?.response?.status === 405) {
+                const limit = Number(params.limit || 20);
+                const page = Number(params.page || 1);
+                const offset = Number(params.offset ?? Math.max(0, (page - 1) * limit));
+                // Preferred fallback: POST list endpoint (avoids triggering vector search for plain listings).
+                const listPayload = {
+                    limit,
+                    offset
+                };
+                if (params.memory_type) {
+                    listPayload.memory_type = params.memory_type;
+                }
+                if (params.tags) {
+                    listPayload.tags = Array.isArray(params.tags)
+                        ? params.tags
+                        : String(params.tags).split(',').map((tag) => tag.trim()).filter(Boolean);
+                }
+                if (params.topic_id) {
+                    listPayload.topic_id = params.topic_id;
+                }
+                if (params.user_id) {
+                    listPayload.user_id = params.user_id;
+                }
+                if (params.sort || params.sort_by) {
+                    listPayload.sort_by = params.sort_by || params.sort;
+                }
+                if (params.order || params.sort_order) {
+                    listPayload.sort_order = params.sort_order || params.order;
+                }
+                for (const endpoint of ['/api/v1/memories/list', '/api/v1/memory/list']) {
+                    try {
+                        const listResponse = await this.client.post(endpoint, listPayload);
+                        const payload = listResponse.data || {};
+                        const resultsArray = Array.isArray(payload.data)
+                            ? payload.data
+                            : Array.isArray(payload.memories)
+                                ? payload.memories
+                                : Array.isArray(payload.results)
+                                    ? payload.results
+                                    : [];
+                        const memories = resultsArray.map((entry) => this.normalizeMemoryEntry(entry));
+                        const pagination = (payload.pagination && typeof payload.pagination === 'object')
+                            ? payload.pagination
+                            : {};
+                        const total = Number.isFinite(Number(pagination.total))
+                            ? Number(pagination.total)
+                            : Number.isFinite(Number(payload.total))
+                                ? Number(payload.total)
+                                : memories.length;
+                        const pages = Number.isFinite(Number(pagination.total_pages))
+                            ? Number(pagination.total_pages)
+                            : Number.isFinite(Number(pagination.pages))
+                                ? Number(pagination.pages)
+                                : Math.max(1, Math.ceil(total / limit));
+                        const currentPage = Number.isFinite(Number(pagination.page))
+                            ? Number(pagination.page)
+                            : Math.max(1, Math.floor(offset / limit) + 1);
+                        const hasMore = typeof pagination.has_more === 'boolean'
+                            ? pagination.has_more
+                            : typeof pagination.has_next === 'boolean'
+                                ? pagination.has_next
+                                : (offset + memories.length) < total;
+                        return {
+                            ...payload,
+                            data: memories,
+                            memories,
+                            pagination: {
+                                total,
+                                limit,
+                                offset,
+                                has_more: hasMore,
+                                page: currentPage,
+                                pages
+                            }
+                        };
+                    }
+                    catch (listError) {
+                        if (listError?.response?.status === 404 || listError?.response?.status === 405) {
+                            continue;
+                        }
+                        throw listError;
+                    }
+                }
+                // Secondary fallback: search endpoint for legacy contracts that expose only search.
+                const searchPayload = {
+                    query: '*',
+                    limit,
+                    threshold: 0
+                };
+                if (params.memory_type) {
+                    searchPayload.memory_types = [params.memory_type];
+                }
+                if (params.tags) {
+                    searchPayload.tags = Array.isArray(params.tags)
+                        ? params.tags
+                        : String(params.tags).split(',').map((tag) => tag.trim()).filter(Boolean);
+                }
+                if (params.topic_id) {
+                    searchPayload.topic_id = params.topic_id;
+                }
+                if (offset > 0) {
+                    searchPayload.offset = offset;
+                }
+                const fallback = await this.client.post('/api/v1/memories/search', searchPayload);
+                const payload = fallback.data || {};
+                const resultsArray = Array.isArray(payload.data)
+                    ? payload.data
+                    : Array.isArray(payload.results)
+                        ? payload.results
+                        : [];
+                const memories = resultsArray
+                    .map((entry) => {
+                    // Some gateways/search endpoints wrap results as `{ data: <memory> }`.
+                    if (entry && typeof entry === 'object') {
+                        const obj = entry;
+                        const data = obj.data;
+                        if (data && typeof data === 'object') {
+                            const dataObj = data;
+                            if (typeof dataObj.id === 'string' && dataObj.id.length > 0) {
+                                return data;
+                            }
+                        }
+                    }
+                    return entry;
+                })
+                    .map((entry) => this.normalizeMemoryEntry(entry));
+                const total = Number.isFinite(payload.total) ? Number(payload.total) : memories.length;
+                const pages = Math.max(1, Math.ceil(total / limit));
+                const currentPage = Math.max(1, Math.floor(offset / limit) + 1);
+                return {
+                    ...payload,
+                    data: memories,
+                    memories,
+                    pagination: {
+                        total,
+                        limit,
+                        offset,
+                        has_more: (offset + memories.length) < total,
+                        page: currentPage,
+                        pages
+                    }
+                };
+            }
+            throw error;
+        }
     }
     async getMemory(id) {
-        const response = await this.client.get(`/api/v1/memories/${id}`);
-        return response.data;
+        try {
+            const response = await this.client.get(`/api/v1/memories/${id}`);
+            return this.normalizeMemoryEntry(response.data);
+        }
+        catch (error) {
+            if (this.shouldUseLegacyMemoryRpcFallback(error)) {
+                const fallback = await this.client.post('/api/v1/memory/get', { id });
+                const payload = fallback.data && typeof fallback.data === 'object'
+                    ? fallback.data.data ?? fallback.data
+                    : fallback.data;
+                return this.normalizeMemoryEntry(payload);
+            }
+            throw error;
+        }
     }
     async updateMemory(id, data) {
-        const response = await this.client.put(`/api/v1/memories/${id}`, data);
-        return response.data;
+        try {
+            const response = await this.client.put(`/api/v1/memories/${id}`, data);
+            return this.normalizeMemoryEntry(response.data);
+        }
+        catch (error) {
+            if (this.shouldUseLegacyMemoryRpcFallback(error)) {
+                const fallback = await this.client.post('/api/v1/memory/update', {
+                    id,
+                    ...data
+                });
+                const payload = fallback.data && typeof fallback.data === 'object'
+                    ? fallback.data.data ?? fallback.data
+                    : fallback.data;
+                return this.normalizeMemoryEntry(payload);
+            }
+            throw error;
+        }
     }
     async deleteMemory(id) {
-        await this.client.delete(`/api/v1/memories/${id}`);
+        try {
+            await this.client.delete(`/api/v1/memories/${id}`);
+        }
+        catch (error) {
+            if (this.shouldUseLegacyMemoryRpcFallback(error)) {
+                await this.client.post('/api/v1/memory/delete', { id });
+                return;
+            }
+            throw error;
+        }
     }
     async searchMemories(query, options = {}) {
         const response = await this.client.post('/api/v1/memories/search', {

package/dist/utils/config.d.ts

@@ -34,6 +34,12 @@ interface CLIConfigData {
     lastAuthFailure?: string | undefined;
     [key: string]: unknown;
 }
+export type RemoteAuthVerification = {
+    valid: boolean;
+    method: 'token' | 'vendor_key' | 'none';
+    endpoint?: string;
+    reason?: string;
+};
 export declare class CLIConfig {
     private configDir;
     private configPath;
@@ -70,6 +76,11 @@ export declare class CLIConfig {
     private resolveFallbackEndpoints;
     private logFallbackUsage;
     private pingAuthHealth;
+    private getAuthVerificationEndpoints;
+    private extractAuthErrorMessage;
+    private verifyTokenWithAuthGateway;
+    private verifyVendorKeyWithAuthGateway;
+    verifyCurrentCredentialsWithServer(): Promise<RemoteAuthVerification>;
     setManualEndpoints(endpoints: Partial<CLIConfigData['discoveredServices']>): Promise<void>;
     hasManualEndpointOverrides(): boolean;
     clearManualEndpointOverrides(): Promise<void>;